From c060d6fad008733a8e557c54e38d9cf1afc8aea7 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Wed, 18 Nov 2026 12:30:21 +0000 Subject: [PATCH 1/8] Session canon-lock-file: prompt and bootstrap The session's charter, committed before any other change (meta/sessions/README.md). predictions.md holds P-1, written before NU1004 is reproduced. Refs #83 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYRfbmM3FZTaoukTyA7 --- .../2026-11-18-canon-lock-file/bootstrap.md | 32 ++++++++++++++++ .../2026-11-18-canon-lock-file/predictions.md | 19 ++++++++++ .../2026-11-18-canon-lock-file/prompt.md | 37 +++++++++++++++++++ 3 files changed, 88 insertions(+) create mode 100644 meta/sessions/2026-11-18-canon-lock-file/bootstrap.md create mode 100644 meta/sessions/2026-11-18-canon-lock-file/predictions.md create mode 100644 meta/sessions/2026-11-18-canon-lock-file/prompt.md diff --git a/meta/sessions/2026-11-18-canon-lock-file/bootstrap.md b/meta/sessions/2026-11-18-canon-lock-file/bootstrap.md new file mode 100644 index 0000000..50a3910 --- /dev/null +++ b/meta/sessions/2026-11-18-canon-lock-file/bootstrap.md @@ -0,0 +1,32 @@ +# Bootstrap — canon's lock file, 2026-11-18 + +Filled in at arrival and committed with `prompt.md` as the session's first commit. + +| Parameter | Value | +|---|---| +| Invocation | Interactive, gated. Emil's prompt is verbatim in `prompt.md` | +| Principal | Emil (rules the fix at G1; ratifies the head at G2) | +| Issue | [#83](https://github.com/mindovermachine-dev/decision-driven-design/issues/83). Every commit of the session carries `Refs #83` | +| Upstream pin | unchanged by this session (`graph/upstream.yaml`) | +| Downstream base | `84aa466` (`84aa4665b4b0392ef4bb08ac042e42ae9fc6d12c`), the head of `main` at arrival | +| Downstream branch | `claude/canon-lock-file-2026-11-18`, from `main` at `84aa466` | +| Local toolchain | `dotnet --list-sdks`: `10.0.404` only (this container; not the devcontainer) | +| Model | Claude Opus 5.5 | + +## Gates + +| Gate | What | Who | +|---|---|---| +| G0 | This charter committed before any other change | Claude | +| G1 | Deliverable 1 (NU1004 reproduced, diagnosis confirmed or corrected) and deliverable 2 (proposals, weakest point first, each with what happens at the next .NET patch) | Claude; **stops for Emil's ruling** | +| G2 | Deliverable 3, the ruled fix: a pull request against `main`, the head to ratify named, `pipeline (devcontainer)` and `agent review` reported for it | Claude; **stops for Emil** | + +## Scope + +In scope: `tools/canon/` build inputs (SDK selection, lock files) and, if ruled, the SDK install +in `.github/workflows/agent-review.yml`, `.github/workflows/validate.yml` and +`.devcontainer/devcontainer.json`; this session record and its row in `meta/sessions/README.md`; +a decision record only if the ruling needs one. + +Out of scope: anything that changes what canon checks; any claim, decision text, method card or +lifecycle data; the branches of #80 and the archive branch; the act map work (#80, #81, #82). diff --git a/meta/sessions/2026-11-18-canon-lock-file/predictions.md b/meta/sessions/2026-11-18-canon-lock-file/predictions.md new file mode 100644 index 0000000..c20ae28 --- /dev/null +++ b/meta/sessions/2026-11-18-canon-lock-file/predictions.md @@ -0,0 +1,19 @@ +# Predictions — canon's lock file + +Written before each operation, then scored against what happened. + +## P-1. Reproduce NU1004 (before deliverable 1) + +Prediction: in this container (SDK 10.0.404), `CI=true dotnet restore tools/canon/canon.slnx` +fails with `NU1004` on `src/Canon` because the SDK's implicit `Microsoft.NET.ILLink.Tasks` +reference is at the runtime version this SDK bundles, not 10.0.14. Without `CI`, the same restore +succeeds and rewrites `packages.lock.json`. I expect the reference comes from +`IsAotCompatible=true` in `Canon.csproj` (which turns on the trim/AOT analyzers and with them the +ILLink pack), not from anything named in the project files. + +Second prediction, to correct the issue's account of `validate`: `devcontainers/ci` runs +`runCmd` with only the `env:` it is given (`GITHUB_BASE_REF`), so `CI` is unset inside the +container, locked mode is off there, and `validate` passes whatever SDK the devcontainer holds. +To be checked against run 385's log. + +Result: (scored below after the run) diff --git a/meta/sessions/2026-11-18-canon-lock-file/prompt.md b/meta/sessions/2026-11-18-canon-lock-file/prompt.md new file mode 100644 index 0000000..26a8d99 --- /dev/null +++ b/meta/sessions/2026-11-18-canon-lock-file/prompt.md @@ -0,0 +1,37 @@ +# Prompt — canon's lock file, 2026-11-18 + +Verbatim, as given by Emil. + +--- + +Work issue #83 in mindovermachine-dev/decision-driven-design: +"The agent review check builds again: canon's lock file and the SDK it is built with". + +Read first: issue #83 in full, AGENTS.md, meta/way-of-working.md, then the files #83 names. + +Set up before any other change +- Branch from main. Name it claude/canon-lock-file-. +- Create meta/sessions/-canon-lock-file/ with prompt.md (this prompt, verbatim) and + bootstrap.md. Commit them first. Write predictions.md before each operation. + +Work the deliverables in the issue's order +- Deliverable 1: reproduce NU1004 and confirm or correct the diagnosis in the issue. It is + marked UNVERIFIED. Do not take it as ground. +- Deliverable 2: the proposals, weakest point first, each saying what happens at the next .NET + patch release. STOP at G1. I rule which fix. +- Deliverable 3 only after my ruling. STOP at G2 with a pull request against main, and name the + head to ratify. + +Discipline +- This issue is the one place tools/canon may be changed. Change nothing that alters what + canon checks. +- The agent review workflow runs from main (pull_request_target). A change to the workflow + file is not exercised by the pull request that makes it. Say how the fix is shown to work + before it lands. +- Every commit carries "Refs #83". Run the whole validate workflow locally before each push. + After each push, report the workflow runs for that head, both required checks: + "pipeline (devcontainer)" and "agent review". +- Do not touch the branches of #80, the archive branch, or any claim, card or lifecycle data. +- Record my rulings in rulings.md when I give them, in my words, with the time. + +If the ground for a ruling is missing, ask me. Do not fill the gap. From 4a091c39ff86447f8641d2707e51646cf93b1335 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Wed, 18 Nov 2026 12:35:00 +0000 Subject: [PATCH 2/8] Session canon-lock-file: G1 findings, proposals, predictions; the sessions index row Deliverables 1 and 2 of #83, for Emil's ruling at G1. Session record only: nothing under tools/canon/, .github/ or .devcontainer/ changes. - D-1: NU1004 reproduced on SDK 10.0.404 with CI set. - D-2: confirmed. IsAotCompatible makes the SDK add Microsoft.NET.ILLink.Tasks at its bundled runtime (KnownILLinkPack), 10.0.15 in 10.0.404. - D-3: corrected. validate passes because CI is unset in the devcontainer, so its restore is unlocked; the devcontainer already has 10.0.404. - D-4: not in the issue. Agent review builds main's canon and trunk has no bypass, so no pull request, this one included, passes it until main builds. - Proposals A, B, C, weakest point first, each at the next .NET patch; D and E rejected. Q-1 to Q-3 for the ruling. Refs #83 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYRfbmM3FZTaoukTyA7 --- .../2026-11-18-canon-lock-file/findings.md | 223 ++++++++++++++++++ .../2026-11-18-canon-lock-file/predictions.md | 30 ++- meta/sessions/README.md | 1 + 3 files changed, 253 insertions(+), 1 deletion(-) create mode 100644 meta/sessions/2026-11-18-canon-lock-file/findings.md diff --git a/meta/sessions/2026-11-18-canon-lock-file/findings.md b/meta/sessions/2026-11-18-canon-lock-file/findings.md new file mode 100644 index 0000000..ace6e8f --- /dev/null +++ b/meta/sessions/2026-11-18-canon-lock-file/findings.md @@ -0,0 +1,223 @@ +# Findings — canon's lock file (G1) + +Deliverables 1 and 2 of [#83](https://github.com/mindovermachine-dev/decision-driven-design/issues/83). +Each finding says what it rests on: a command run in this session, a log line from a named run, or +a file at `84aa466`. Where it rests on nothing checkable it says `UNVERIFIED — Emil review`. + +## Deliverable 1. The diagnosis + +**In one sentence.** `IsAotCompatible` in `Canon.csproj` makes the SDK add an implicit +`PackageReference` to `Microsoft.NET.ILLink.Tasks` at the runtime version that SDK bundles; the +lock file was written by an SDK that bundled 10.0.14, the runner now has SDK 10.0.404, which +bundles 10.0.15, and the runner sets `CI`, so the restore is locked and fails with `NU1004`. + +### D-1. NU1004 reproduced + +In this container (SDK `10.0.404`, runtime `10.0.15`), at `84aa466`: + +``` +CI=true dotnet restore tools/canon/canon.slnx +…/src/Canon/Canon.csproj : error NU1004: The package reference Microsoft.NET.ILLink.Tasks version +has changed from [10.0.14, ) to [10.0.15, ). +``` + +Same message, word for word, as agent review run 83 on PR #78 +([run 44268079979](https://github.com/mindovermachine-dev/decision-driven-design/actions/runs/44268079979)). +Without `CI` the same restore passes and rewrites `src/Canon/packages.lock.json` (three lines: +`requested`, `resolved`, `contentHash`), which is what #80's session saw. `tests/Canon.Tests` +restores in both modes: it does not set `IsAotCompatible`, so it has no ILLink reference. + +### D-2. Where the dependency comes from — the issue's reading confirmed, with the mechanism + +Confirmed: nothing in the project files names `Microsoft.NET.ILLink.Tasks`; the SDK adds it. +The chain, read from SDK 10.0.404's own targets: + +1. `Canon.csproj` sets `IsAotCompatible=true` (`DESIGN.md` "AOT-ready"). The SDK infers + `IsTrimmable`, `EnableTrimAnalyzer` and `EnableAotAnalyzer` from it (`dotnet msbuild + -getProperty` shows all four `true`). +2. `Microsoft.NET.Publish.targets` (target `_ComputeToolPackInputsToProcessFrameworkReferences`) + sets `_RequiresILLinkPack=true` when any of those is true. +3. `ProcessFrameworkReferences` then adds a `PackageReference` to `Microsoft.NET.ILLink.Tasks` at + `KnownILLinkPack`'s `ILLinkPackVersion`, which `Microsoft.NETCoreSdk.BundledVersions.props` + sets to the SDK's bundled runtime: `10.0.15` in SDK 10.0.404. + +So the version in the lock file moves with **the SDK's patch level (its bundled runtime)**, not +with its feature band. Every SDK band (10.0.1xx … 10.0.4xx) released on the same patch day +bundles the same runtime, so `rollForward` does not decide the ILLink version; the installed SDK +does. + +Something the issue does not say, and which matters to the options: the package carries the trim +and AOT **analyzers** (`analyzers/dotnet/cs/ILLink.RoslynAnalyzer.dll` in both the 10.0.14 and the +10.0.15 package). With `TreatWarningsAsErrors`, the ILLink version is one of the inputs to whether +canon builds. canon is not trimmed or published AOT, so the tasks themselves are not used. + +### D-3. Which SDK each workflow gets today — the issue's reading corrected + +| | agent review | validate (`pipeline (devcontainer)`) | +|---|---|---| +| Installs .NET with | `actions/setup-dotnet` v6, `global-json-file: tools/canon/global.json` | the devcontainer `dotnet:2` feature, `version: "10.0"` | +| What that resolves to | `rollForward: latestFeature` → `install-dotnet.sh --channel 10.0` (setup-dotnet maps `latestFeature` to `major.minor`). Run 83 log: *"SDK with version '10.0.404' is already installed"* (the runner image's) | `dotnet-install.sh --version latest --channel 10.0 --quality GA`. Run 385 log: *"Installed version is 10.0.404"*, *"SDK Version: 10.0.404"* | +| `CI` set? | Yes (GitHub runner) → `RestoreLockedMode=true` | **No.** `devcontainers/ci` passes into the container only the `env:` it is given (`GITHUB_BASE_REF`) and its own `GITHUB_*` file paths (run 385, `devcontainer exec --remote-env …`) | +| Result | NU1004 | Restore passes (run 385: *"Restored …/src/Canon/Canon.csproj"*) and silently rewrites the lock file in the checkout | + +**Corrected.** The issue says `validate` passes "only while the devcontainer still holds the +older SDK", and that it fails "as soon as the devcontainer is rebuilt". Both are wrong: + +- The devcontainer **already** has 10.0.404. It is rebuilt from scratch on every run: the + `--cache-from ghcr.io/mindovermachine-dev/decision-driven-design-devcontainer:latest` import + fails with `403 Forbidden` (run 385, lines 267 and 676), so the feature downloads the newest + 10.0 SDK each time. +- `validate` passes because **locked mode is off inside the container**: `CI` is unset there, + and `RestoreLockedMode` is conditioned on `CI` (`Directory.Build.props`). The `onCreateCommand` + (`dotnet build tools/canon/canon.slnx`) rewrites the lock file before any step runs. + +So the two checks differ not in the SDK (both have 10.0.404 today) but in `CI`. `validate` has +never enforced canon's lock file; `DESIGN.md` §1 says "`RestoreLockedMode` in CI", and that +holds for agent review only. It will keep passing at the next patch, under every option below, +unless that is changed. + +**Confirmed.** Neither workflow nor the devcontainer names a patch. `global.json` asks for +`10.0.100` with `rollForward: latestFeature`, so any 10.0 SDK is accepted. (`DESIGN.md`'s "Built" +table records this as a deliberate departure from Varve's exact `10.0.401`.) + +Where the 10.0.14 came from: the lock file was added in `f31bd4b` (2026-11-06), and `DESIGN.md` +says "Locally it was 10.0.403". That 10.0.403 bundles 10.0.14 is inferred, not checked +(`UNVERIFIED — Emil review`); nothing below depends on it. + +### D-4. The deadlock — not in the issue, and it decides how any fix lands + +The agent review job **checks out `main` by name and builds main's canon** (`agent-review.yml`, +"Checkout main"; run 83 log: `git checkout … -B main`, head `84aa466`). The `trunk` ruleset +requires `agent review` with **"No bypass, the admin role included"** (`.github/repo-standard.yaml`, +`DDD-dec-108`, `DDD-dec-109`). + +So until `main` itself builds on the runner's SDK, agent review fails on **every** pull request, +this issue's included, whatever the pull request contains. A fix on this branch cannot turn its +own `agent review` green; and with no bypass, it cannot land by the trunk ruleset. Deliverable +3's exit ("both required checks pass on this issue's own pull request") cannot be met as written. + +Landing the fix needs one act outside this branch, which is the admin's (Emil's): for example, +lift the `agent review` requirement from `trunk` for the one landing and restore it after, or +fast-forward `main` some other way. That is ground I do not have; it is question Q-1 below. + +## Deliverable 2. The proposals, weakest point first + +"The next .NET patch" is the next servicing release of .NET 10, which by Microsoft's usual +cadence is Patch Tuesday, 2026-12-08 (`UNVERIFIED — Emil review`: the date is the cadence, not an +announcement). It would bring runtime 10.0.16 and SDKs 10.0.1xx–10.0.405. + +### A. Regenerate the lock file for the newer SDK, change nothing else + +*Change.* `src/Canon/packages.lock.json`: ILLink 10.0.14 → 10.0.15. Nothing else. + +*Weakest point.* It is a fix for one month. It ties the lock file to whichever SDK the runner +image or `install-dotnet --channel 10.0` happens to hold. + +*At the next patch.* Agent review breaks again the day the runner image or the channel moves to +10.0.405 (NU1004, 10.0.15 → 10.0.16), and every pull request is blocked again, by D-4, until +someone lands the same one-line change, which itself needs the D-4 act. `validate` stays green +throughout (D-3), so nothing warns before it breaks. + +*What it breaks.* Nothing today. A local machine or runner with an SDK older than 10.0.404 (e.g. +10.0.403) now fails in locked mode. The trim/AOT analyzer moves to 10.0.15. + +### B. Pin the SDK exactly in `global.json`; workflow and devcontainer install that version; regenerate the lock once (the issue's opening position) + +*Change.* `global.json`: `"version": "10.0.404", "rollForward": "disable"`. The devcontainer +feature: `"version": "10.0.404"`. The lock file: ILLink → 10.0.15 (what 10.0.404 bundles). +`DESIGN.md`'s "Built" row on `global.json` updated to say so. + +*Corrections to the issue's version of this option.* + +- **`agent-review.yml` need not change.** `setup-dotnet` at the pinned commit installs the exact + `sdk.version` when `rollForward` is neither `latestMajor`, `latestMinor`, `latestFeature` nor + `latestPatch` (source read at `a98b568`, `getVersionFromGlobalJson`). With `disable` it + installs exactly 10.0.404, and the `dotnet` host then selects exactly that SDK even if the image + holds a newer one. That removes the D-4 caution about workflow changes for this option: what + changes is files the workflow reads from `main`. +- **`rollForward` must be `disable`, not `latestPatch`.** `latestPatch` maps to `10.0.4xx` in + setup-dotnet and would take 10.0.405 at the next patch, which is option A again. + +*Weakest point.* The version is written in two places that nothing compares: `global.json` and +`devcontainer.json` (the feature cannot read `global.json`). If they drift, agent review breaks +and `validate` does not notice (D-3). Second: every SDK patch, security fixes included, now waits +for a reviewed bump (three files, one commit). Third, small: a developer needs that exact SDK +installed; `dotnet` refuses to run in `tools/canon/` otherwise, with a clear message. + +*At the next patch.* Nothing happens. Agent review and `validate` keep 10.0.404 until someone +bumps it. The bump is one commit (`global.json`, `devcontainer.json`, lock file). Its pull request is +judged by main's canon, which still builds on the old pin, so D-4 does not recur. + +*What it breaks.* `DESIGN.md`'s recorded reason for `latestFeature` ("any 10.0 SDK from 10.0.100 +up builds canon") stops holding, by design. That the dotnet feature accepts an exact `X.Y.Z` is +from the feature's documentation, not yet run here (`UNVERIFIED — Emil review`; checked in +deliverable 3 by building the container). + +### C. Pin the ILLink pack in the repository; the SDK stays floating (not in the issue) + +*Change.* A new `tools/canon/Directory.Build.targets` with one item, +`` (or 10.0.15 +with the lock regenerated). No other file. Run here (P-2, not committed): with it, `CI=true +dotnet restore` passes on SDK 10.0.404 against the **committed** lock file, and `CI=true dotnet +build -c Release` passes with 0 warnings. The same line in `Directory.Build.props` does nothing +(NU1004), because the SDK's bundled versions are imported after it. + +*Weakest point.* `KnownILLinkPack` is the SDK's internal item, not a documented contract. A +future SDK could rename it or stop reading it. The failure is loud, not silent: the reference +reverts to the SDK's version and agent review fails with NU1004, i.e. back to today. Second: an +older ILLink analyzer runs under a newer SDK and compiler; that combination is not one Microsoft +documents as supported (`UNVERIFIED — Emil review`). + +*At the next patch.* Nothing happens to the build. The SDK moves to 10.0.405, the ILLink package +stays at the pinned version, the lock file matches. The ILLink version becomes a reviewed line, +as `Directory.Packages.props` already makes every other package. + +*What it breaks.* Nothing seen. The trim/AOT analyzer no longer moves with the SDK. + +### Rejected, listed so the ruling can see them + +- **D. Turn off `IsAotCompatible`.** Removes the reference, and with it the trim/AOT analyzers: + it changes what canon's build checks, and reverses `DESIGN.md`'s "AOT-ready". Out of scope. +- **E. Restore unlocked in agent review** (`--force-evaluate`, or no `CI`). Removes the lock + discipline `DESIGN.md` §1 sets. Out of scope. + +### Recommendation + +**B**, as the issue proposes, with the two corrections above (no workflow change; `disable`). +C is the smaller change and also survives the next patch, but it rests on an SDK-internal item; +B rests on documented behaviour of `global.json` and `setup-dotnet`. A is not a fix. + +## Questions for the ruling (G1) + +- **Q-1 (D-4). How does the fix land?** Agent review builds main's canon, so it cannot pass on + this pull request, and `trunk` has no bypass. Which act do you take: lift the `agent review` + requirement for this one landing and restore it, or another? Does that need a decision record + (the issue allows one "if the ruling needs one")? +- **Q-2 (D-3). Should `validate` enforce the lock file?** Passing `CI` into the container (one + line in `validate.yml`'s `env:`) would make `pipeline (devcontainer)` fail on drift as agent + review does, and would have caught this a week early. It makes `validate` stricter than it is + today. Is that inside "change nothing that alters what canon checks", or not? I will not do it + unless you rule it. +- **Q-3 (B only). Which exact version?** 10.0.404 is what the runner image and the devcontainer + have today. I would pin that. + +## How the fix is shown to work before it lands + +Agent review on this pull request cannot show it (D-4). What can: + +1. **Locally, the agent review job's build, with its inputs.** On a clean `~/.nuget/packages` and + `DOTNET_ROOT`, install .NET with `install-dotnet.sh` and the arguments setup-dotnet derives + from the fixed `global.json` (B: `--version 10.0.404`; C: `--channel 10.0`), then `CI=true + dotnet run --project src/Canon -c Release -- --help` from `tools/canon/`, i.e. the job's + command with the network-only `agent-review` subcommand replaced. For C, also with the newest + SDK on the channel, to stand in for "the next patch". +2. **The devcontainer, built here** with the same `@devcontainers/cli` (0.90.0) CI uses, and + validate's `runCmd` run in it — and, for this purpose only, once more with `CI=true` passed in, + to show the container's SDK and the lock file agree. +3. **On a GitHub runner, if you allow it.** A `push` run takes its workflow from the pushed + branch. A throwaway workflow on this branch (checkout this branch, the same `setup-dotnet` + step, `CI=true dotnet build`) would show the build on the real `ubuntu-latest` image. It + touches `.github/workflows/`, so I will not add it without your word, and it would be removed + before the head to ratify. +4. **After landing**, the first pull_request_target run of agent review (e.g. a `synchronize` on + #78 or #80's pull request) is the real proof. I will name it when it runs. diff --git a/meta/sessions/2026-11-18-canon-lock-file/predictions.md b/meta/sessions/2026-11-18-canon-lock-file/predictions.md index c20ae28..83a0d64 100644 --- a/meta/sessions/2026-11-18-canon-lock-file/predictions.md +++ b/meta/sessions/2026-11-18-canon-lock-file/predictions.md @@ -16,4 +16,32 @@ Second prediction, to correct the issue's account of `validate`: `devcontainers/ container, locked mode is off there, and `validate` passes whatever SDK the devcontainer holds. To be checked against run 385's log. -Result: (scored below after the run) +Result: **held, both.** NU1004 reproduced word for word; without `CI` the restore passed and +rewrote the three lines (10.0.15). The source is `IsAotCompatible` → `_RequiresILLinkPack` → +`KnownILLinkPack` (findings D-2). Run 385: `--remote-env` carries only `GITHUB_*` file paths, and +`Canon.csproj` restored at SDK 10.0.404, which locked mode would have refused. Not predicted: the +devcontainer already had 10.0.404 (the ghcr cache import is 403, so it is rebuilt every run), and +agent review builds main's canon, so no pull request can pass it (findings D-3, D-4). + +## P-2. Pin the ILLink pack in the repository, not by the SDK (an experiment, not committed) + +Prediction: an uncommitted `tools/canon/Directory.Build.targets` holding +`` makes +`CI=true dotnet restore` pass on SDK 10.0.404 against the committed lock file, unchanged, and +`dotnet build -c Release` pass with warnings as errors. The same line in `Directory.Build.props` +does nothing, because the SDK's bundled versions are imported after it. The experiment is +reverted after it runs. + +Result: **held, both.** With the `.targets` file: locked restore passed, the lock file untouched, +Release build 0 warnings, 0 errors. With the line in `Directory.Build.props`: NU1004. Both +reverted; `git status` clean of them. + +## P-3. The validate workflow, locally, before the G1 push + +Prediction: `devcontainer build` + `devcontainer up` + `devcontainer exec` of validate.yml's +`runCmd` (the `@devcontainers/cli`, as `devcontainers/ci` uses it) passes on this branch's head: +the container gets SDK 10.0.404, `CI` is unset inside it, the onCreate `dotnet build` rewrites +`src/Canon/packages.lock.json` to 10.0.15 in the bind-mounted checkout (the working tree shows it +modified afterwards), and every step is green. The rewrite is discarded after the run. + +Result: (scored below) diff --git a/meta/sessions/README.md b/meta/sessions/README.md index ecd9910..75f7bba 100644 --- a/meta/sessions/README.md +++ b/meta/sessions/README.md @@ -54,3 +54,4 @@ session's later work exceeds the committed prompt, the excess is visible as exce | `2026-11-08-specification-feasibility/` | Rulings filed, gated — specification feasibility, from a claude.ai conversation (F-1 to F-12): every dependency on ground has a What layer and a How layer, the How decides by three loose-coupling conditions, any granted actor vets a pinned What change and product-cli records the decision (`DDD-dec-116`); vetted ground becomes a ground-sourced bounded context, admitted per system for Deciders, Projectors and Views, with permission the data owner's; product-cli and the framework carry grants and roles, superseding `[D1.11]` (`DDD-dec-117`). Not applied; S-1 to S-8. Issue #62 | | `2026-11-08-demand-flow/` | Rulings filed, gated — map the flow of demand, from the claude.ai conversation's Rounds 23 to 25: a method step after step 1 (`method/01b-map-the-flow-of-demand.md`, `[PROPOSED]`), general, with each process declaring its kinds of demand and the PDLC's new, owed and own-ground as its worked example and starting point; four PDLC-scoped claims in a new area, `DDD-flow-01` to `-04`, projected; `DDD-dec-118`, adding to `DDD-dec-114`; the acme shop's #101, #103 and #104 traced as graph data checked against the act map. Nothing upstream. Round 26 (2026-11-10) closed R-1: sighting separated from entry, only the What owner says whether a defect is a bug. Open: numbering (N-1), promotion (P-1), the two examples (E-1). Issue #67 | | `2026-11-10-release-v0.7.0/` | Release descriptor, gated. `releases/v0.7.0.yaml` is MINOR under `DDD-dec-82`: step 1b's card was added (`DDD-dec-118`), and no step's register moved (F-1). Format 2, `prerelease: true` for Emil to confirm (F-3). Its `CHANGELOG.md` section is from `canon changelog`, and `canon ratify` fills the ratified head. The prompt calls the PDLC and SDLC specifications `[PROPOSED]`, while the repository says they are ruled (Round 28). The summary follows the repository, and Emil is to settle it (F-2). Not landed and not cut. Issue #69 | +| `2026-11-18-canon-lock-file/` | Interactive, gated — the `agent review` check builds again (#83). NU1004 reproduced: `IsAotCompatible` makes the SDK reference `Microsoft.NET.ILLink.Tasks` at its bundled runtime (10.0.15 in SDK 10.0.404), the lock file holds 10.0.14, and the runner sets `CI`. Corrected: `validate` passes because `CI` is unset in the devcontainer, not because of an older SDK; and agent review builds main's canon, so no pull request can pass it until main builds (D-4). Proposals A (regenerate), B (exact SDK pin), C (pin the ILLink pack); G1 open. Issue #83 | From 7ba2d810b4b0c574aad86af2a298e07ced357a97 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Wed, 18 Nov 2026 13:19:27 +0000 Subject: [PATCH 3/8] rulings.md: Emil's G1 rulings, verbatim, received 13:17 UTC Option B with both corrections, 10.0.404 (Q-3); CI passed into the devcontainer, closing a gap in Directory.Build.props' existing rule (Q-2); Emil lifts and restores the agent review requirement himself, and a waiver decision record is drafted for his ruling (Q-1); the throwaway workflow on terms; deliverable 3's exit restated. Record only. Refs #83 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYRfbmM3FZTaoukTyA7 --- .../2026-11-18-canon-lock-file/rulings.md | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 meta/sessions/2026-11-18-canon-lock-file/rulings.md diff --git a/meta/sessions/2026-11-18-canon-lock-file/rulings.md b/meta/sessions/2026-11-18-canon-lock-file/rulings.md new file mode 100644 index 0000000..7d61e0b --- /dev/null +++ b/meta/sessions/2026-11-18-canon-lock-file/rulings.md @@ -0,0 +1,53 @@ +# Rulings — canon's lock file + +Emil's rulings, in his words, with the time Claude received them. Nothing here is paraphrased; +Claude's notes, where any, follow a ruling and are marked as Claude's. + +## G1 — received 2026-11-18 13:17 UTC (14:17 Europe/Berlin) + +> My G1 rulings on #83. Record this message in rulings.md, in my words, with the time you +> receive it. Then do deliverable 3 and stop at G2. +> +> The fix. Option B with your two corrections: pin the SDK exactly in global.json with +> rollForward "disable", pin the same version in devcontainer.json, and regenerate the lock file +> once. agent-review.yml does not change. +> +> Q-3. Pin 10.0.404. +> +> Q-2. Yes. Pass CI into the devcontainer so validate restores in locked mode. +> Directory.Build.props already rules that a CI restore is locked, so this closes a gap in an +> existing rule. It is not a new check. Say so in the record. +> +> Q-1. I will lift the "agent review" requirement on the trunk ruleset for this one landing and +> restore it straight after. You do not touch the ruleset. Draft a decision record for the +> waiver and stop for my ruling on its text before filing it: what was waived, why no other path +> exists (the check is posted by the gates app, and the job builds main's canon), the head that +> landed, and the times lifted and restored, which I will give you. Check every branch of both +> repositories for the next free decision id. DDD-dec-122 is on #84's branch. +> +> The throwaway workflow. Allowed, on these terms: it runs on push to this branch only, has +> read-only permissions and no secrets, does the agent review job's build steps and nothing +> else, and is removed in its own commit before the head to ratify. Report its run. +> +> Check one thing and report it: with rollForward "disable", does dotnet refuse to run when the +> installed SDK differs from global.json? If it does, a drift between global.json and +> devcontainer.json fails validate loudly, and the weakest point you named for B is milder than +> stated. Record whichever you find. +> +> Corrections to record, with attribution: #83's statement that validate passes because the +> devcontainer holds an older SDK was wrong, and it was Claude's in the planning conversation. +> You found the real cause and the deadlock. +> +> Successor items to record, without acting on them: +> - a scheduled check that says when a newer .NET patch exists, since B makes security patches +> wait for a manual bump; +> - the deadlock itself: a required check that builds main's canon, with no bypass, means a +> broken main can only be repaired by suspending the rule. +> +> Deliverable 3's exit changes, because it cannot be met as written. It is now: the validate +> workflow passes on the head with locked restore; your three pre-landing proofs pass; every +> commit carries "Refs #83". The first agent review run after landing is the final proof, and I +> will have #84 re-run it. +> +> Stop at G2 with a pull request against main, and name the head to ratify. Out of scope stays +> as in the issue. From d2eb86c9d82e08453a4c73929124960ff3256996 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Wed, 18 Nov 2026 13:19:27 +0000 Subject: [PATCH 4/8] predictions.md: P-3 scored; P-4 to P-7 before G2's operations Refs #83 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYRfbmM3FZTaoukTyA7 --- .../2026-11-18-canon-lock-file/predictions.md | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/meta/sessions/2026-11-18-canon-lock-file/predictions.md b/meta/sessions/2026-11-18-canon-lock-file/predictions.md index 83a0d64..6818742 100644 --- a/meta/sessions/2026-11-18-canon-lock-file/predictions.md +++ b/meta/sessions/2026-11-18-canon-lock-file/predictions.md @@ -45,3 +45,50 @@ the container gets SDK 10.0.404, `CI` is unset inside it, the onCreate `dotnet b modified afterwards), and every step is green. The rewrite is discarded after the run. Result: (scored below) + +## P-3, scored (written after the G1 push, before G2's operations) + +Result: **held.** Fresh clone of `4a091c3`, devcontainer built from its own `devcontainer.json` +(plus a scratch base layer with this sandbox's proxy CA and host networking, which CI does not +need): SDK 10.0.404 installed, `CI=[]` inside, `src/Canon/packages.lock.json` modified after +onCreate, runCmd exit 0. Three runs before that failed for causes in this sandbox, not the repo: +no tags and a shallow history locally (the release guard and `issue-refs` need both, as CI's +`fetch-depth: 0` gives), and the proxy variables routing the tests' 127.0.0.1 server (fixed with +`NO_PROXY`). Validate run 388 on `4a091c3`: success. + +## P-4. rollForward "disable" with a different installed SDK (Emil's check, G1) + +Prediction: with `global.json` at `"version": "10.0.403", "rollForward": "disable"` and only SDK +10.0.404 installed, every `dotnet` command under that directory (`--version`, `restore`, `build`) +exits non-zero with "A compatible .NET SDK was not found" naming 10.0.403. So a drift between +`global.json` and `devcontainer.json` fails validate at its first `dotnet` call, in onCreate. + +Result: (scored below) + +## P-5. The fix (B, 10.0.404) and the CI pass-through + +Prediction: with `global.json` at 10.0.404/`disable` and the lock file regenerated (three lines, +ILLink 10.0.14 → 10.0.15, nothing else), `CI=true dotnet restore` and `CI=true dotnet build -c +Release` pass on SDK 10.0.404; the tests' lock file does not change. In the devcontainer built +from the new `devcontainer.json` with `CI=true` passed to both up and exec (as `devcontainers/ci` +v0.3 does with an `env:` name, read in its dist/index.js), the working tree is clean after +onCreate and after the runCmd, and the runCmd exits 0. + +Result: (scored below) + +## P-6. Proof 1: the agent review job's build on a clean install + +Prediction: with an empty `DOTNET_ROOT` and NuGet cache, `install-dotnet.sh --version 10.0.404` +(what setup-dotnet derives from the fixed `global.json`), then `CI=true dotnet run --project +src/Canon -c Release -- --help` from `tools/canon/` exits 0 with canon's usage text. + +Result: (scored below) + +## P-7. Proof 3: the throwaway workflow on a GitHub runner + +Prediction: on push, the throwaway workflow's setup-dotnet step logs an install of exactly +10.0.404 (not `--channel 10.0`), and `CI=true dotnet build src/Canon -c Release` succeeds on +`ubuntu-latest`. Validate on the same head is green, including canon's +`RepositoryDeclarationTests` (they look at `agent-review.yml` by path only). + +Result: (scored below) From d2d7a1ad8f1cf0f22c4feff35270a123a9357bda Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" Date: Wed, 18 Nov 2026 13:19:27 +0000 Subject: [PATCH 5/8] canon's SDK pinned at 10.0.404; the lock file regenerated once; CI into the devcontainer Option B of #83, as Emil ruled at G1 (rulings.md): - tools/canon/global.json: 10.0.404, rollForward "disable". setup-dotnet installs exactly this version for agent review, so agent-review.yml does not change. - .devcontainer/devcontainer.json: the dotnet feature at 10.0.404. - tools/canon/src/Canon/packages.lock.json: regenerated on 10.0.404. Three lines: Microsoft.NET.ILLink.Tasks 10.0.14 -> 10.0.15. The tests' lock file does not change. - .github/workflows/validate.yml: CI passed into the container. This closes a gap in an existing rule (Directory.Build.props: a CI restore is locked); it is not a new check. Nothing changes what canon checks. - tools/canon/DESIGN.md: the layout line and the "Built" table record it. Refs #83 Basis: DDD-dec-101; DDD-dec-102; DDD-dec-109 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NbWSYRfbmM3FZTaoukTyA7 --- .devcontainer/devcontainer.json | 6 ++++-- .github/workflows/validate.yml | 6 +++++- tools/canon/DESIGN.md | 3 ++- tools/canon/global.json | 4 ++-- tools/canon/src/Canon/packages.lock.json | 6 +++--- 5 files changed, 16 insertions(+), 9 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 94ad373..47aa026 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -10,10 +10,12 @@ // The .NET SDK beside Python, for canon (tools/canon/, DDD-dec-101): built from source here and // in CI, never pulled from a feed (DDD-dec-106). The feature's major version was checked against - // ghcr.io/devcontainers/features/dotnet on 2026-11-02 (latest 2.5.0). + // ghcr.io/devcontainers/features/dotnet on 2026-11-02 (latest 2.5.0). The SDK is the exact version + // tools/canon/global.json pins (rollForward "disable"); the two are bumped together, with the lock + // file (#83). A drift fails validate: dotnet refuses to run in tools/canon/ on any other SDK. "features": { "ghcr.io/devcontainers/features/github-cli:1": {}, - "ghcr.io/devcontainers/features/dotnet:2": { "version": "10.0" } + "ghcr.io/devcontainers/features/dotnet:2": { "version": "10.0.404" } }, "onCreateCommand": "pip install --no-cache-dir -r scripts/requirements.txt && dotnet build tools/canon/canon.slnx", diff --git a/.github/workflows/validate.yml b/.github/workflows/validate.yml index 31f6599..d67e294 100644 --- a/.github/workflows/validate.yml +++ b/.github/workflows/validate.yml @@ -33,9 +33,13 @@ jobs: # Gate 2 it adds three checks no Python gate makes: its own tests, CHANGELOG.md as the # projection of releases/ (DDD-dec-104), and Refs #N with Basis: on canon commits over # the range under test (DDD-dec-105). GITHUB_BASE_REF is passed in so a pull request's - # range is base..head. + # range is base..head. CI is passed in so canon's restores are locked here as on any CI + # runner (tools/canon/Directory.Build.props): a lock file that does not match the pinned + # SDK fails this job, as it fails agent review (#83). The rule is not new; the container + # did not see CI, so it was not applied here. env: | GITHUB_BASE_REF + CI runCmd: | set -e python3 scripts/ci.py diff --git a/tools/canon/DESIGN.md b/tools/canon/DESIGN.md index 145a008..2dff1ab 100644 --- a/tools/canon/DESIGN.md +++ b/tools/canon/DESIGN.md @@ -76,7 +76,7 @@ tools/canon/ DESIGN.md this file README.md install, commands, exit codes (G2) canon.slnx - global.json SDK 10.0.x, rollForward latestFeature (as Varve) + global.json SDK 10.0.404 exactly, rollForward disable (#83) Directory.Build.props net10.0, LangVersion latest, Nullable, warnings as errors, ImplicitUsings off, Deterministic (as Varve) Directory.Packages.props central package management, transitive pinning on @@ -673,6 +673,7 @@ records every operation, predicted before it ran. | §2, §3.1: `System.CommandLine` | Hand-parsed arguments (`Cli.cs` and one file per command) | As Varve's `eng/` scripts are. Five commands with a few flags each do not need a parser library, and plain parsing is easier to audit. It is one package fewer, and it stays AOT-clean | | §3.1: Varve packages pinned | Not referenced yet | Gate 2 is git, GitHub and YAML. The `Varve.*` pins arrive with the shapes at Gate 3, in `Graph/` only (§1) | | §9.1: `global.json` SDK `10.0.401`, as Varve | `10.0.100`, `rollForward: latestFeature` | The devcontainer feature installs the newest 10.0 SDK, whatever its band. Any 10.0 SDK from 10.0.100 up builds canon. Locally it was 10.0.403 | +| (the row above, amended by #83) | `10.0.404`, `rollForward: disable`; the devcontainer feature at `10.0.404` | `IsAotCompatible` makes the SDK reference `Microsoft.NET.ILLink.Tasks` at the runtime it bundles, so the lock file moves with the SDK's patch. A floating SDK broke the locked restore at 10.0.404 (NU1004). setup-dotnet installs the exact version from this file; the feature repeats it. A bump is one commit: `global.json`, `devcontainer.json`, the lock file. Ruled by Emil, 2026-11-18 (`meta/sessions/2026-11-18-canon-lock-file/rulings.md`) | | §3.4: a recorded-response replay server for GitHub | A real HTTP/1.1 server on `127.0.0.1`, port 0, holding state (`GitHubServer.cs`) | No response was ever recorded, so a replay would have replayed invented data. The server answers the two REST shapes from what the test put there. `HttpListener` was tried first. Under parallel tests it raced for ports and crashed the test host once (exit 134), so it was replaced | | §4.3 step 8: Release name `title` | Name ` — `, the tag message | One string for one release, rule 2's composition | | §4.3: changelog check last (step 9) | The changelog check is step 6, before the tag. `--plan` stops before step 7 (the tag) | So that nothing irreversible happens before every check has passed | diff --git a/tools/canon/global.json b/tools/canon/global.json index df32a2e..742b820 100644 --- a/tools/canon/global.json +++ b/tools/canon/global.json @@ -1,7 +1,7 @@ { "sdk": { - "version": "10.0.100", - "rollForward": "latestFeature", + "version": "10.0.404", + "rollForward": "disable", "allowPrerelease": false }, "test": { diff --git a/tools/canon/src/Canon/packages.lock.json b/tools/canon/src/Canon/packages.lock.json index cd06f0f..4340fd6 100644 --- a/tools/canon/src/Canon/packages.lock.json +++ b/tools/canon/src/Canon/packages.lock.json @@ -4,9 +4,9 @@ "net10.0": { "Microsoft.NET.ILLink.Tasks": { "type": "Direct", - "requested": "[10.0.14, )", - "resolved": "10.0.14", - "contentHash": "YlTamXppEQls6DYWt7RdUuwWDb0lyw/vXCaGeQpLCpsLmfwGuCkOz/vIGgMTV7ECsJcavkCOkxZXv9s8rdAHkQ==" + "requested": "[10.0.15, )", + "resolved": "10.0.15", + "contentHash": "u0WnRcZgBZYHlVFpbe/3Adpmb9rmNJ8/fmEwqc/xjB7fFppq+gfaLJd3Sdaw+J02zV0eP/T9dneQ3Dv5jWw6bw==" }, "Varve.JsonLd": { "type": "Direct", From 3d0ac651c24236848a0c87b862867ef7ea4022d1 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" <claude+emil@okkels-klein.dk> Date: Wed, 18 Nov 2026 13:19:40 +0000 Subject: [PATCH 6/8] Throwaway workflow: agent review's build steps on this branch, on push Pre-landing proof 3 of #83, on the terms Emil set at G1: push to this branch only, contents: read, no secrets, the agent review job's checkout, setup-dotnet and build and nothing else. Removed in its own commit before the head to ratify. Refs #83 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01NbWSYRfbmM3FZTaoukTyA7 --- .../workflows/agent-review-build-proof.yml | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 .github/workflows/agent-review-build-proof.yml diff --git a/.github/workflows/agent-review-build-proof.yml b/.github/workflows/agent-review-build-proof.yml new file mode 100644 index 0000000..36f2fbc --- /dev/null +++ b/.github/workflows/agent-review-build-proof.yml @@ -0,0 +1,45 @@ +# THROWAWAY (#83, allowed by Emil at G1, meta/sessions/2026-11-18-canon-lock-file/rulings.md). +# Shows that canon builds with the agent review job's build steps on a GitHub runner, before the +# fix lands: agent-review.yml runs from main (pull_request_target) and builds main's canon, so +# it cannot show this branch's fix. This file is removed in its own commit before the head to +# ratify. Push to this branch only; read-only; no secrets; no check named `agent review`. + +name: agent review build proof (throwaway, #83) + +on: + push: + branches: [claude/canon-lock-file-2026-11-18] + +permissions: + contents: read + +env: + DOTNET_NOLOGO: "true" + DOTNET_CLI_TELEMETRY_OPTOUT: "true" + DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "true" + +jobs: + build: + name: build proof (throwaway) + runs-on: ubuntu-latest + steps: + # As agent-review.yml's steps, with this branch's head checked out in place of main. + - name: Checkout this branch + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + with: + fetch-depth: 1 + persist-credentials: false + + - name: Set up .NET + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6 + with: + global-json-file: tools/canon/global.json + + # The build agent review's `dotnet run ... -c Release` does, in locked mode (CI is set on + # the runner), without running `agent-review`, which needs the gates App's token. + - name: Build canon as agent review does + working-directory: tools/canon + run: | + echo "CI=$CI" + dotnet --version + dotnet build src/Canon -c Release From 59043360bfe1372af242d326e585970592e183a6 Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" <claude+emil@okkels-klein.dk> Date: Wed, 18 Nov 2026 13:28:23 +0000 Subject: [PATCH 7/8] Session canon-lock-file: G2 findings, the waiver draft, predictions scored Deliverable 3's record, appended to findings.md: Emil's corrections with attribution (validate's cause was Claude's misreading in the planning conversation); rollForward "disable" refuses any other SDK (exit 155), so B's weakest point is milder than stated; the three pre-landing proofs and validate run 389 with CI passed in; successors S-1 and S-2, not acted on. decision-draft.yaml: the waiver of the agent review requirement for one landing, drafted for Emil's ruling on its text and not filed. Every branch of both repositories checked: DDD-dec-123 is the next free id by files, but #80's bootstrap names it conditionally (W-1). Refs #83 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01NbWSYRfbmM3FZTaoukTyA7 --- .../decision-draft.yaml | 51 +++++++++++ .../2026-11-18-canon-lock-file/findings.md | 91 +++++++++++++++++++ .../2026-11-18-canon-lock-file/predictions.md | 19 +++- 3 files changed, 156 insertions(+), 5 deletions(-) create mode 100644 meta/sessions/2026-11-18-canon-lock-file/decision-draft.yaml diff --git a/meta/sessions/2026-11-18-canon-lock-file/decision-draft.yaml b/meta/sessions/2026-11-18-canon-lock-file/decision-draft.yaml new file mode 100644 index 0000000..deb1a02 --- /dev/null +++ b/meta/sessions/2026-11-18-canon-lock-file/decision-draft.yaml @@ -0,0 +1,51 @@ +# DRAFT for Emil's ruling on its text (G1, Q-1). Not filed: it is not under core/decisions/ and +# no gate reads it. On the ruling, the id is settled (question at the foot), the <...> fields are +# filled with the head and the times Emil gives, and it is filed as core/decisions/<id>.yaml. +format: 1 +id: DDD-dec-123 +kind: decision +statement: | + For one landing only, the trunk ruleset's required `agent review` check is lifted, so that #83's fix can reach main; it is restored straight after. Nothing else in trunk or in any other ruleset changes, and nothing in DDD-dec-108 or DDD-dec-109 is superseded. The waiver is not a precedent: a later broken main is a new decision. +principal: Emil +made: | + 2026-11-18, G1 of the canon-lock-file session (issue #83), given by Emil in the session and recorded verbatim at meta/sessions/2026-11-18-canon-lock-file/rulings.md (received 13:17 UTC). The requirement was lifted at <time lifted, Emil's> and restored at <time restored, Emil's>, both by Emil as repository admin. Emil's ruling on this record's text is the filing act +resolution: | + ## The ruling + + > Q-1. I will lift the "agent review" requirement on the trunk ruleset for this one landing and + > restore it straight after. You do not touch the ruleset. + + ## What was waived + + The `required_status_checks` entry `agent review` (integration 5594102, the gates App) in the + trunk ruleset (.github/repo-standard.yaml), for the landing of head <head that landed> to main + and for nothing else. The trunk ruleset's other rules held throughout: `pipeline + (devcontainer)` required, deletion and non-fast-forward refused. Signed Commits was not + touched. + + ## Why no other path existed + + - The `agent review` verdict is a check run posted by the gates App ("mom-gates", integration + 5594102), and the ruleset requires that name from that App (DDD-dec-109). No job a pull + request can change may post it, by design. + - The agent review job checks out main by name and builds main's canon before it judges + (.github/workflows/agent-review.yml, "Checkout main"). Main's canon did not build on the + runner's SDK: NU1004, the lock file at Microsoft.NET.ILLink.Tasks 10.0.14, the runner's SDK + 10.0.404 adding 10.0.15 (meta/sessions/2026-11-18-canon-lock-file/findings.md, D-1 to D-4). + - So agent review failed on every pull request whatever it held, the fix's own included, and + trunk has no bypass actor, the admin role included (DDD-dec-108). The fix could reach main + only if the requirement was suspended. + + ## What showed the fix before it landed + + Validate on the head, with locked restore (CI passed into the devcontainer); the agent review + job's build on a clean install of SDK 10.0.404 with CI set; the same on a GitHub runner by a + throwaway workflow, removed before the head (findings.md, deliverable 3). The first agent review + run after the landing is the final proof: <run, filled after the landing>. +basedOn: + - DDD-dec-108 + - DDD-dec-109 +notes: | + Successor, recorded by Emil's ruling and not acted on: a required check that builds main's + canon, with no bypass, means a broken main can only be repaired by suspending the rule. This + record is the first time that happened. diff --git a/meta/sessions/2026-11-18-canon-lock-file/findings.md b/meta/sessions/2026-11-18-canon-lock-file/findings.md index ace6e8f..8fd9d0e 100644 --- a/meta/sessions/2026-11-18-canon-lock-file/findings.md +++ b/meta/sessions/2026-11-18-canon-lock-file/findings.md @@ -221,3 +221,94 @@ Agent review on this pull request cannot show it (D-4). What can: before the head to ratify. 4. **After landing**, the first pull_request_target run of agent review (e.g. a `synchronize` on #78 or #80's pull request) is the real proof. I will name it when it runs. + +--- + +# G2 — deliverable 3, after Emil's G1 rulings (rulings.md, 13:17 UTC) + +Appended; nothing above is reworded. + +## Corrections, with attribution + +- **#83's statement that `validate` passes because the devcontainer holds an older SDK was + wrong. It was Claude's, in the planning conversation that wrote the issue** (Emil's attribution + at G1). The real cause is D-3: `CI` never reached the container, so its restore was never + locked. The deadlock (D-4) was not in the issue. Both were found in this session. +- **My weakest point for B was overstated** (P-4, run here). With `rollForward: "disable"`, + `dotnet` refuses to run in a directory under that `global.json` when the installed SDK is any + other version, older or newer: exit 155, "A compatible .NET SDK was not found … Requested SDK + version: 10.0.403". So a drift between `global.json` and `devcontainer.json` does not pass + silently: `validate` fails at its first `dotnet` call in `tools/canon/` (the runCmd's `dotnet + test`). It does not fail in onCreate: that build runs from the repository root, where there is + no `global.json`, and (now that `CI` is passed) would fail there only by NU1004. Agent review + fails the same way, since setup-dotnet installs the pinned version and the host refuses any + other. The two places still have to be bumped together, but a miss is loud, not silent. +- **D-3's "validate will keep passing at the next patch under every option"** is no longer true + after Q-2: with `CI` passed in, `validate` restores locked and fails on drift as agent review does. + +## What changed (commit d2d7a1a) + +| File | Change | +|---|---| +| `tools/canon/global.json` | `10.0.404`, `rollForward: "disable"` | +| `.devcontainer/devcontainer.json` | dotnet feature `10.0.404` (it installs with `dotnet-install.sh --version 10.0.404`, seen in the build log) | +| `tools/canon/src/Canon/packages.lock.json` | regenerated on 10.0.404: three lines, ILLink 10.0.14 → 10.0.15. `tests/Canon.Tests`' lock file unchanged | +| `.github/workflows/validate.yml` | `CI` added to `devcontainers/ci`'s `env:` | +| `tools/canon/DESIGN.md` | the layout line and a "Built" row for the pin | + +`agent-review.yml` does not change. Nothing changes what canon checks. + +**Q-2, as Emil ruled it:** passing `CI` into the devcontainer closes a gap in an existing rule. +`Directory.Build.props` already rules that a CI restore is locked (`RestoreLockedMode` when `CI` +is set, `DESIGN.md` §1); the container did not see `CI`, so the rule was not applied there. It is +not a new check. `devcontainers/ci` v0.3 passes an `env:` name to both `devcontainer up` (so the +onCreate build too) and the runCmd's exec, and omits it when unset (its `dist/index.js`, +`populateDefaults`); on a GitHub runner `CI=true`. + +## Deliverable 3's exit, as restated by Emil + +| Exit | Result | +|---|---| +| `validate` passes on the head with locked restore | Locally, devcontainer with `CI=true` to up and exec, on `3d0ac65`: `CI=[true] sdk=10.0.404`, every gate ok, 66 tests passed, changelog, issue-refs (6 commits, Refs on 6) and `check --compare` ok, working tree clean after onCreate and after the runCmd. On GitHub, [validate run 389](https://github.com/mindovermachine-dev/decision-driven-design/actions/runs/44313244378) on `3d0ac65`: success; its log shows `--remote-env CI=true` on both `devcontainer up` and the exec, the feature running `dotnet-install.sh --version 10.0.404`, `Restored …/src/Canon/Canon.csproj` (locked), tests passed, `canon check: all gates passed`. Later heads: in the pull request | +| Proof 1: the agent review job's build on a clean install | `install-dotnet.sh --version 10.0.404` (setup-dotnet's own script at `a98b568`, the arguments it derives from the new `global.json`) into an empty `DOTNET_ROOT`, empty `NUGET_PACKAGES`, `PATH` without the system SDK, fresh clone of `3d0ac65`: `dotnet --list-sdks` shows only 10.0.404; `CI=true dotnet run --project src/Canon -c Release -- --help` exit 0, canon's usage printed; tree clean | +| Proof 2: the devcontainer, built here, validate's runCmd in it, with `CI=true` | The first row | +| Proof 3: the throwaway workflow on a GitHub runner | [Run 44313244012](https://github.com/mindovermachine-dev/decision-driven-design/actions/runs/44313244012), on `3d0ac65`: success. setup-dotnet ran `install-dotnet.sh --skip-non-versioned-files --version 10.0.404` ("already installed", the image's); `CI=true`; `dotnet --version` 10.0.404; `Restored …/src/Canon/Canon.csproj`; `Build succeeded. 0 Warning(s) 0 Error(s)`. Removed in its own commit | +| Every commit carries `Refs #83` | `canon issue-refs` over `84aa466..` on each pushed head | +| Final proof | The first agent review run after landing; #84 re-runs it (Emil) | + +Not shown, because it cannot be yet: the next patch itself. No SDK newer than 10.0.404 exists +to install beside it. P-4 shows what the host does when the installed SDK is not the pinned one. + +The local devcontainer runs differ from CI's in one scratch base layer only (this sandbox's proxy +CA and proxy variables, `NO_PROXY` for the tests' 127.0.0.1 server, host networking). The base +image, features, onCreate and runCmd are the clone's own. + +## The waiver decision (Q-1): drafted, not filed + +`decision-draft.yaml`, for Emil's ruling on its text. It validates against the decision format +(`validate-claims.py --decisions` over a copy of `core/decisions/` with the draft added: 97 +decisions, ids unique). Fields Emil gives are left as `<…>`: the head that landed, the times lifted +and restored, and the first agent review run after landing. + +**The id. Every branch checked.** This repository: 66 remote branches, decision files up to +`DDD-dec-122` (on `claude/act-map-and-process-2026-11-17`, `claude/pull-and-scope-2026-11-18`, +`claude/act-map-scope-and-pull-2026-11-18`). The principle repository +(`actor-indexed-determination`): 27 branches, decision files up to `DDD-dec-39`, and no text +naming any `DDD-dec-12x`. No branch of either holds a `DDD-dec-123` file. **But** #80's session +bootstrap (`meta/sessions/2026-11-18-act-map-scope-and-pull/bootstrap.md`, line 43, on its +branch) says "A new decision, if one is ruled, would take `DDD-dec-123`". The draft carries +`DDD-dec-123`, the next free id by files; whether #80's conditional mention reserves it is Emil's +to say (question W-1). + +## Successor items, recorded and not acted on (Emil, G1) + +- **S-1. A scheduled check that says when a newer .NET patch exists.** B makes security patches + wait for a manual bump of `global.json`, `devcontainer.json` and the lock file. +- **S-2. The deadlock.** A required check that builds main's canon, with no bypass, means a broken + main can only be repaired by suspending the rule (D-4; the draft decision is the first time). + +## Questions at G2 + +- **W-1.** The waiver's id: `DDD-dec-123` (next free by files on every branch of both + repositories), or `DDD-dec-124`, leaving 123 to #80's session as its bootstrap says? +- **W-2.** The draft's text, for your ruling, with the head, the two times and the run to fill. diff --git a/meta/sessions/2026-11-18-canon-lock-file/predictions.md b/meta/sessions/2026-11-18-canon-lock-file/predictions.md index 6818742..d6c343d 100644 --- a/meta/sessions/2026-11-18-canon-lock-file/predictions.md +++ b/meta/sessions/2026-11-18-canon-lock-file/predictions.md @@ -44,7 +44,7 @@ the container gets SDK 10.0.404, `CI` is unset inside it, the onCreate `dotnet b `src/Canon/packages.lock.json` to 10.0.15 in the bind-mounted checkout (the working tree shows it modified afterwards), and every step is green. The rewrite is discarded after the run. -Result: (scored below) +Result: scored in "P-3, scored" below. ## P-3, scored (written after the G1 push, before G2's operations) @@ -63,7 +63,11 @@ Prediction: with `global.json` at `"version": "10.0.403", "rollForward": "disabl exits non-zero with "A compatible .NET SDK was not found" naming 10.0.403. So a drift between `global.json` and `devcontainer.json` fails validate at its first `dotnet` call, in onCreate. -Result: (scored below) +Result: **held, with one correction.** Exit 155, "A compatible .NET SDK was not found", +"Requested SDK version: 10.0.403", for `--version`, `restore` and `build`; the same with the pin +at 10.0.405 (newer than installed). Wrong: "in onCreate". onCreate runs `dotnet build +tools/canon/canon.slnx` from the repository root, where no `global.json` is, so the first +refusal is the runCmd's `dotnet test` in `tools/canon/`. ## P-5. The fix (B, 10.0.404) and the CI pass-through @@ -74,7 +78,11 @@ from the new `devcontainer.json` with `CI=true` passed to both up and exec (as ` v0.3 does with an `env:` name, read in its dist/index.js), the working tree is clean after onCreate and after the runCmd, and the runCmd exits 0. -Result: (scored below) +Result: **held.** Lock diff three lines; tests' lock unchanged; locked restore and Release build, +0 warnings. Devcontainer on `3d0ac65`, `CI=true` to up and exec: feature ran `dotnet-install.sh +--version 10.0.404`; tree clean after onCreate and after the runCmd; exit 0. Two failed attempts +first, both this sandbox's: the Docker daemon had stopped, then the proxy port had changed under +the scratch Dockerfile. ## P-6. Proof 1: the agent review job's build on a clean install @@ -82,7 +90,7 @@ Prediction: with an empty `DOTNET_ROOT` and NuGet cache, `install-dotnet.sh --ve (what setup-dotnet derives from the fixed `global.json`), then `CI=true dotnet run --project src/Canon -c Release -- --help` from `tools/canon/` exits 0 with canon's usage text. -Result: (scored below) +Result: **held.** `--list-sdks` showed only the scratch 10.0.404; exit 0; usage printed. ## P-7. Proof 3: the throwaway workflow on a GitHub runner @@ -91,4 +99,5 @@ Prediction: on push, the throwaway workflow's setup-dotnet step logs an install `ubuntu-latest`. Validate on the same head is green, including canon's `RepositoryDeclarationTests` (they look at `agent-review.yml` by path only). -Result: (scored below) +Result: **held** for the throwaway run (44313244012: `--version 10.0.404`, `CI=true`, build +succeeded, 0 warnings). Validate on `3d0ac65`: run 389, success, with `CI=true` passed in (findings.md, G2). From 1bf7e56af31cd19e004def678c163ccf224c134f Mon Sep 17 00:00:00 2001 From: "Claude (Emil)" <claude+emil@okkels-klein.dk> Date: Wed, 18 Nov 2026 13:28:23 +0000 Subject: [PATCH 8/8] Remove the throwaway agent review build proof workflow It ran once, on 3d0ac65 (run 44313244012, success), as Emil allowed at G1. Removed in its own commit, before the head to ratify. Refs #83 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01NbWSYRfbmM3FZTaoukTyA7 --- .../workflows/agent-review-build-proof.yml | 45 ------------------- 1 file changed, 45 deletions(-) delete mode 100644 .github/workflows/agent-review-build-proof.yml diff --git a/.github/workflows/agent-review-build-proof.yml b/.github/workflows/agent-review-build-proof.yml deleted file mode 100644 index 36f2fbc..0000000 --- a/.github/workflows/agent-review-build-proof.yml +++ /dev/null @@ -1,45 +0,0 @@ -# THROWAWAY (#83, allowed by Emil at G1, meta/sessions/2026-11-18-canon-lock-file/rulings.md). -# Shows that canon builds with the agent review job's build steps on a GitHub runner, before the -# fix lands: agent-review.yml runs from main (pull_request_target) and builds main's canon, so -# it cannot show this branch's fix. This file is removed in its own commit before the head to -# ratify. Push to this branch only; read-only; no secrets; no check named `agent review`. - -name: agent review build proof (throwaway, #83) - -on: - push: - branches: [claude/canon-lock-file-2026-11-18] - -permissions: - contents: read - -env: - DOTNET_NOLOGO: "true" - DOTNET_CLI_TELEMETRY_OPTOUT: "true" - DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "true" - -jobs: - build: - name: build proof (throwaway) - runs-on: ubuntu-latest - steps: - # As agent-review.yml's steps, with this branch's head checked out in place of main. - - name: Checkout this branch - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 - with: - fetch-depth: 1 - persist-credentials: false - - - name: Set up .NET - uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6 - with: - global-json-file: tools/canon/global.json - - # The build agent review's `dotnet run ... -c Release` does, in locked mode (CI is set on - # the runner), without running `agent-review`, which needs the gates App's token. - - name: Build canon as agent review does - working-directory: tools/canon - run: | - echo "CI=$CI" - dotnet --version - dotnet build src/Canon -c Release