@event4u/agent-config 14.12.0 → 14.14.0

package/src/config/gate-coverage.yml

@@ -15,17 +15,17 @@
 # THE CONTRACT (three rules, each from a real failure)
 # ----------------------------------------------------
 # 1. MACHINE-READABLE COUNT. Every listed gate emits exactly one line
-#    `scanned: <N>` (stdout or stderr), N = artefacts it actually inspected. The
+#    `scanned: <N>` (stdout or stderr), N = artifacts it actually inspected. The
 #    guard never parses a gate's human output — that would make the guard itself
 #    fragile, and a fragile guard is the thing being replaced.
 #
 # 2. CI-IDENTICAL INVOCATION. `argv` MUST match how CI/Taskfile calls the gate.
 #    A bare probe produced a false alarm during the sweep: `skill_linter` looked
 #    blind when called with no arguments, but CI passes `--all` and it scans 429
-#    artefacts. The guard must reproduce the real call or it invents defects.
+#    artifacts. The guard must reproduce the real call or it invents defects.
 #
 # 3. BASELINE, NOT `> 0`. `min_scanned` is a floor, not a zero-check. A gate that
-#    drops from 428 artefacts to 3 is as broken as one that drops to 0, and `> 0`
+#    drops from 428 artifacts to 3 is as broken as one that drops to 0, and `> 0`
 #    cannot see it. Set the floor below the true corpus (room for legitimate
 #    deletions) but far above a collapse.
 #
@@ -40,17 +40,79 @@
 #                visible, or it repeats the sin it exists to catch.
 #   canary       optional mutation recipe (Phase 7) — see CANARY below
 #
-# COVERAGE — THE HONEST DENOMINATOR (re-measured 2026-08-25)
+# COVERAGE — THE HONEST DENOMINATOR (re-measured 2026-08-28)
 # ----------------------------------------------------------
-# 291 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
+# 306 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
 # (the count is computed, not asserted — `check_gate_coverage.count_gate_scripts`,
-# re-run on the tree carrying these rows, with `check_skill_admissions`,
-# `check_command_examples`, `check_routing_coverage`, `description_route_check`
-# and `lint_skill_trigger_corpus` counted).
-# **63 of them emit the machine-readable `scanned: <N>` line under their
-# CI-identical argv, and 60 of those 63 are listed below.** The manifest is
-# therefore complete with respect to its own contract for every gate that can
-# carry a floor, and covers ~21 % of the population.
+# re-run on the tree carrying these rows, which now include the four gates the
+# two runtime-cost roadmaps add: check_prefix_stable_mutation,
+# check_loss_class_declared, check_benchmark_report_fields, and
+# check_no_currency_in_cost_surfaces).
+# **78 of them emit the machine-readable `scanned: <N>` line under their
+# CI-identical argv, and 75 of those 78 are listed below.** The manifest is
+# complete for every gate that can carry a floor, covering ~25 % of the population.
+#
+# RECOUNTED 2026-08-31, on the change that adds `lint_promotion_paths` — and the
+# 2026-08-30 block above was already stale when this row landed, in BOTH numbers
+# rather than only in the one this change moves. Recomputed on this tree:
+# `count_gate_scripts()` returns **310** and `grep -c '^  - id:'` returns **81**
+# (80 before this row), so 81/310 = 26.1 %. The script count rose without any
+# recount, which is the drift the blocks below keep describing; it is recorded
+# here rather than folded into the 2026-08-30 prose, because that block is a
+# measurement of a tree that no longer exists.
+#
+# RECOUNTED ON A MERGE, 2026-08-30 — the fifth time, and the same shape as the
+# 2026-08-26 blocks below: two sides each correct for their own tree (~24 % from
+# the branch, ~25 % from main) meeting in one number. Recomputed rather than
+# picked: `count_gate_scripts()` returns **306** and `grep -c '^  - id:'`
+# returns **76** on the merged tree, so 76/306 = 24.8 % and main's side is the
+# right one — arrived at by arithmetic, not by taking theirs.
+#
+# RECOUNTED ON A MERGE, 2026-08-26 — the fourth time this file has met the case
+# the 2026-08-24 block below describes, and this one left TWO STACKED claim
+# blocks rather than a conflict inside one number: 295/68 from this branch and
+# 296/67 from main, each correct for its own tree. Collapsed to one recomputed
+# block rather than reconciled by hand: `count_gate_scripts()` returns **296**
+# and `grep -c '^  - id:'` returns **66** on the merged tree.
+#
+# 66 + 3 unlisted emitters (`lint_evidence_artifacts`, `adr_cite_check`,
+# `check_new_adr_evidence`) = 69.
+#
+# RECOUNTED ON A MERGE, 2026-08-26, and the merge left TWO stacked header claims
+# rather than a conflict inside one number — each branch had recounted correctly
+# for its own tree, and keeping both sides produced a page asserting 294/62 and
+# 295/64 four lines apart. Collapsed to one recomputed block: `count_gate_scripts()`
+# returns **295** and `grep -c '^  - id:'` returns **64** on the merged tree.
+#
+# A paragraph that briefly stood here claimed the emitter total "cannot be
+# derived by grep" and dropped it. That was true of the method it tried and
+# wrong as a conclusion — every LISTED row is an emitter by construction (a row
+# that did not emit could carry no floor) and the same three emitters remain
+# deliberately unlisted, so 64 + 3 = 67. The figure is arithmetic over this
+# file, not a grep over `src/scripts/`, and it is restored rather than left
+# absent.
+#
+# RECOUNTED ON A MERGE, 2026-08-26 — the case the 2026-08-24 block below was
+# written for, arriving again. Two branches each added one row and each recorded
+# a correct population line for its own tree, so the merge put 293 and 294 side
+# by side; after the merge both gates exist, so either figure describes a tree
+# that no longer does. Recomputed on the merged tree rather than reconciled by
+# hand: `count_gate_scripts()` returns **294** and `grep -c '^  - id:'` returns
+# **63**.
+#
+# The emitter total moves with the listed count for the reason the 2026-08-25
+# paragraph already states: every LISTED row is an emitter, because a row that
+# did not emit could carry no floor, and the same three emitters remain
+# deliberately unlisted (`lint_evidence_artifacts`, `adr_cite_check`,
+# `check_new_adr_evidence`). 63 + 3 = 66.
+#
+# RECOUNTED on 2026-08-26 while adding `lint_canonical_terms`
+# (road-to-canonical-terms 2.3). Recomputed, not adjusted — the two commands in
+# the 2026-08-24 block below were re-run on this tree and returned 293 and 61.
+# The population moved by TWO while one row was added, which is why the prose was
+# not incremented by hand: a second gate script had arrived since the last count
+# without a manifest row, and hand-arithmetic would have recorded 292 and been
+# wrong in a way nobody could see.
 #
 # `description_route_check` is counted in the POPULATION and deliberately NOT
 # listed: it is diff-scoped, so its natural reading on most trees is zero cases,
@@ -306,10 +368,56 @@
 # in-place edit would need byte-exact restoration of a tracked file, and a canary
 # that can corrupt the tree violates the never-ships rule it inherits. The
 # consequence is a real gap — a gate whose only possible violation is a
-# modification of an existing tracked artefact (`check_condensation`, whose
+# modification of an existing tracked artifact (`check_condensation`, whose
 # contract is `dist == rewrite(src)`; `check_ci_local_parity`, whose corpus is
 # workflow files) carries no recipe and is reported UNPROVEN, never green.
 gates:
+  - id: lint_metric_consumers
+    argv: ["--quiet"]
+    min_scanned: 5
+    corpus: "entries in src/config/metric-registry.yml (7 at the time of writing). The floor is 5, not 1: the registry's failure shape is a scan that reads a truncated or renamed file, and a single surviving entry would still pass a `> 0` check while the other six went unchecked."
+    status: enforced
+    no_canary_reason: >-
+      A create-only canary cannot express this gate's violation. The corpus is
+      the `metrics:` list inside ONE tracked file, so a planted file lands in no
+      row; every violation it can have is a MODIFICATION — a field emptied, a
+      field replaced with boilerplate, an id duplicated. Same class as
+      `check_no_automerge_key` and `lint_memory_twin_parity`. Discrimination is
+      proven instead by the gate's own `--self-test`: 7 cases, 6 rejecting,
+      each driving the real CLI against a throwaway registry.
+    note: >
+      road-to-experience-loop-broadening step 0.3. Refuses a metric that does
+      not name its consumer, the decision it feeds, and what fails without it.
+      The third field is the falsifiable one: the first two are answerable for a
+      metric nobody needs, and if the honest answer to "what fails without it"
+      is nothing, the entry cannot be written. HONEST LIMIT, stated in the
+      gate's own docstring: it checks SHAPE, not truth — it makes the omission
+      impossible, not the answer correct, because telling a real consumer from a
+      plausible sentence is a review judgement no parser has.
+  - id: lint_consolidation_lineage
+    argv: []
+    min_scanned: 0
+    corpus: "every agents/roadmaps/*.md, counted as FILES rather than as declarations. THE FLOOR WAS RETIRED ON 2026-08-30 AND REPLACED WITH AN ENUMERATION ASSERTION IN THE LINTER ITSELF (AI council, anthropic + openai, convergent on option b). It sat at 5 over a population under deliberate drawdown to ZERO, so it went red the day the drain succeeded — 6 active roadmaps to 4 in one afternoon — and the only available move was lowering the number again, a treadmill ending at a floor of 0, which is no floor. What guards the scope now is `lint_consolidation_lineage` refusing outright when a declared root is missing, is not a directory, or cannot be enumerated; that check lives in the PRODUCTION linter rather than here on purpose, because an independent existsSync in this gate would observe a directory without proving the linter enumerated it. Honest limit, named rather than implied: it catches a missing or renamed root, not a glob narrowed to match nothing, not enumeration in the wrong working directory, and not roadmaps moved into nested directories the walk no longer traverses. Today none of them carries a `consolidates:` field, so the finding count is legitimately zero while the scanned count is not — that split is the point: a declaration-count floor would be a zero-check wearing a ratchet's name, and would go green the moment the scan root moved. The floor sits at 5 rather than near the present 12 because the active estate is under deliberate drawdown (one-in-one-out plus an explicit drain), so a falling count is expected work rather than a collapse; below 5 the estate would be smaller than any point in its recorded history. NO CANARY, deliberately: the council decision that admitted this gate (2026-08-27, 2/2 convergent, E1=b/E2=report) fixed it in REPORT mode, so it exits 0 on findings by design and a planted violation could not turn it red. Its ability to go red is proven instead by `--self-test`, which the same decision required: six declaration spellings must parse identically, all four finding types must fire, and a complete folder must stay silent."
+    status: enforced
+    no_canary_reason: "A report-mode gate cannot be turned red by a planted file. The council decision that admitted this gate (2026-08-27, 2/2 convergent, E1=b/E2=report) fixed it in report mode deliberately: the four measured failures come from a high-noise drafting context and do not establish precision on the tracked estate, so blocking is earned by tracked-scope evidence rather than assumed. A canary here would either be planted and ignored (proving nothing) or force `--strict` into CI, which would decide E2 by wiring instead of by evidence. The negative control is `--self-test` instead, required by the same decision and stronger than a single planted file: six declaration spellings must parse to an identical parent set, all four finding types must fire, and a complete folder must stay silent — the third arm being what stops a checker that returned every code unconditionally from passing the second. Revisit together with E2: when the tracked half is promoted to blocking, it owes a canary."
+  - id: lint_carrier_integrity
+    argv: []
+    min_scanned: 600
+    corpus: "every roadmap file under agents/roadmaps/archive/ and agents/roadmaps/skipped/ — 656 at the time of writing, and the count only rises because archival is one-way. The floor sits at 600 rather than near 656 because a reading below it means the walk lost a directory, not that roadmaps were un-archived. The walk direction is the design: a `[~]` carry is validated once, when the parent is archived, by a sweep that then never looks at the pair again, so the receiver can be deleted afterwards with nothing going red. Starting from the archived parent — which names its destination by slug and which nothing rewrites — makes whole-file deletion detectable on the first pass, with no registry to maintain. TWO CLASSES, and the split decides the tier: `broken-destination` (deleted, renamed, re-parented, skipped, or archived with open steps) is a HARD failure at zero with no baseline, because every member had a recorded home and lost it; `unannotated` (a bare `[~]` with no annotation at all) is ratcheted at 243 in gate-violation-baselines.json, all of it predating the annotation contract by up to three months."
+    status: enforced
+    canary:
+      class: contract-violation
+      path: agents/roadmaps/archive/zz-canary-carrier-integrity.md
+      content: |
+        ---
+        complexity: bounded
+        ---
+        # Canary planted by check_gate_coverage --canary; never ships.
+
+        ## Phase 1 — a phase
+
+        - [~] **1.1 A step carried to a receiver that does not exist.**
+              <!-- deferred-resolution: carried-to=road-to-zz-canary-receiver-that-does-not-exist -->
   - id: lint_skill_trigger_corpus
     argv: []
     min_scanned: 70
@@ -406,7 +514,7 @@ gates:
       per-class red observation lives in the gate's own `--self-test` (9 cases,
       6 rejecting), which proves every class discriminates over a synthetic
       payload with no pack run. Two of the four cannot be planted through the
-      register at all: `compiled-test-artefact` is excluded from the payload by
+      register at all: `compiled-test-artifact` is excluded from the payload by
       the `files[]` negations that fixed it, so a plant never ships and never
       reds, and `source-map` needs 121 files in a BUILT tree.
 
@@ -461,7 +569,7 @@ gates:
     corpus: "the npm pack payload (2,686 in an unbuilt worktree on 2026-08-22), read to classify each .npmignore pattern against what actually shipped"
     status: enforced
     no_canary_reason: >-
-      the violation is a MODIFICATION, not a creation: this gate reds when package.json `files[]` or `.npmignore` changes and the committed artefact does not, and the canary contract is create-only. A planted FILE cannot move either surface — the closest it gets is changing the payload-derived shadowed set, which is informational and deliberately excluded from the drift verdict, so a plant would leave the gate green and be reported as dead. Discrimination is proven by the gate's own `--self-test` (8 cases, 5 rejecting) over the pattern matcher, and end to end by hand: editing `files[]` alone exits 1, regenerating exits 0, editing `.npmignore` alone exits 1, restoring exits 0.
+      the violation is a MODIFICATION, not a creation: this gate reds when package.json `files[]` or `.npmignore` changes and the committed artifact does not, and the canary contract is create-only. A planted FILE cannot move either surface — the closest it gets is changing the payload-derived shadowed set, which is informational and deliberately excluded from the drift verdict, so a plant would leave the gate green and be reported as dead. Discrimination is proven by the gate's own `--self-test` (8 cases, 5 rejecting) over the pattern matcher, and end to end by hand: editing `files[]` alone exits 1, regenerating exits 0, editing `.npmignore` alone exits 1, restoring exits 0.
 
   - id: check_pack_passport_reconciliation
     argv: []
@@ -821,7 +929,7 @@ gates:
   - id: check_no_roadmap_refs
     argv: []
     min_scanned: 700
-    corpus: "stable artefacts across src/{rules,skills,agent-src/*} + docs/ + agents/settings/contexts (872 at baseline)"
+    corpus: "stable artifacts across src/{rules,skills,agent-src/*} + docs/ + agents/settings/contexts (872 at baseline)"
     status: enforced
     canary:
       class: stale-reference
@@ -829,7 +937,7 @@ gates:
       content: |
         ---
         type: auto
-        description: "Planted canary rule linking a stable artefact into the transient roadmap tree."
+        description: "Planted canary rule linking a stable artifact into the transient roadmap tree."
         ---
 
         See [the plan](../../agents/roadmaps/road-to-nowhere.md) — the exact
@@ -837,7 +945,7 @@ gates:
     note: >
       Retargeted 2026-07-29 from the ADR-051-emptied tree. It had been enforcing the
       no-roadmap-references rule for docs/ only while the rule + skill layer went
-      unscanned — 0 -> 872 artefacts. No violation had slipped through (verified),
+      unscanned — 0 -> 872 artifacts. No violation had slipped through (verified),
       so this closed a latent gap, not a live breach.
 
   - id: check_context_paths
@@ -921,7 +1029,7 @@ gates:
       silent-green found in the same sweep — the per-pack lint matrix, whose path was
       a double ADR-051 casualty and which exited 0 on an empty match across 17 CI
       shards — is NOT listed here because it was deleted rather than repaired
-      (skill_linter --all already covers all 429 artefacts in 0.5s).
+      (skill_linter --all already covers all 429 artifacts in 0.5s).
 
 
   # ── Registered 2026-08-02 (road-to-renewal-foundation Phase 1) ───────────
@@ -965,7 +1073,7 @@ gates:
     corpus: "src/rules + src/skills + src/agent-src/commands + docs/guidelines .md (533 at baseline)"
     status: enforced
     no_canary_reason: >-
-      thresholds are computed across the whole corpus; a single planted artefact has no population to exceed.
+      thresholds are computed across the whole corpus; a single planted artifact has no population to exceed.
     note: >
       A collapse below the floor would mean the gate stopped reading the tree
       that states extraction thresholds, so a bare or diverging threshold
@@ -1071,10 +1179,45 @@ gates:
       or if a drop to 0 is ever traced to a scanner defect rather than to an
       empty corpus.
 
+  - id: check_gate_reachability
+    script: src/scripts/check_gate_reachability.ts
+    min_scanned: 10
+    corpus: "exemption rows in src/config/gate-reachability-exemptions.json PLUS the gate-shaped task targets reachable from neither `task ci`'s transitive closure nor any workflow. Reachability is measured three ways, not two: a workflow may call `task <name>` OR the script directly, and conflating those overstated the hole 39 -> 22 on this tree."
+    status: enforced
+    no_canary_reason: "The negative control is the gate's own --self-test, run in CI: 4 cases, 2 rejecting, covering BOTH directions — an unreachable target with no row, and a row naming a target that is reachable. It builds throwaway task trees rather than touching this one, which is strictly better than a planted canary here: a canary would mean adding a real unreachable gate target to taskfiles/ and removing it again, and a forgotten one is the exact defect this gate exists to catch."
+
+  # road-to-retired-claims-stay-retired 2.3. The gate was NOT in this manifest
+  # before that roadmap widened it: it asserted its scope with plain
+  # `assertScanned` and published no machine-readable count, so
+  # check_gate_coverage could not see it at all. Widening it to read the
+  # publish-surface set is exactly the moment that becomes indefensible — a
+  # gate that now decides what may ship on npm should not be the one gate
+  # nobody counts.
+  - id: check_claims
+    argv: []
+    min_scanned: 60
+    corpus: "ledger entries in docs/CLAIMS.md (97 at registration: 59 backed, 30 unbacked, 8 closed). The gate's SECOND root, the five files in `PUBLISH_SURFACES`, is not summed into this count — ledger entries and files are different units and a sum of the two is a number nobody can re-derive. That root is guarded by `assertWatchlistResolves` inside the gate, which fires when every publish surface has vanished while a retired phrasing is still registered."
+    status: enforced
+    no_canary_reason: "The gate carries its own `--self-test` (5 cases, 3 rejecting) — so this row is an adopter, not an exemption; the reason field states why a PLANTED canary is additionally unavailable. Beyond the self-test the negative controls are the 30 mechanism tests in tests/scripts/check_claims.test.ts (17) and tests/scripts/check_claims_retired_phrasings.test.ts (13), each building a throwaway tree and running the real script in it. Twenty-one assert a REJECTION, and one publishes the LITERAL historical string (`zero runtime daemon`) that shipped in package.json and .github/about.yml while claim:no-runtime-daemon was already withdrawn. A planted canary here would mean committing a retired phrasing to a real publish surface and removing it again, and a forgotten one is precisely the defect this gate exists to catch."
+
+  - id: check_rule_evidence_declaration
+    argv: []
+    min_scanned: 10
+    corpus: "the ten security / safety-floor rules named in the gate's own SCOPE constant. The floor equals the scope on purpose, unlike every other row here: the corpus is not discovered, it is DECLARED, so a count below it means a row was deleted rather than that the tree shrank. Widening the obligation means adding a row to SCOPE, which raises both numbers together."
+    status: enforced
+    no_canary_reason: "The gate carries its own `--self-test` (6 cases, 4 rejecting), each building a throwaway src/rules/ tree and running the real gate against it — a missing block, a valueless key, and BOTH directions of the conditional rule: an external-source block missing `normative_level` or `verified_on` must reject, and an `own-analysis` block carrying neither must ACCEPT. That pair is the load-bearing one, because a gate enforcing more than the schema would reject a rule the schema accepts. A planted canary cannot express any of them: the violation is a MODIFICATION of one of ten tracked rule files, and a newly created file lands outside the declared scope by construction. Same class as check_no_automerge_key and check_score_contract."
+
+  - id: check_concern_admissions
+    script: src/scripts/check_concern_admissions.ts
+    min_scanned: 0
+    corpus: "agents/decisions/concern-admissions.jsonl rows PLUS the concerns added since the base ref (a SET DIFFERENCE over ids in src/scripts/hook_manifest.yaml, because a concern is a key inside one file rather than a file of its own). Ships at 0: the 55 pre-existing concerns are grandfathered by that forward-only scope, so the first row arrives with the first new concern, and a MALFORMED ledger is a separate hard error in readLedger() rather than an empty read."
+    status: enforced
+    no_canary_reason: "The negative control is the gate's own --self-test, which is stronger than a single planted canary and is run in CI: 6 cases, 3 of them rejecting, covering a concern added with no row, a row with a blank answer, and a rejected row naming a live concern — plus two ACCEPT cases that pin the grandfathering, so a gate that started failing everything would not pass either. A planted canary in the real ledger would additionally have to be removed again, and a forgotten one is a false rejection row in a decision record."
+
   - id: check_estate_count
     argv: []
     min_scanned: 20
-    corpus: "active + parked roadmap files (81 at baseline: 38 active, 43 in later/)"
+    corpus: "active + parked roadmap files (81 at baseline: 38 active, 43 in later/), plus src/scripts/hook_manifest.yaml for the concern axis — a single file read with `git show` at the base ref rather than a third materialised subtree"
     status: enforced
     canary:
       class: contract-violation
@@ -1099,17 +1242,45 @@ gates:
       cannot survive a collapse: at that point the gate's own `reportScanned`
       fires first. (Set to 50 in the first version, corrected on an R2 finding.)
 
+  - id: check_static_parity
+    argv: ["--quiet"]
+    min_scanned: 20
+    corpus: "test files that spell the dispatcher module name, discovered by grep over tests/ and src/. The count is deliberately not written here — it moves with the suite, and four different figures for it appeared across the rounds of this change (R2 round-5 finding 12). The floor is 20, not 1: this gate's silent-failure shape is a discovery COLLAPSE — a grep that stops matching would run two suites of one file each and report them identical, which is the 'gate that scans nothing exits green' case in its most convincing disguise."
+    status: enforced
+    no_canary_reason: >-
+      No plantable violation: the gate's finding is a DIVERGENCE between two
+      whole-suite runs, not a pattern in a file. Planting one would mean making
+      the collector behave differently under the two runs, i.e. writing the bug
+      it exists to detect.
+    note: >
+      road-to-supervised-telemetry-collector step 4.2 (AC-7). Runs the
+      dispatcher-reaching suite twice — collector present-but-off, then aliased
+      away entirely — and compares per-test verdicts rather than declaring each
+      run green. Two green runs are not the assertion; a test that silently
+      turns from `passed` to `skipped` keeps both suites green and only the
+      per-test comparison sees it.
+
+      SELF-TEST EXEMPT, with the reason rather than the omission: a
+      `--self-test` here would have to spawn two full vitest runs over a fixture
+      repository, minutes per invocation, to prove a comparator that is already
+      unit-tested with a REJECTING case —
+      `tests/scripts/check_static_parity.test.ts` drives `compare()` through the
+      `passed → skipped` divergence a length-only check would miss, plus both
+      only-in-one-run directions. The discrimination is proven; what is skipped
+      is proving it a second time through the slowest possible harness. The
+      marker the self-test ratchet reads lives in the gate's own source, beside
+      `main` — this note explains it; that line is what is counted.
   - id: check_completion_review
     argv: ["--advisory", "--base", "origin/main"]
     min_scanned: 1
-    corpus: "findings artefacts under agents/evidence/reviews/ + the current-diff evaluation (1 at baseline — the evaluation itself; artefact count grows with gated PRs)"
+    corpus: "findings artifacts under agents/evidence/reviews/ + the current-diff evaluation (1 at baseline — the evaluation itself; artifact count grows with gated PRs)"
     status: enforced
     no_canary_reason: >-
       git-dependent: it evaluates the current diff against a base ref.
     note: >
       Gate R2 (docs/contracts/plan-review-gates.md § 2). HONEST LIMIT, stated
       because a floor that cannot fail is exactly the false green this file
-      exists to prevent: scanned = artefacts inspected + 1 for the diff
+      exists to prevent: scanned = artifacts inspected + 1 for the diff
       evaluation, so on any run that REACHES the count `min_scanned: 1` cannot
       trip. It is not unreachable in principle — a moved reviews root exits
       before the inventory and reports `scanned: 0`, which the guard does read —
@@ -1141,7 +1312,7 @@ gates:
       deleted, so a drop to 7 means the reviews root moved or the naming
       convention drifted — not that the work went clean. That is precisely the
       case rule 3 exists for. The gate reads the FROZEN records because R2
-      selects only artefacts in the CURRENT review scope, so a superseded round
+      selects only artifacts in the CURRENT review scope, so a superseded round
       renamed out of the `*.findings.md` glob is read by nothing at all — two
       findings sat recorded as `open` in this repo's own corpus for a day
       through exactly that gap.
@@ -1184,15 +1355,15 @@ gates:
       collision gate across four roots at once; one planted name collides with nothing.
     note: >
       Counts NAMES, not files — the scan-scope census counts files under the same
-      roots, so the two artefacts legitimately report different numbers here.
+      roots, so the two artifacts legitimately report different numbers here.
 
   - id: lint_artefact_frontmatter
     argv: ["--quiet"]
     min_scanned: 540
-    corpus: "artefacts carrying frontmatter across the discovery roots (619 at baseline)"
+    corpus: "artifacts carrying frontmatter across the discovery roots (619 at baseline)"
     status: enforced
     no_canary_reason: >-
-      a planted artefact is judged, but the gate reports adoption across the discovery roots, so the number rather than a red is the output.
+      a planted artifact is judged, but the gate reports adoption across the discovery roots, so the number rather than a red is the output.
 
   - id: audit_skill_overlap
     argv: ["--quiet", "--print-table", "--strict"]
@@ -1410,7 +1581,7 @@ gates:
     note: >
       The plant needs a slug that already carries a `prompt_hash` but no committed
       package — a brand-new `zz-canary` slug is skipped, not caught, because an
-      artefact without a package is deliberately out of scope. `zcs-closure` is a
+      artifact without a package is deliberately out of scope. `zcs-closure` is a
       closed round, so it will not gain a real package and the plant cannot
       collide with one. The two planted failures the roadmap asked for (a one-byte
       prompt edit, a pre-loaded verdict) are pinned in
@@ -1469,7 +1640,7 @@ gates:
       That case is the gate's own subject, so it is pinned by a test fixture
       too (`a table that parses to zero rows reds rather than exiting green`).
       No `canary:` recipe: this gate's only violation shape is a MODIFICATION of
-      a tracked artefact (`docs/MIGRATION.md`), and the canary contract is
+      a tracked artifact (`docs/MIGRATION.md`), and the canary contract is
       create-only, so it reports UNPROVEN rather than green. Discrimination is
       proven instead by paired fixtures in
       `tests/scripts/lint_scheduled_deprecations.test.ts`, verified by mutation:
@@ -1600,7 +1771,7 @@ gates:
   #     cmd_settings_check), forcing them into the ledger contract and reddening
   #     the completeness ratchet for work nobody asked for;
   #   - renaming the script to `check_adr_citations.ts` is the convention-conform
-  #     answer and touches 26 files, including archived review artefacts and a
+  #     answer and touches 26 files, including archived review artifacts and a
   #     committed diff.patch that must not be rewritten;
   #   - manifest-driven classification is explicitly rejected by
   #     gate_population.ts's own header (a new gate lands before anyone
@@ -1623,7 +1794,7 @@ gates:
       the gate correctly stays green. Measured on a previous attempt, where the
       gate was then mis-reported as dead. Same class as `check_condensation` and
       `check_ci_local_parity` — the only possible violation is a modification of
-      an existing tracked artefact. The red is proven instead by the committed
+      an existing tracked artifact. The red is proven instead by the committed
       violating fixture `tests/fixtures/automerge-key/` plus two recorded
       sabotage probes in `tests/scripts/check_no_automerge_key.test.ts`.
     note: >
@@ -1632,7 +1803,7 @@ gates:
       lands OUTSIDE the corpus and the gate correctly stays green — measured on a
       previous attempt at this gate, where it was then mis-reported as dead. The
       only violation this gate can have is a modification of an existing tracked
-      artefact, which is the same class as `check_condensation` and
+      artifact, which is the same class as `check_condensation` and
       `check_ci_local_parity`, and the CANARY section above already states that
       such a gate carries no recipe and is reported UNPROVEN rather than green.
 
@@ -1750,42 +1921,54 @@ gates:
       ADR whose dated record must not be rewritten, and a bare rule count with no
       enforcement sense ("2 rules" in a concepts page) which must not be a finding.
 
+  - id: check_supervision_claim_atomicity
+    argv: []
+    min_scanned: 6
+    corpus: "public surfaces a reader lands on — README.md plus seven docs/ pages (8 at baseline, 2026-08-27); the floor is 6 so a page being renamed does not silently shrink the scan to nothing"
+    status: enforced
+    no_canary_reason: >-
+      A create-only canary cannot express this gate's violation. The corpus is a
+      committed CONSTANT (`PUBLIC_SURFACES`), so a planted file lands in no row —
+      the eight rows exist whatever the filesystem holds. The violation is a
+      present-tense supervision claim appearing INSIDE one of those tracked
+      pages, which is a modification. Same class as `check_score_contract`,
+      `check_no_automerge_key` and `check_condensation`.
+      Discrimination is proven instead by the gate's own `--self-test`, which is
+      the step that created it: road-to-runtime-governance-flip 3.4 required
+      seeded negatives to be OBSERVED red, not asserted. **7/7, 5 rejecting**,
+      each building a throwaway git repo so the revision check is real and each
+      driving the real CLI. The rejecting cases: no evidence at all; an emptied
+      suite whose cases all skipped; a result recorded against a different
+      revision; a suite that did not exercise real processes; and a non-integer
+      case count. Two accepting controls: sufficient evidence lets the claim
+      through, and a DENIAL of supervision needs no evidence at all.
+      The refusals are separate because a suite that ran on a parent commit, one
+      that skipped everything, and one that mocked the process layer are three
+      different lies, and a file-presence check catches none of them.
+      **Grown from 4/4 by a neutral council review of the code**, which found the
+      docstring advertising a mocked-process negative the case list did not
+      contain, and — worse — that the pattern matched `is NOT supervised`, so the
+      gate would have refused a truthful denial. Both are closed with regression
+      cases; the second is the `denial` accepting control above.
   - id: check_score_contract
     argv: ["--quiet"]
     min_scanned: 20
     corpus: "rows in `agents/evidence/ac-capability-scorecard.yaml` — one per rubric category recoverable from the tracked tree (23 at baseline, 2026-08-24)"
     status: enforced
-    canary:
-      class: contract-violation
-      path: agents/evidence/ac-capability-scorecard-zz-canary.yaml
-      content: |
-        # zz canary probe: a scorecard awarding `ten` with an empty required
-        # evidence class, which is the one thing this gate exists to refuse.
-        # Create-only, so it is expressible as a canary — unlike the MODIFICATION
-        # shapes (a redeclared `state: complete`, a count edited to match an
-        # added row) that most of this file's ratchets detect.
-        schema_version: 1
-        rubric:
-          state: incomplete
-          authority: unavailable-external-review
-          reported_category_count: 32
-          recovered_category_count: 1
-          missing_category_count: 31
-          manifest_version: baseline_v1
-          recovery_source: agents/roadmaps/road-to-ten-across-the-board.md
-          excluded_from_manifest: []
-        categories:
-          - category: release-integrity
-            baseline: 9.2
-            claim: "canary"
-            closing_path: "canary"
-            mechanism_evidence: ["src/scripts/check_score_contract.ts"]
-            adoption_evidence: ["src/scripts/check_score_contract.ts"]
-            negative_control_evidence: []
-            production_window: src/scripts/check_score_contract.ts
-            outcome_evidence: ["src/scripts/check_score_contract.ts"]
-            non_regression_evidence: ["src/scripts/check_score_contract.ts"]
-            status: ten
+    no_canary_reason: >-
+      Create-only canary cannot reach this corpus. Measured 2026-08-26: the row
+      declared one, and `check_gate_coverage --canary` reported the gate DEAD —
+      it stayed green over the plant. The gate is not dead; the recipe was
+      unreachable. `check_score_contract` reads ONE file (`DEFAULT_REL`, or
+      `--file`), so a newly created `ac-capability-scorecard-zz-canary.yaml`
+      sits outside the corpus by construction and the gate correctly ignores it.
+      Same class as `check_no_automerge_key` and `check_condensation`: the only
+      violation this gate can have is a MODIFICATION of the one tracked
+      scorecard, which a create-only canary cannot express. Discrimination is
+      proven instead by the gate's own `--self-test` (8 cases, 6 of them
+      pointing at the committed twins under `tests/fixtures/score-contract/twins/`)
+      and by `tests/scripts/check_score_contract.test.ts`, which asserts each
+      twin reds on exactly one finding CODE rather than merely on a non-zero exit.
     note: >
       The floor is 20 against a live corpus of 23, and the gap is deliberately
       narrow because this corpus does not grow by ordinary work: a row is added
@@ -1805,3 +1988,486 @@ gates:
       `tests/scripts/check_score_contract.test.ts` asserts each reds on exactly
       one finding CODE — not merely on a non-zero exit, which would let a twin
       keep passing while testing the wrong defect.
+  - id: check_beta_review_markers
+    argv: []
+    min_scanned: 100
+    corpus: "every `stability: beta` contract under docs/contracts/ — 121 at the time this row landed. The floor sits at 100 because the beta population shrinks as contracts promote to stable, so a slow decline is expected and a drop below 100 is a scan-root collapse rather than a promotion wave."
+    status: enforced
+    canary:
+      class: contract-violation
+      path: docs/contracts/zz-canary-beta-lapse.md
+      content: |
+        ---
+        stability: beta
+        keep-beta-until: 2026-01-01
+        ---
+
+        # ZZ canary — a beta contract whose review deadline lapsed
+
+        Planted by `check_gate_coverage --canary`; never ships. The date is far
+        in the past, so this is a FRESH lapse rather than one inside the frozen
+        2026-08-25 baseline — the distinction is the whole point of the gate,
+        because an inherited lapse warns and a new one must fail.
+  - id: lint_canonical_terms
+    argv: []
+    min_scanned: 1200
+    corpus: "every markdown file under src/ and docs/, tracked and untracked. 1,577 exist in the shipped tree; the floor sits at 1,200 so a legitimate documentation prune cannot red it while a scan-root collapse still can. Untracked files are IN the corpus deliberately — the canary below is create-only by contract, so a tracked-only listing would leave the gate green on its own canary."
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/skills/zz-canary-canonical-terms/SKILL.md
+      content: |
+        ---
+        name: zz-canary-canonical-terms
+        description: Canary planted by check_gate_coverage --canary; never ships.
+        ---
+
+        # Canary
+
+        This sentence describes the observed behaviour of an artifact, in prose,
+        outside any fence — two non-canonical spellings the house dialect
+        recorded in `src/config/canonical-terms.yml` decided against. The gate
+        must red on it, because a ratchet that cannot see a NEW occurrence is a
+        ratchet that only records history.
+  - id: lint_host_portability
+    argv: []
+    min_scanned: 600
+    corpus: "every .md under src/skills, src/agent-src, src/domains and src/subagents — 717 today. The floor sits at 600 because the artifact estate only grows by ordinary work and a reading below it means a scan root moved, not that 117 artifacts were deleted."
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/skills/zz-canary-host-portability/SKILL.md
+      content: |
+        ---
+        name: zz-canary-host-portability
+        description: Canary planted by check_gate_coverage --canary; never ships.
+        execution:
+          type: assisted
+          handler: internal
+          allowed_tools: ["FileWriterTool"]
+        ---
+
+        # Canary
+
+        The grant above names a tool no host in this tree is known to honour. A
+        loader IGNORES an unrecognised key, so this artifact reads as restricted
+        and is not — which is the whole defect class the gate exists to refuse.
+  - id: check_host_loadability
+    argv: ["--reach", "--root", "."]
+    min_scanned: 6
+    corpus: "the six host surfaces in HOST_SURFACES (claude-code, cursor, cline, windsurf, gemini-cli, copilot). The floor is the full set rather than a fraction: the surface list is a committed constant, so a reading below 6 means a row was dropped from the constant, never that a projection is legitimately smaller. An ABSENT host tool is a ledger SKIP with its detection signal named, not a missing row."
+    status: enforced
+    no_canary_reason: "Create-only canary cannot reach this corpus, and the reason is structural rather than incidental. The corpus is a committed CONSTANT (HOST_SURFACES in _lib/host_projection_reach.ts), so a planted FILE lands in no row: the six rows exist whatever the filesystem holds. The violation this gate can have is an installed host tool whose projection directory is EMPTY \u2014 a state a create-only plant is the opposite of. Discrimination is proven instead by the measurement itself, which reports 6/6 present and projecting with per-host artifact counts (claude-code 13, cursor 228, cline 14, windsurf 215, gemini-cli 1, copilot 1); a dead projection reads as `empty-projection` and a missing tool as `skipped-tool-absent`, and those two verdicts being DIFFERENT is the whole point of the mode."
+    argv_note: "The `--reach` argv, not the default. The default mode checks that two projections PARSE and emits no coverage line; reach accounts for every host surface and is the mode that carries a corpus. Registered on the argv that emits, per this manifest\u0027s own CI-identical-argv rule \u2014 and note that `--reach` is declared LOCAL-ONLY in ci-local-parity.yml, because a CI runner has no host tool installed and every row would resolve `skipped-tool-absent`, which is the empty-scope false green this manifest exists to refuse."
+  - id: lint_eval_specs
+    argv: []
+    min_scanned: 120
+    corpus: "every eval specification under src/skills/*/evals/, src/domains/*/evals/ and src/agent-src/commands/evals/ — 175 at the time this row landed. The floor sits at 120 because the corpus grows as skills gain evals and shrinks only when a skill is archived; a drop below 120 is a scan-root collapse rather than a pruning wave."
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/skills/zz-canary-eval-specs/evals/evals.json
+      content: |
+        {
+          "skill": "zz-canary-eval-specs",
+          "scenarios": [
+            { "id": "x", "prompt": "planted by check_gate_coverage --canary; never ships", "assertions": [{ "kind": "tool-choice" }] }
+          ]
+        }
+  - id: lint_memory_twin_parity
+    argv: []
+    min_scanned: 7
+    corpus: "the twins declared in src/config/memory-twin-verdicts.yml — 7 today. The floor is the exact count rather than a lower bound: this list does not grow by ordinary work (a twin is added only when a script is duplicated into the template tree, which is a deliberate act), and a DROP means a verdict was deleted rather than earned. A new twin raises the floor in the same commit."
+    status: enforced
+    no_canary_reason: >-
+      Create-only canary cannot reach this corpus. The gate's population is the
+      `twins:` list inside one tracked config file, and every violation it can
+      have is a MODIFICATION — a twin drifting, a verdict deleted, a ceiling
+      exceeded. A newly created file lands outside the list by construction and
+      the gate correctly ignores it. Same class as `check_no_automerge_key`,
+      `check_condensation` and `check_ci_local_parity`. Discrimination is proven
+      instead by the gate's own `--self-test`: 5 cases, 3 rejecting, including
+      the two states the roadmap's verify clause names by hand — a one-line
+      behavioural divergence must RED, and a comment-only divergence must stay
+      GREEN.
+  - id: lint_skill_link_reach
+    argv: []
+    min_scanned: 200
+    corpus: "every skill directory under dist/agent-src/skills — the tree the installer deploys. 299 at the time this row landed, and the floor sits at 200 because the delivered set shrinks when a skill is archived and a scoped projection can legitimately deliver fewer, while a reading below 200 means the projection is broken rather than smaller."
+    status: enforced
+    canary:
+      class: contract-violation
+      path: dist/agent-src/skills/zz-canary-link-reach/SKILL.md
+      content: |
+        ---
+        name: zz-canary-link-reach
+        description: Canary planted by check_gate_coverage --canary; never ships.
+        ---
+
+        # Canary
+
+        This body links to [a skill that is not delivered](../zz-canary-absent-target/SKILL.md).
+        The gate must red on it: a consumer following that link gets a 404, and a
+        link checker that reads only `src/` cannot see the difference between a
+        missing file and a file that exists but did not ship.
+  - id: lint_composition_review
+    argv: []
+    min_scanned: 380
+    corpus: "the skill + rule corpus — every src/skills/*/SKILL.md and src/rules/*.md (419 at baseline: 299 skills + 120 rules)"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/rules/__canary_composition_review__.md
+      content: |
+        ---
+        name: __canary_composition_review__
+        composition_review:
+          - candidate: rule:this-rule-does-not-exist
+            disposition: create_separate
+            rationale: a canary record naming an incumbent that is not in the tree
+        ---
+
+        # canary
+    note: >
+      road-to-composition-before-creation Phase 4.1. Two halves with different
+      teeth, on purpose. The STRUCTURAL half is hard: a present record whose
+      candidate resolves to nothing, whose `none`/`none_found` pair disagrees,
+      whose disposition is off-enum, which repeats a candidate, which is empty,
+      or which uses a YAML block scalar, exits 1. The PRESENCE half is advisory
+      and exits 0: an artifact added without a record is reported by path and
+      never blocks. Flipping that to a block needs a false-positive rate from at
+      least one release of advisory operation, which the roadmap records as not
+      yet measured and does not pre-authorise.
+
+      WHAT IT CERTIFIES, narrowed after an independent review (2 seats, both
+      raising it): REFERENTIAL CONSISTENCY, never that a search happened. An
+      author can name any existing artifact, write `create_separate` and a
+      sixteen-character rationale, and pass. The earlier wording here said a
+      record pointing at a non-existent incumbent "reads as evidence of a search
+      that cannot have happened", which reads as a claim about the search — it is
+      not one, and the module docstring makes the same narrowing. What the hard
+      half buys is that a record cannot point at nothing; whether it points at
+      the RIGHT thing is a reviewer's judgement, and the roadmap's own Risk 1 is
+      that the field becomes a pro-forma line.
+
+      DISCRIMINATION is carried by `--self-test` (8 cases, 5 rejecting), not by
+      the canary. The canary is one create-only recipe by design and exercises
+      the unresolvable-candidate door only; the other five hard doors and the
+      advisory path are covered by the self-test and by
+      tests/scripts/lint_composition_review.test.ts, including a real-git
+      fixture for the untracked-addition union.
+
+      COMPATIBILITY: this is a new HARD whole-corpus gate, so a pre-existing
+      malformed record anywhere in the tree would fail every later PR. Measured
+      at landing: 419 artifacts scanned, 0 records malformed, because zero
+      artifacts carry the field at all — the hard half can only fire on a record
+      that EXISTS, so a corpus with none cannot fail it. The first record written
+      is the first thing that can.
+
+      `{{.QUIET_FLAG}}` in the taskfile against `argv: []` here: `--quiet`
+      suppresses per-finding lines only. Verified — `scanned: 419` and the exit
+      code are byte-identical with and without it, so the coverage measurement
+      and the CI invocation cannot diverge.
+
+      The floor is 380 against a live 419 — room for real deletions, far above
+      a collapse. The corpus is the whole estate rather than the diff precisely
+      so the floor can be honest: `lint_evidence_artifacts` declines
+      registration here because a diff-scoped gate legitimately scans 0, and
+      this gate narrows to the diff only for the advisory half.
+
+  - id: check_prefix_stable_mutation
+    argv: []
+    min_scanned: 35
+    corpus: "hook-manifest concerns bound on at least one mid-session slot, whose script exists (45 at baseline, across 45 mid-session concerns)"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/scripts/__canary_prefix_stable__.ts
+      content: |
+        // A canary hook that writes a prefix-stable surface mid-session.
+        // The gate reads the MANIFEST, so this file alone cannot trip it —
+        // which is why DISCRIMINATION is carried by --self-test, not here.
+        import * as fs from 'node:fs';
+        fs.writeFileSync('dist/agent-src/rules/__canary__.md', 'x');
+    note: >
+      road-to-runtime-context-floors step 1.2 — the RUNTIME half of prefix
+      stability. `check_kernel_prefix_stability` guards the kernel prefix at
+      authoring time against a committed snapshot, and `_lib/payload_hash_drift`
+      measures churn after the fact from an audit ledger; neither can see a hook
+      rewriting a prefix-stable surface DURING a session, which invalidates the
+      prompt cache for the rest of it.
+
+      THE SURFACE LIST IS LOADED, NOT RESTATED. Both this gate and
+      `check_preamble_payload_budget` import `PREFIX_STABLE_SURFACES` from
+      `_lib/prefix_stable_surfaces.ts`. That refactor is part of the same change:
+      the budget gate previously stated its three roots twice inside its own
+      file, and a third statement here would be the drift shape this repository
+      already pays for elsewhere.
+
+      DISCRIMINATION is carried by `--self-test` (7 cases, 2 rejecting), NOT by
+      the canary. The gate's corpus is the hook manifest, so a planted script
+      that no manifest binds is invisible to it by construction — the canary
+      above documents the violating SHAPE for a reader and is honestly not the
+      discriminator. The self-test plants a manifest as well as a script, which
+      is what actually proves the red path: a fixture concern on `post_tool_use`
+      writing `dist/agent-src/rules/` fails, and the same concern with
+      `re_arm: pre_compact` passes.
+
+      FAIL-CLOSED on an undecidable target, per the council that resolved
+      `which-surfaces-are-prefix-stable` (2026-08-28, 2/2): a write whose target
+      is computed at runtime, in a file that ALSO carries a literal resolving
+      into a declared surface, fails. Narrow on purpose — a dynamic write in a
+      file with no such literal is not reported, because a gate that flagged
+      every dynamic write in every hook is one nobody can keep green.
+
+      The floor is 35 against a live 45: room for real concern deletions, far
+      above a collapse. `{{.QUIET_FLAG}}` against `argv: []` is safe here —
+      `--quiet` suppresses only the success line, and `scanned:` is emitted
+      outside that guard.
+
+  - id: check_loss_class_declared
+    argv: []
+    min_scanned: 45
+    corpus: "every hook-manifest concern whose script exists (53 at baseline); of those, the model-facing lossy subset is the gated population"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/scripts/__canary_loss_class__.ts
+      content: |
+        // A model-facing lossy transform with no loss_class declaration.
+        // As with the sibling gate, the manifest is the corpus, so the
+        // discriminator is --self-test rather than this plant.
+        const WORD_CAP = 400;
+        export function run() {
+          return { context: redactLines(body).slice(0, WORD_CAP).join('\n') };
+        }
+    note: >
+      road-to-runtime-context-floors step 3.2. Strictness was decided, not
+      assumed: council 2026-08-28 (2/2 convergent) resolved
+      `how-strict-the-loss-class-lint-is` as option (b) — FAIL on transforms
+      whose output reaches the model, WARN elsewhere. Option (a) (fail
+      everywhere in `src/`) buys a first-run backlog whose usual answer is a
+      broad allowlist, which this repository has measured emptying a gate;
+      option (c) (warn everywhere, ratchet later) is the shape this repository
+      has measurably never ratcheted. Both seats added the refinement adopted
+      here: unknown reachability is classified as model-reaching.
+
+      MEASURED AT LANDING: **1** module qualifies — `hot_context_hook`, which is
+      exactly the `ephemeral-lossy` exemplar `docs/contracts/loss-classes.md`
+      classifies. A gated population of one is the honest state of this tree,
+      not a broken detector, and it is why the floor below is set on the SCANNED
+      corpus (53 hook scripts) rather than on the gated subset.
+
+      THE DETECTOR READS CODE, NOT PROSE. Its first cut matched `truncat` inside
+      three docblocks that describe truncation without performing any and
+      reported a corpus of four; three of those four were comments. Comments are
+      stripped before matching, and one self-test case pins that direction
+      ("prose about truncation is not truncation"), because a gate that fires on
+      writing about a defect is how a real corpus of one becomes a pro-forma
+      corpus of four.
+
+      DISCRIMINATION: `--self-test`, 8 cases, 3 rejecting — including the two
+      that matter beyond "missing declaration": a `recoverable-lossy` with no
+      `loss_recovery` locator (without it the class is indistinguishable from
+      `ephemeral-lossy`) and a misspelled class name.
+
+  - id: check_benchmark_report_fields
+    argv: []
+    min_scanned: 4
+    corpus: "committed benchmark reports under internal/bench/reports/ that announce a schema_version and a corpus/selection block (6 at baseline)"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: internal/bench/reports/__canary_missing_cache__.json
+      content: |
+        {
+          "schema_version": 1,
+          "corpus": { "id": "__canary__" },
+          "selection": { "top_k": 3 }
+        }
+    note: >
+      road-to-runtime-context-floors step 4.1. `cache.read_write_ratio` and
+      `cache.stable_prefix_share` are REQUIRED fields; a report that cannot
+      compute one emits `{ unavailable: "<reason>" }` rather than omitting the
+      key or emitting a zero. A blank reads as "no cache activity" and a zero
+      reads as "the worst possible ratio" — both are claims, and neither is the
+      claim "this was not measured".
+
+      The canary IS the discriminator here, unlike its two siblings: this gate's
+      corpus is a directory of files, so a planted report is genuinely in scope
+      and a create-only plant exercises the real red path. `--self-test` adds 7
+      cases (5 rejecting) covering the forms a plant cannot reach — a blank
+      `unavailable` reason, and a share above 1.
+
+      COMPATIBILITY: six committed reports predate the requirement, and all six
+      were backfilled in the landing change with a stated reason rather than a
+      fabricated number — additively, 48 insertions and 0 deletions, so no
+      historical measurement moved.
+
+      The floor is 4 against a live 6. `allowEmpty` is declared
+      (`OPTIONAL_INPUT:`) because benchmark reports are run artefacts rather
+      than source and a checkout may legitimately carry none; the floor applies
+      whenever any are present.
+
+  - id: check_no_currency_in_cost_surfaces
+    argv: []
+    min_scanned: 4
+    corpus: "the four cost surfaces road-to-delivered-cost-truth built (4 at baseline) — a named watchlist, not a tree walk"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/scripts/__canary_currency__.ts
+      content: |
+        // A planted file is NOT in this gate's corpus by construction — the
+        // watchlist is four named files. Discrimination is --self-test's job.
+        out.push(`total: $42`);
+    note: >
+      road-to-delivered-cost-truth AC-7. The suite does not know a consumer's
+      contract — subscription, per-token, committed spend, a reseller rate — so
+      any monetary figure it printed would be extrapolated from a rate it
+      invented. That is worse than no number, because it is actionable and wrong,
+      and it is exactly the thing someone reasonably adds back later on the
+      grounds that a cost report should show cost.
+
+      SCOPE IS A NAMED LIST, NOT A PATTERN, and that is the load-bearing choice.
+      `cache_realization_report` legitimately carries a `cost_usd` block for
+      back-compat with downstream consumers; a gate sweeping `src/scripts/*cost*`
+      would fail on it and be neutered with an allowlist inside a release. The
+      watchlist is asserted by `assertWatchlistResolves`, so a renamed surface is
+      a dead scope (exit 2) rather than a silent pass.
+
+      THE DETECTOR TOOK TWO CORRECTIONS, BOTH FROM ITS OWN SELF-TEST, and both
+      are pinned as accepting cases so a future widening cannot reintroduce them:
+      a bare `$` substring matches TEMPLATE INTERPOLATION (`${value}`), and
+      excluding `${` alone still matched a REGEX END ANCHOR (`/\.md$/`). The
+      shipped pattern is positive rather than subtractive — a currency `$` is
+      followed by a digit or by an interpolated amount — because a gate whose
+      first real run produces dozens of false positives gets an allowlist within
+      a release and then guards nothing.
+
+      DISCRIMINATION: `--self-test`, 9 cases, 4 rejecting. The canary above
+      documents the violating shape for a reader and is honestly NOT the
+      discriminator, because a created file lands outside a four-name watchlist.
+
+  - id: lint_promotion_paths
+    argv: ["--quiet"]
+    min_scanned: 1800
+    corpus: "every .ts file under src/ and tests/ (2812 at baseline). The floor is 1800, not 1: this gate's failure shape is a walk that stops at a renamed root or a skip-list that grows, and a partial walk certifies exactly the coverage it did not perform."
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/scripts/__canary_promotion_bypass__.ts
+      content: |
+        import { parseCandidateRecord } from './_lib/candidate_record.js';
+        const promoted = { ...parseCandidateRecord, lifecycle: 'promoted' };
+        fs.writeFileSync(path.join(REPO_ROOT, 'src', 'rules', 'x.md'), promoted);
+    note: >
+      road-to-harness-promotion-bridge — discharge route 1 of the carried
+      blocking condition. The condition covers "a verb, a state transition into
+      `promoted`, or any write into `src/` derived from a candidate", and the AI
+      council of 2026-08-31 ruled it NOT DISCHARGED because only the first two
+      were gated. This gate inventories all three limbs across the whole
+      authored tree and fails when a promotion-capable write bypasses the single
+      guarded capability in `src/scripts/_lib/promotion_capability.ts`.
+
+      THE CAPABILITY IS UNOBTAINABLE WHILE `blocker: merge-authority` IS OPEN,
+      and R0 proves that by CALLING it rather than by reading it — a text match
+      would pass over a refusal edited into a no-op. Sensitivity of R0 was
+      observed: neutralising the refusal makes the gate red with
+      "capability obtainable while the blocker is open".
+
+      ANTI-VACUITY IS THE POINT, not a bonus. The condition's own text says a
+      check over a population of zero discharges nothing, so three floors are
+      asserted separately — 400 files, 4 candidate-derived modules, 10
+      filesystem-write sites inside them — each via `assertScanned`, each exiting
+      2 rather than green. Live values at baseline: 2812 / 16 / 66.
+
+      THE CANARY IS A GENUINE DISCRIMINATOR here: the corpus is a tree walk, so
+      a planted file is in scope and a create-only plant exercises the real red
+      path on all three limbs at once. `--self-test` adds 15 cases (9 rejecting)
+      covering the forms a single plant cannot reach — the interface-declaration
+      accepting pole, a two-argument `assertTransition`, a candidate-derived
+      write into a CLONE's `src/` (out of scope: a clone is a candidate's own
+      sandbox, already gated by `bench_ab_integrity`'s allowed-delta-path check),
+      a candidate-derived READ of `src/`, and prose in a block comment.
+
+      TWO DEFECTS WERE FOUND BY RUNNING IT, both pinned as cases: a substitution
+      that rewrote identifiers INSIDE string literals (`cand` in `'ac-cand-'`),
+      and an expansion that DESTROYED the `REPO_ROOT` token the rule keys on
+      because `REPO_ROOT` is itself a `const`. The first produced a false
+      positive on a tmpdir removal; the second silently dropped the R3 half of a
+      planted three-limb bypass, which is the failure direction that matters.
+
+  - id: lint_code_comments
+    argv: ["--base", "origin/main"]
+    min_scanned: 0
+    corpus: >
+      the source files a change touches, measured against the base ref — a DIFF,
+      not a tree walk. The floor is 0 deliberately: a docs-only or config-only
+      change legitimately carries no source file, and a floor above 0 would red
+      exactly those commits. The scan-scope failure this class exists to catch
+      cannot occur here, because there is no committed path list that can go
+      stale — the root is `git diff`, and git answers for its own range.
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/scripts/__canary_comment_discipline__.ts
+      content: |
+        // Hier stehen nur die Werte, die Bedeutung tragen und nicht mehr.
+        export const canary = 1;
+    note: >
+      The carrier `code-comment-discipline` never had, and the one the "Code
+      comments English" clause of `language-and-tone` claimed via a `.md`-only
+      validator (`check_md_language.ts:175` rejects every other path).
+
+      THE CANARY IS A GENUINE DISCRIMINATOR: the corpus is a diff, a newly
+      created file is in it by construction, and the planted content trips the
+      `de-comment` class on two function words with no umlaut — the
+      transliterated form the real incident was written in, not the easy case.
+
+      DISCRIMINATION IS ALSO PINNED BY FIXTURE, in both directions, because a
+      language heuristic is only usable if its near-misses are known:
+      `tests/scripts/lint_code_comments.test.ts` asserts silence on an umlauted
+      proper name, a non-ASCII sample value inside a code span, a `Ü2` step
+      label, and a German user quotation spanning two comment lines — the four
+      shapes this repository's own hooks actually contain. Measured over 402
+      source files here: zero findings. Measured over the 45 changed files of
+      the consumer repository that prompted the gate: 530.
+
+      SENSITIVITY WAS OBSERVED, not assumed: neutralising the German predicate
+      turns 4 of the 20 table cases red and restoring it turns them green. (The
+      earlier wording said "4 of the 22" and described the inline vitest corpus
+      that the fixture-table refactor replaced; a completion review caught the
+      stale denominator.)
+
+      THE GATE ALSO CARRIES ITS OWN `--self-test` (20 cases, 11 rejecting),
+      which drives the real binary rather than the imported classifier — argv
+      parsing, scan-scope assertion and exit codes included. It does NOT reach a
+      consumer checkout, and the earlier claim that it did was withdrawn after a
+      completion review: `runGateCli` spawns `<repoRoot>/node_modules/.bin/tsx`
+      and both `tsx` and `vitest` are devDependencies, `dist/scripts/` carries no
+      compiled twin, and `scripts-run` is not in `files[]` — so where the suite
+      is absent the self-test cannot run either, and where it runs the suite is
+      present. What it buys is real and narrower: it exercises the CLI half that
+      the vitest file cannot reach, and CI runs the gate only in diff mode,
+      which exits 0 on an empty diff. It is ONE table, not a second corpus: the cases
+      live in `COMMENT_CASES`, exported by the gate, and the vitest file
+      enumerates the same export against `scanText` while the self-test
+      enumerates it against the CLI. A second table over one classifier would
+      drift, and the copy nobody runs locally drifts first. Floors are set at
+      16/8 against a real 20/11, so deleting a case to reach green fails and a
+      deliberate shrink shows up as a floor edit in the diff. Sensitivity
+      re-observed on the self-test the same way: neutralising the German
+      predicate turns exactly 4 of the 11 rejecting cases red (the three
+      German-comment shapes and the reasonless escape) while the report and
+      provenance cases stay green, and restoring it returns 20/20. The block-comment
+      continuation and JSX cases arrived with the two blind spots fixed on
+      `origin/main` and were folded into the same table on merge, so both surfaces
+      cover them rather than the vitest file alone.
+
+      NOTE ON THE ADOPTION RATCHET, stated because the number does not move:
+      `gate-self-test:registered-non-adopters` counts manifest rows that are
+      `enforced` AND carry `min_scanned >= 1`. This row's floor is 0 for the
+      reason the corpus field gives, so it was never in that population and
+      the count stays at 24 either side of this change. The self-test is
+      therefore adopted on its merits rather than to clear a ratchet.