Skip to content

Releases

1.21.0

Choose a tag to compare

@github-actions github-actions released this 20 Nov 16:29
feea92b

Changed

  • Every first-party assembly now multi-targets net10.0;net11.0 (ADR 0015). .NET 11 shipped on 2026-11-10; .NET 8 and .NET 9 reached end of support the same day. ADR 0015's rule is to add a TFM the day a release ships and drop one the day Microsoft ends its support, so this is that rule firing for the first time rather than a judgement call.

    global.json pins SDK 11.0.100. That pin is load-bearing: SDK 10 cannot target net11.0, and rollForward: latestFeature will not cross a major version, so an environment without SDK 11 fails the build outright instead of quietly producing net10-only packages.

    If you target net8.0 or net9.0, stay on 1.20.0 — 1.21.0 carries no assets your project can resolve, and restoring it fails with NU1202 rather than falling back. Please read the next entry before you do: 1.20.0 is also the last release carrying a SARIF severity bug, and it is a security-relevant one.

  • Tamp.NetCli.V8 and Tamp.NetCli.V9 are retargeted, not retired. Their assemblies now load on net10.0 / net11.0, and they still wrap the dotnet 8 and dotnet 9 CLIs exactly as before. Which runtime a wrapper runs on and which CLI it drives are independent axes (ADR 0015), and locked-down environments keep older SDKs installed for years past EOL. Nothing about these packages' purpose changed.

  • SARIF: an absent level now reads as Warning on every target framework, instead of None on some of them (#166). This is a behaviour change with security consequences, and the reason it surfaced now is worth stating.

    Tamp.Sarif's schema records are records with non-nullable properties carrying initializers — SarifLevel Level { get; init; } = SarifLevel.Warning, and eleven others. A property initializer like that is only honoured if the deserializer leaves absent JSON members alone. .NET 11's System.Text.Json source generator leaves them alone. Every earlier runtime overwrites the member with default(T). default(SarifLevel) is None.

    So on net8, net9 and net10 — every runtime Tamp has ever shipped on — a SARIF result whose scanner omitted level was read as SarifLevel.None, the least severe value, where the declared default was Warning. Omitting it is legal: SARIF 2.1.0 §3.27.10 defers to the rule's defaultConfiguration, which itself defaults to warning. And because the value then round-tripped, Tamp wrote "level": "none" back into the evidence file — a finding of unknown severity recorded as benign. SecurityPipelineMetrics.LevelToTag tags the metric a gate reads from that value, so such a finding sat below any "warning and above" threshold. The other initialized properties could come back null the same way; log.Runs[0] on a log with no runs member threw a NullReferenceException.

    Fixed by enforcing each declared default in the accessor rather than trusting the runtime: readonly backing fields with coercing init accessors. Deliberate choices inside that fix —

    • Coercion is null-only, not IsNullOrEmpty. SarifMerge.Combine picks the first non-empty Version / Schema across logs, which requires new SarifLog { Version = "" } to stay expressible.
    • Level keeps a nullable LevelRaw companion ([JsonPropertyName("level")]) so an explicit "level": "none" stays None and an absent one stays absent on write. Defaulting on read must not become asserting on write.
    • SarifLog.Schema lost its initializer entirely; SarifWriter now stamps SarifLog.CanonicalSchema on any log that has none. A property default would have been clobbered on read by every pre-net11 runtime, which is the whole bug — and SarifMerge needs "no schema" to survive a parse as null.

    Nine regression tests in SarifDefaultsTests.cs pin this, and they run per-TFM: revert the source fix and they fail on net10 and pass on net11, which is how the cause was confirmed rather than inferred.

Added

  • Tamp.NetCli.V11 — wrapper for the .NET 11 SDK CLI, starting at its own version per ADR 0002. Same surface as Tamp.NetCli.V10.

  • Tamp.Components.NetCli.V11 — concrete dotnet bodies for the Tamp.Components target shapes (ADR 0020) driving the dotnet 11 CLI. ADR 0015 only commits to the NetCli.V{N} package, but a consumer whose build script targets net11.0 and composes via Tamp.Components needs this one: Tamp.Components.NetCli.V10 drives SDK 10, which cannot build net11.0 projects at all.

  • SarifLog.CanonicalSchema — the SARIF 2.1.0 schema URI every log Tamp writes carries, exposed so consumers can assert on it instead of hardcoding the string.

  • The shipped version is announced on an issue when its release is published (#164). CONTRIBUTING.md required every closing comment to name its release, but an issue closed before the release is cut can only promise one — and the promise is what gets forgotten. #151 and #155 were both closed with "I will comment the version when it is cut", both shipped in 1.20.0, and neither got the comment. The link existed in one direction only: from the release notes to the issue, never back.

    release.yml now runs .github/scripts/announce-release.sh after creating the Release. An issue is announced when both its number appears in the release notes and it carries the new awaiting-release label. The intersection is deliberate: notes also cite issues for context ("tracked in #162", "see the epic #58"), so announcing on every cited issue would claim a version for work that did not ship — a false statement, which is worse than a missing comment. Announcing on every labelled issue would be wrong the other way, for a fix merged after the tag. A missing comment is recoverable and the label keeps it visible; a wrong one is not.

    Never fails a release: by that point the packages are public and irreversible, so a problem announcing is a warning and nothing more. The script is dependency-free so it copies into the satellites.

    The publish job gains issues: write, scoped to that job alone.

    #151 and #155 have been backfilled with 1.20.0.


Packages for this release are on nuget.org, and the attached .nupkg files are the exact artifacts that were pushed.

1.20.1

Choose a tag to compare

@github-actions github-actions released this 20 Nov 20:37

Patch release off the v1.20.0 tag. It carries only the #166 fix and still targets net8.0;net9.0;net10.0, for consumers who cannot move to 1.21.0 because that release drops both EOL frameworks.

Fixed

  • A finding whose scanner omitted level was recorded as benign (#166). Tamp.Sarif's schema records declare their defaults as property initializers — SarifLevel Level { get; init; } = SarifLevel.Warning, and eleven others. An initializer like that is only honoured if the deserializer leaves absent JSON members alone. .NET 11's System.Text.Json source generator does; every earlier runtime overwrites the member with default(T).

    default(SarifLevel) is None. So on net8, net9 and net10 — every runtime this release line runs on — a result whose scanner legally omitted level was read as the least severe value where the declared default was Warning. Omitting it is legal: SARIF 2.1.0 §3.27.10 defers to the rule's defaultConfiguration, which itself defaults to warning. The value then round-tripped, so Tamp wrote "level": "none" back into the evidence file, and SecurityPipelineMetrics.LevelToTag tags the metric a gate reads from it — a finding of unknown severity sat below any "warning and above" threshold, recorded as benign. log.Runs[0] on a log with no runs threw an NRE for the same reason.

    Every declared default is now written into the document by SarifReader before deserialization, so no default depends on the runtime. Only an absent member is filled: an explicit "level": "none" is a deliberate statement by the scanner and is preserved exactly.

Notes for anyone comparing this with 1.21.0

  • This is a re-implementation, not a backport. 1.21.0 enforces each default in the property accessor over a readonly backing field, exposing the raw nullable under the wire name with [JsonIgnore] on the resolved property. That shape cannot run on net8 or net9 at all: [JsonIgnore] on a property with an init accessor makes the .NET 8/9 JSON source generator emit a parameterized-constructor deserialization path, which throws ConstructorParameterIncompleteBinding on every parse and makes SarifResult entirely undeserializable. Since this line exists precisely to serve net8/net9, the fix had to be built differently.

  • The public API is unchanged from 1.20.0. Level remains a settable SarifLevel named level, so a satellite that constructs SARIF (Tamp.McpScanner, Tamp.AxeCore) still compiles. There is no new LevelRaw member on this line.

  • One behavioural difference from 1.21.0. 1.21.0 preserves the distinction between "level absent" and "level explicitly warning" across a round trip; this release does not — an absent level is materialised as "warning" and written back that way. Per SARIF 2.1.0 §3.27.10 the two are semantically the same claim, and it is in any case strictly better than the "none" 1.20.0 writes.

  • A log with no $schema is now tagged with SarifLog.CanonicalSchema on write, applied in SarifWriter rather than as a property default for the same reason as above. An explicit $schema is preserved.

Upgrading is still the better move where you can. This release freezes you on frameworks Microsoft stopped supporting on 2026-11-10; it fixes the severity bug but nothing after it. ADR 0015 is amended to record what a stranded pin costs: it freezes the consumer's bugs along with their runtime.


Packages for this release are on nuget.org, and the attached .nupkg files are the exact artifacts that were pushed.

1.20.0

Choose a tag to compare

@github-actions github-actions released this 05 Nov 16:24
7cd099c

Added

  • Corroboration between two tools is recorded instead of discarded (#156). SarifDedup.Distinct collapses duplicates across runs, so a finding two tools both reported was kept on whichever run came first in input order and the other tool's run showed nothing for it — with no record that it concurred. Agreement between two independent scanners is a signal, and a finding both tools see is worth triaging differently from one only one tool sees.

    The surviving result now carries tamp.alsoReportedBy (SarifDedup.AlsoReportedByProperty), a JSON array of the other tools' driver names in input order. Counts do not move — still one result per finding, which is what makes CombineDistinct useful; use SarifMerge.Combine when a consumer needs a result per reporting tool instead.

    The property is written only when a different tool's copy was dropped, so the multi-TFM Roslyn case the helper exists for adds nothing: "roslyn also reported this roslyn finding" is noise, not a second opinion. An uncorroborated finding gets no property at all, which is the distinction worth having. A run whose tool has no driver name is recorded as (unnamed tool) rather than silently omitted.

    The property name is public contract from here. Implementation note: the JsonElement is built with Utf8JsonWriter rather than JsonSerializer.SerializeToElement, because Tamp.Sarif is source-generation-only to stay AOT- and trimming-friendly and the reflection-based serialiser throws without a type-info resolver.

  • SarifDedup.Distinct(log, keySelector) and SarifMerge.CombineDistinct(logs, keySelector) (#155) — a key seam, so a caller with package-level findings is not forced to choose between full dedup and none. SarifDedup.ComputeKey is promoted to public SarifDedup.DefaultKey so a selector can compose onto it rather than reimplement it, which is what callers usually want: $"{SarifDedup.DefaultKey(r)}|{purl}".

    No built-in "package key" is offered, deliberately: where component identity lives is producer-specific, and a built-in would have to guess.

    Producer fingerprints are deliberately not the default key, even though SARIF nominates fingerprints / partialFingerprints as a result's identity — a fingerprint is only as good as the producer. grype 0.112.0's primaryLocationLineHash identifies the package-version rather than the finding, with 35 distinct advisories against one package version sharing a fingerprint, so the same 299 results carry just 62 distinct fingerprints. Preferring them would turn a 10% collapse into a 79% one. There is a test pinning that.

  • An enforcement stage, after publication rather than before it (#151). Both publishing targets depended on the scan targets, so the natural way to add a gate — failing a scan on findings — skipped SecurityPush and SecurityMetrics, and therefore the SBOM push, the SARIF upload and the metrics, in exactly the runs where findings existed. Evidence arrived reliably when there was nothing to report and unreliably when there was.

    tamp Security is now three ordered stages: collect (SecurityCollect) → publish (SecurityMetrics + SecurityPush, unconditional) → enforce (SecurityGate). Every stage from collect onward is AssuredAfterFailure(), so failing the gate costs no evidence and one scanner crashing does not suppress the others' output.

  • EnforceSecurityPolicy(SecurityEvidenceSummary) — the policy seam, called by SecurityGate after both publishing targets. Default implementation does nothing: a severity threshold is the adopter's decision, not core's. The summary carries per-scanner counts, FindingsAtOrAbove(level), the SBOM, publication outcomes and ReliabilityProblems.

  • An evidence receipt at artifacts/security/security-receipt.json (SecurityReceiptFile), written before the gate throws — the run where evidence matters most is the run where something went wrong. findings is null, not 0, for a scan with no result, so a reader cannot mistake "no result" for "found nothing". A green publishing job is weak evidence that a consumer accepted anything, since most ingestion is asynchronous; the receipt is what gives a missing report a single meaning.

  • SecurityExpectedScans — the scans the pipeline expects, which is what turns "did this scan run?" into an answerable question. An adopter who deliberately drops a scanner removes it here, stating that the surface is not covered rather than leaving a silent gap. The merged sast.sarif is deliberately not in the set: it derives from the OpenGrep and Roslyn outputs, and counting it too would double every SAST finding.

  • SecurityPublicationStatus distinguishes NotConfigured (credentials unset — still a green outcome, as before) from Completed, Incomplete and Failed. An unsettled Dependency-Track analysis is now Incomplete and fails the gate rather than passing as a successful push.

Changed

  • SecurityGate fails by default when the evidence cannot be relied on — an expected scan that did not run, an unreadable output, an absent or empty SBOM, or a publication that was attempted and did not land. This is evidence integrity, not severity policy.

    This is the one behavioural change that can fail a build that used to pass. A scanner that is not installed previously produced a skipped target, zero findings and a green build. Three ways to go green again, the first two being the honest ones: install the scanner; remove it from SecurityExpectedScans; or set SecurityRequireReliableEvidence to false, which keeps the receipt and the status metrics so the gap stays visible even though it no longer blocks. Tamp's own CI is unaffected — nothing in it invokes the aggregate Security target.

    An SBOM that parsed but holds zero components counts as unreliable: every SCA result derived from it is vacuously clean, which is the most convincing kind of false negative.

  • Roslyn findings emit one status point per scan rather than one per file. The Roslyn leg writes one SARIF per (project, TFM); those are now read as a single scan, so a corrupt file among them makes the whole scan Unreadable rather than silently understating the surface by an unmeasurable amount. Findings totals and tag keys are unchanged — they are still summed across files, not deduplicated.

Fixed

  • SarifMerge.CombineDistinct no longer documented as the general multi-tool path (#155). It was described as "the common path when stitching together SARIF from sources that re-analyse the same source per TFM (Roslyn) or scan overlapping directories (multi-tool pipelines)", and the dedup key — (ruleId, URI, line, column, logical fullyQualifiedName) — has no component or version term of its own. A dependency scanner reports the advisory as ruleId, the lockfile as the URI, the same line for every result and the affected version only in the message text, so distinct affected versions of one package collapsed into a single result: the defect fixed in tamp-grype#6, re-introduced by anyone following the documentation. Measured on grype 0.112.0's native SARIF, 299 results collapse to 268.

    The guidance is now a condition rather than a category, because the key already has a slot for component identity: CombineDistinct is safe when the producer puts it in logicalLocations.fullyQualifiedName, and not when the producer puts the path there or omits logical locations. Tamp.Grype 0.2.0 puts the purl there, and the same document passes through 299 → 299.

    Also documents the attribution effect: duplicates are collapsed across runs, so a finding two tools both reported is attributed to whichever run came first in input order. Every run survives, so "which tools ran" stays answerable; "which tools found this" does not. The class summary previously read as a stronger guarantee than CombineDistinct gives. The behavioural fix ships alongside — see #156 under Added.

    No live misuse existed in the fleet: the only callers are the OpenGrep + per-TFM Roslyn merge in SecurityPipelineBuild.SecurityScan, which is exactly the case the helper was built for. That call site now carries a comment saying why it is correct there, and why the CVE and Trivy SARIFs must not be added to it.

  • A skipped security scan no longer reports as a clean one (#151). SecurityPipelineMetrics.EmitFindingsFromSarif returned 0 when the SARIF did not exist, and EmitComponentsFromBom did the same for a missing BOM, so tamp.security.scan.findings_count emitted the same observation — nothing — for "this scanner ran and found nothing" and "this scanner never ran". An unsettled Dependency-Track analysis likewise logged a line and let SecurityPush go green. In all three places an unknown outcome was reported as a good one, which is the failure direction a security control must never take.

    Evidence now carries its own reliability instead of having it inferred from a count: SecurityEvidenceStatus is NotRun, Unreadable or Completed, and only the last makes a count of zero mean "looked and found nothing". New readers ReadSarifScan, ReadSarifScanDirectory, ReadScan and ReadBom return a SecurityScanReport / SecuritySbomReport saying why there is no result. EmitFindingsFromSarif and EmitComponentsFromBom keep their signatures and now emit the status too, so existing callers get the fix without a change.

    Two new counters carry the signal findings_count structurally cannot: tamp.security.scan.status and **`tamp.security.sbom.stat...

Read more

1.19.0

Choose a tag to compare

@BrewingCoder BrewingCoder released this 05 Nov 15:40
14ddede

Added

  • tamp migrate nuke, preview. Tamp.Migrate is now packable, and tamp migrate … runs it at the CLI's own version through dotnet tool execute (.NET 10 SDK; on older SDKs, install it with dotnet tool install -g Tamp.Migrate). Beyond the C# rewrite, it now rewrites the NUKE build project in place: Nuke.* references and properties go, and Tamp.Core plus the wrapper packages the build uses are added. It writes tamp init's bootstrap (tamp.sh, tamp.cmd, and dotnet-tamp in the tool manifest, from the same source as tamp init), and refuses to run on a dirty git working tree (--allow-dirty overrides). A first dogfood on NSwag's NUKE build (docs/nuke-migration/dogfood-nswag.md) found and fixed these silent failures:
    • the template Configuration class
    • qualified Serilog.Log calls
    • NUKE settings types that silently resolve to Tamp's
    • Configure<T> and lifecycle hooks
    • Solution.AllProjects, via a new member match kind
    • a wrong [GitRepository] row
  • Solution converts to its path wherever a string is expected, as AbsolutePath already does and as NUKE's Solution does, so DotNet.Build(s => s.SetProject(Solution)) compiles. It also makes the migrator's auto row SetProjectFile(Solution) → SetProject(Solution) correct as written. Before, the converted build didn't compile when the argument was a Solution.
  • Tamp.Migrate: the NUKE → Tamp rewriter (#131, ADR 0021 Phase 2a). A separate dotnet tool, tamp-migrate nuke [--root] [--build-dir] [--dry-run] [--package-major], so Roslyn stays out of the tamp tool every CI run installs (the packaging ADR 0021 settled). It parses the NUKE build with no restore and no compile, and applies the auto rows of the embedded mapping.yaml. No rule is hardcoded: base class, Main → Execute<T>(args) plus .Default() on the target (across partial files), usings (from a new namespaces: table), injection attributes, path helpers, the target DSL, and DotNetTasks.* → DotNet.* with every setting rewritten per the mapping. A call that ran a tool becomes ProcessRunner.Run(DotNet.X(..)) in a statement, or the returned plan in Executes(() => ..). Every other recognised site gets a // TAMP-MIGRATE(<rule-id>): <what to do> marker and is left alone, including unmapped verbs and settings, tool results that are used, families that aren't auto, and known gaps. tamp-migration.json / .md count each site as applied, assisted, manual or unmapped. A second run changes nothing.

Changed

  • NUKE migration mapping, schema 0.2 (#58, Phase 2 step 1). docs/nuke-migration/mapping.yaml is now what tamp migrate nuke will apply. Every rule has a stable id, a match and rewrite from a closed vocabulary, a marker for anything not auto, and verify: the Tamp symbols it relies on. The new tests/Tamp.Migrate.Tests checks those symbols against Tamp.Core, Tamp.NetCli and Tamp.Components by reflection. That check corrected six rows of the reference:

    • CreateOrCleanDirectory maps to DeleteDirectory().CreateDirectory(), and Copy / Move map to CopyTo / MoveTo. CopyFile, MoveFile and CreateOrCleanDirectory don't exist in Tamp.
    • Serilog Log.* maps to console output, which Tamp captures per target. Build code has no Log.
    • NUKE's .Consumes(Target) can't be kept by name: Tamp's Consumes is a concurrency resource.
    • Calling a [PathExecutable] tool becomes Tool.Plan(...).
    • IsServerBuild maps 1:1.
    • Components are covered (shipped in 1.17).

    New rows: CI-generation attributes, .Unlisted() → .Internal(), .Description, unmapped DSL calls, unshipped components, and more DotNet settings. Scope is NUKE 8+. ADR 0021 is accepted, with the Phase 2 design. The migration moves to 1.19 on the roadmap.

  • Sonar new-code reliability findings cleared (#132): ~45 sync-over-async call sites in tools/findings-ingest (S6966), the self-build script moved into a named namespace (S3903), and a test without an assertion (S2699). PollingTests now runs on a virtual TimeProvider (#142), so its assertions no longer depend on how fast the machine is; Polling.Until takes the clock internally.

Fixed

  • tamp migrate no longer suggests installing the .NET 10 SDK when the migration itself declined to run. The forwarder printed its "dotnet tool execute needs the .NET 10 SDK; install Tamp.Migrate instead" hint on any non-zero exit, so a refusal on a dirty working tree came back with correct advice followed by irrelevant advice. The hint is now printed only for an exit code Tamp.Migrate does not produce itself, i.e. only when dotnet tool execute never got the tool running.

Security

  • Every OS command Tamp launches is resolved to an absolute path first (#133, Sonar S4036). git, dotnet, macOS security and Linux secret-tool went through the OS's own lookup, which on Windows searches the working directory before PATH and on every OS treats a relative or empty PATH entry as the current directory — so a planted git.exe in a checkout could be handed a secret. The new ExecutableLocator walks PATH itself, refuses relative entries and anything inside the current or the launch working directory, and prefers a known location where one exists (/usr/bin/security; the running dotnet host, then DOTNET_ROOT, so a repo-local SDK still works). [FromPath] tools keep the lenient walk: a tool the build deliberately puts on PATH under its own tree is a deliberate choice.
  • Tamp.Core's regexes run under one shared match timeout (#134, Sonar S6444). TampRegex holds the single timeout and surfaces a hit as an InvalidDataException naming what was being parsed — never as "no match", which would silently drop a project from a solution or lose a remote URL. The .git/config remote-URL pattern was also rewritten off a lazy .+? followed by \s*$, which re-tried at every character and went quadratic on a long whitespace run.
  • CI and Release pin every external action to a commit SHA, and id-token: write is scoped to the publish job alone (#135, Sonar S7637/S8233). A moved tag on an action in the publish job would otherwise have handed a third party the OIDC token that mints a nuget.org key. Dependabot now watches the pinned SHAs.

Backfilled: this version was published to nuget.org at the time but no GitHub Release was created (tamp#159). Notes are this version's CHANGELOG.md section, unedited.

1.18.0

Choose a tag to compare

@BrewingCoder BrewingCoder released this 05 Nov 15:40
7944807

Added

  • Build-wide cancellation and orderly interrupts (#125, part 1). tamp now handles Ctrl+C, SIGTERM and SIGHUP itself instead of being killed mid-build:
    • The first signal cancels the new TampBuild.BuildCancellation token (also passed to the new Executes(async ct => ...) overloads) and ProcessRunner kills the running tool's whole process tree and starts nothing new.
    • The running target finishes with the new status cancelled (reason: "signal: SIGINT"; no remedy, no failure handlers), later targets are not_run, and AssuredAfterFailure cleanup targets still run with a fresh token that cancels when the shutdown grace period ends (default 10 s, --shutdown-timeout <seconds> / TAMP_SHUTDOWN_TIMEOUT).
    • build.finished reports status: "cancelled", reason and a cancelled count, and the exit code is 128 + signal on every OS (130 SIGINT, 143 SIGTERM, 129 SIGHUP).
    • A second signal, or the grace period running out, forces the exit after killing child process trees.
    • Also: ProcessCancelledException, ExecutionResult.InterruptSignal, IBuildReporter.OnTargetCancelled (defaults to OnTargetNotRun), the tamp mcp run summary's status / reason, and the cancelled ADR-0018 outcome. Additive; the event schema stays 1.0.
  • service.ready / service.stopped events for long-running services (#124). A target that starts a dev server, emulator or other long-running process can now say when it is usable (kind, url, optional port, pid, processStartTime, readinessProbe, statePath) and when and why it stopped (reason: requested | signal | exited | timeout, plus optional pid, exitCode, durationMs). The reason lets consumers tell a deliberate shutdown from a failure: a killed service reports a non-zero tool.exited code even when nothing went wrong. Emitted with BuildEvents.ServiceReady(...) / BuildEvents.ServiceStopped(...), which can share the service's tool.invoked command span; url and readinessProbe are scrubbed through the redaction table. Additive: the schema version stays 1.0. See docs/agent-first.md.
  • ManagedProcess: a long-running child process for targets that start a dev server, emulator or similar (#125, part 2). ManagedProcess.StartAsync(plan, options) emits tool.invoked, waits for a Readiness check (Http with optional loopback self-signed TLS, Tcp, OutputMatches, When), then service.ready, all on one command span parented to the starting target. Disposing it kills the whole process tree (optionally SIGTERM first on Unix) and records service.stopped (requested) and tool.exited; the stop is idempotent and safe across threads. An early exit throws with the output tail (exited), a readiness timeout throws TimeoutException (timeout), and an exit on its own after ready is recorded at once (exited). The executor stops managed processes on an interrupt (signal), kills them on a forced exit, and stops any still running when the build ends, so a service can serve later targets but never outlives the build.

Changed

  • Event sinks are now written under a lock, so an event emitted off the build thread (a forced exit) can't interleave with the main loop's.

Backfilled: this version was published to nuget.org at the time but no GitHub Release was created (tamp#159). Notes are this version's CHANGELOG.md section, unedited.

1.17.6

Choose a tag to compare

@BrewingCoder BrewingCoder released this 05 Nov 15:40
e2564cf

Fixed

  • tamp init's tamp.cmd no longer prints a stray 'm' is not recognized error on Windows (#120). The shim's C# raw string carried the line endings of whatever checkout the CLI was compiled from (LF on the ubuntu release runner) and the first rem line held a UTF-8 em dash; under console code page 437, cmd.exe misreads an LF-only batch file containing a multi-byte character and runs a fragment of a later line. The shim is now always emitted with CRLF line endings, whatever OS built the CLI, and is pure ASCII. tamp.sh is likewise pinned to LF. The %~dp0 trailing-backslash trim (not the cause) was dropped and paths now join directly onto %~dp0, which always ends in \. Existing repos keep their broken copy: the shim is written with SkipIfExists, so delete tamp.cmd and re-run tamp init (or convert it to CRLF and replace the em dash by hand) to pick up the fix.
  • tamp init scaffolds the newest released Tamp, not the CLI's own version. init used to pin Tamp.Core, Tamp.NetCli.V10 and the dotnet-tamp local tool to the running CLI's version, so a 1.17.3 CLI produced a 1.17.3 build project. Adding a satellite built against a newer core (Tamp.Heft.V1 0.1.0 requires Tamp.Core >= 1.17.5) then failed restore with NU1605 and nothing said why. init now looks up the newest stable Tamp.Core on the NuGet v3 flat-container feed (nuget.org by default; TAMP_INIT_FEED_URL points it at a mirror) with a 5 s cap, never picks a version older than the CLI, and pins all three to it. It prints the version and where it came from, and suggests dotnet tool update -g dotnet-tamp when the CLI is older than the scaffold. Offline, on timeout or on a bad response it falls back to the CLI's version with a one-line note; init never fails because the feed is unreachable. New --tamp-version <x> pins a version explicitly and skips the lookup. (#119)
  • Actionable message when a satellite needs a newer Tamp.Core. When dispatch to the build project (tamp <target>, and tamp mcp runs) fails and restore reported NU1605 on a Tamp.* package, the CLI now says which package needs which version, what build/Build.csproj pins, and to raise Tamp.Core, Tamp.NetCli.V10 and the dotnet-tamp tool pin together. It reads NuGet's own log from obj/project.assets.json, so the raw NuGet output is still shown above it. (#119)

Backfilled: this version was published to nuget.org at the time but no GitHub Release was created (tamp#159). Notes are this version's CHANGELOG.md section, unedited.

1.17.5

Choose a tag to compare

@BrewingCoder BrewingCoder released this 05 Nov 15:42
a7ea338

This version was published to nuget.org but has no CHANGELOG.md section — the entry was never written. This Release exists so the Releases tab matches what is on nuget.org (tamp#159); it is not a reconstruction.

What changed is recoverable from the commit range: v1.17.4...v1.17.5

Backfilled. If you know what shipped here, a PR adding the CHANGELOG section is welcome.

1.17.4

Choose a tag to compare

@BrewingCoder BrewingCoder released this 05 Nov 15:42
702dbbc

This version was published to nuget.org but has no CHANGELOG.md section — the entry was never written. This Release exists so the Releases tab matches what is on nuget.org (tamp#159); it is not a reconstruction.

What changed is recoverable from the commit range: v1.17.3...v1.17.4

Backfilled. If you know what shipped here, a PR adding the CHANGELOG section is welcome.

1.17.3

Choose a tag to compare

@BrewingCoder BrewingCoder released this 05 Nov 15:40
6648825

Changed

  • TAMP004 approves the Tamp.Http namespace. Secret.Reveal() inside Tamp.Http no longer trips the SecretRevealOutsideApprovedContextAnalyzer. Tamp.Http is foundational egress infrastructure — its credential types (BasicCredential/BearerCredential/CustomHeaderCredential) must reveal a Secret to build the Authorization header, exactly the legitimate wire-egress role already approved for Tamp.NetCli.V*. Surfaced when the Components Phase 4 fleet migration bumped tamp-http's Tamp.Core (activating the analyzer) flagged its own credential classes. Peer framework-internal; now approved alongside Tamp.Cli/Tamp.NetCli.V*/Tamp.Core.

Backfilled: this version was published to nuget.org at the time but no GitHub Release was created (tamp#159). Notes are this version's CHANGELOG.md section, unedited.

1.17.2

Choose a tag to compare

@BrewingCoder BrewingCoder released this 05 Nov 15:40
eb011b1

Unblocks the Tamp.Components satellite-migration wave (epic #57 Phase 4) by making the NetCli.V10 component bodies match what every satellite actually does, plus records three architectural decisions the tamp-conformance reverse-examination dogfood surfaced.

Changed

  • Tamp.Components.NetCli.V10 Test/Pack bodies match the fleet convention (ADR 0020 Phase 4 enabler). IDotNetTest now collects coverage the way every satellite hand-rolls it — a trx logger + the XPlat Code Coverage collector, results under artifacts/test-results, and (when a build/coverlet.runsettings exists) that runsettings file — on top of the existing --no-build/--blame-crash. IDotNetPack now honors the PACKAGE_VERSION environment variable (the tag-driven release version), passing it as the Version MSBuild property. This closes the gap that blocked the satellite-migration wave: the component defaults previously did plain solution-wide test/pack, so adopting them would have dropped coverage (breaking SonarCloud) and the tag-driven version (breaking releases). With this, a satellite composes class Build : TampBuild, IDotNetTest, IDotNetPack and drops its bespoke Test/Pack targets. No public API change; degrades cleanly when no runsettings / PACKAGE_VERSION is present.

Docs

  • ADR 0024 — OS-native credential store as a null-tolerant leg of the SecretBinder chain (macOS security / Linux secret-tool / Windows Credential Manager); the store/binding side of ADR 0005's Secret type. (#87)
  • ADR 0025 — Tamp.Security.Pipeline — a curated one-import supply-chain bundle (SBOM + CVE + SAST + config scan, env-gated push), every step overridable. (#87)
  • ADR 0005 amended (TAM-196): Secret.Reveal() is public, gated by TAMP004. Reconciled the ADR/code drift the tamp-conformance dogfood flagged (tamp#82): ADR 0005 still described Reveal() as internal/IVT-gated, but it became public + TAMP004-analyzer-gated in 1.6.0. Added an amendment section documenting the rationale and fixed the stale class-doc on Secret. No behavior change.

Backfilled: this version was published to nuget.org at the time but no GitHub Release was created (tamp#159). Notes are this version's CHANGELOG.md section, unedited.