@event4u/agent-config 14.7.0 → 14.9.0

package/src/config/gate-coverage.yml

@@ -42,16 +42,64 @@
 #
 # COVERAGE — THE HONEST DENOMINATOR (re-measured 2026-08-18)
 # ----------------------------------------------------------
-# 267 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
-# (the count is computed, not asserted — `check_gate_coverage.count_gate_scripts`).
-# **42 of them emit the machine-readable `scanned: <N>` line under their
-# CI-identical argv, and 41 of those 42 are listed below.** The manifest is
+# 272 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
+# (the count is computed, not asserted — `check_gate_coverage.count_gate_scripts`,
+# re-run 2026-08-22 and it returns 272).
+# **47 of them emit the machine-readable `scanned: <N>` line under their
+# CI-identical argv, and 44 of those 47 are listed below.** The manifest is
 # therefore complete with respect to its own contract for every gate that can
-# carry a floor, and covers ~15 % of the population.
+# carry a floor, and covers ~17 % of the population.
 #
-# The one emitter deliberately NOT listed is `lint_evidence_artifacts`, for the
-# same reason `check_rule_projection_integrity` is not (see the paragraph
-# below): it is diff-scoped, so it legitimately emits `scanned: 0` on any
+# RECOUNTED on 2026-08-22, and it was wrong on every figure before the recount —
+# which is the fourth time, and the reason this paragraph keeps asking to be
+# computed. `check_no_stub_inventory_table` added ONE row and ONE script, but the
+# readings moved by more than one in three of the four places: population
+# 269 -> 272 (two scripts had landed since 2026-08-21 without touching this
+# prose), listed rows 42 -> 44 (the file already held 43 before this change; the
+# prose had again been adjusted instead of recounted, and the paragraph below
+# says so about its own previous revision), emitters 45 -> 47. Every number here
+# is reproducible: `grep -c '^  - id:' src/config/gate-coverage.yml` for the rows
+# and `count_gate_scripts()` for the population.
+#
+# Both halves were RE-DERIVED on 2026-08-21, not incremented, and the previous
+# reading was off by one in a way worth recording: it said "42 … and 41 of those
+# 42 are listed" while the file carried 42 rows AND named one deliberately
+# unlisted emitter (`lint_evidence_artifacts`, below). Those three facts cannot
+# all hold — 42 listed rows plus 1 unlisted emitter is 43 emitters, not 42. It
+# is the same drift this section documents three times: an entry was added and
+# the prose was adjusted by one instead of recounted.
+#
+# The derivation now, so the next reader can check it rather than trust it:
+# `grep -c '^  - id:'` returns 44 (computable, and computed); every listed row
+# is an emitter, because a row that did not emit could carry no floor and the
+# guard would report it `failing`; THREE emitters are deliberately unlisted —
+# `lint_evidence_artifacts` (below), `adr_cite_check` and
+# `check_new_adr_evidence` (each in the block where its row would have sat);
+# 44 + 3 = 47. The population figure comes from the function, and
+# `check_new_adr_evidence` matches the population prefix whether or not it
+# carries a row here.
+#
+# `adr/evidence_census` emits a `scanned:` line too and is NOT in either number:
+# it carries no `lint|check|audit` prefix, so `count_gate_scripts()` never sees
+# it. Named because the omission looks like a fourth miscount and is not one —
+# an emitter outside the population cannot be an unlisted emitter within it.
+#
+# Corrected in completion review, and it is the third time this paragraph has
+# been off by one — which is the argument for computing it rather than
+# adjusting it. The previous reading said 43 listed and self-invited a `grep`
+# that returns 42, so the check it offered refuted the sentence containing it.
+# The cause each time is the same: a row was added or removed and the prose
+# was incremented instead of recounted.
+#
+# A shape-grep over `src/scripts/` (`reportScanned(` or a literal `scanned: ${`)
+# returns 63 files. That is a DIFFERENT population — any file carrying an emit
+# shape, including gates that emit only in a non-CI mode — so it is not a
+# recount of this sentence and must not be substituted for one.
+#
+# Three emitters are deliberately NOT listed, all for one reason. The first is
+# `lint_evidence_artifacts`, for the same reason `check_rule_projection_integrity`
+# is not (see the paragraph below): it is diff-scoped, so it legitimately emits
+# `scanned: 0` on any
 # branch that adds no evidence artifact, and `min_scanned: 0` is the
 # false-count shape this file rejects. Its ledger half IS discharged — it
 # adopts `_lib/gate_ledger.ts` and `_lib/scan_scope.ts`, so
@@ -169,11 +217,93 @@
 # 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: check_pack_size
+    argv: []
+    min_scanned: 2000
+    corpus: "the `npm pack --dry-run --ignore-scripts` payload — every file package.json `files[]` resolves (2,954 in a built worktree and 2,686 in an unbuilt one on 2026-08-22, which is why the floor sits well under both)"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: src/scripts/zz-canary-shipped-credential.pem
+      content: |
+        zz canary probe: not a key, and deliberately not shaped like one.
+        The credential-shaped class matches on the PATH (`\.pem$`), never on the
+        body, so the plant needs no key-shaped content to red the class - and a
+        PEM header here would be a high-confidence check_secret_leak finding in
+        this tracked file. Measured, not guessed: the first draft carried a
+        BEGIN PRIVATE KEY block and reddened the secret gate at
+        gate-coverage.yml:229 in both `diff` and the new `pack` mode. A canary
+        that breaks a sibling gate to prove its own is not a canary.
+    note: >
+      ONE canary, and the entry shape is why. `canary:` is a single recipe per
+      gate id, not a list, while this gate carries FOUR content classes — so
+      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
+      the `files[]` negations that fixed it, so a plant never ships and never
+      reds, and `source-map` needs 121 files in a BUILT tree.
+
+      The credential class is the one that gets the recipe. It is empty today,
+      and an empty class with no check is indistinguishable from a class nobody
+      looked at — so it is the class where "has this ever been red" is a real
+      question. The plant sits under `src/scripts/`, which IS a `files[]` root;
+      an earlier attempt under `src/skills/` was silently absent from the
+      payload because that path is not shipped, and a canary that cannot reach
+      the corpus proves nothing.
+
+      Floor is a count, not a size. The size arm has a budget file; the count
+      arm is what stops an empty payload — a botched `files[]`, a pack that
+      resolved nothing — from measuring 0 MB and passing every budget. The gate
+      already exits 2 rather than 0 on that, via `assertScanned`.
+
+  - id: check_secret_leak
+    argv: ["--pack"]
+    min_scanned: 2000
+    corpus: "the npm pack payload — every file package.json `files[]` resolves, INCLUDING shipped-but-gitignored paths no git-backed mode can reach (2,684 in an unbuilt worktree on 2026-08-22)"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: dist/zz-canary-shipped-and-gitignored.pem
+      content: |
+        -----BEGIN RSA PRIVATE KEY-----
+        MIIEowIBAAKCAQEAzz-canary-not-a-real-key-zz
+        -----END RSA PRIVATE KEY-----
+    note: >
+      Registered on the `--pack` argv specifically, and the canary path is the
+      whole point: `dist/` is a `files[]` root while `/dist/*` is
+      `.gitignore:206`, so this plant is shipped and untracked at the same time.
+      `git check-ignore -q` matches it and `npm pack` includes it. A canary in a
+      tracked file would pass under the pre-existing `diff` and `all` modes too
+      and would prove nothing about the scope this entry exists for.
+
+      Measured, not assumed: with the plant in place `--pack` exits 1 and names
+      the path, while the default `diff` mode exits 0. The plant carries a real
+      PEM shape because THIS gate matches on CONTENT — unlike its sibling
+      `check_pack_size`, whose credential class matches on the path and whose
+      canary therefore deliberately carries no key-shaped body.
+
+      Two reasons the scope was blind, and adding the mode only fixed the first.
+      Mode enumeration walks the git tree; the `DEFAULT_EXCLUDE` list ALSO drops
+      all of `dist/`, regardless of mode. Until that exclusion became
+      mode-aware, the new scope resolved the payload and then filtered away
+      exactly the paths it was built to reach — the mode was measurably inert.
+
+  - id: check_publish_surface
+    argv: []
+    min_scanned: 2000
+    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.
+
   - id: check_gate_completeness
     argv: []
     min_scanned: 180
     corpus: "gates reachable from the `ci` / `consistency` task roots (220 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      whole-graph: it parses every gate invocation in the task roots at once, so a planted file has no property to violate — the defect it detects is a MISSING edge, which cannot be planted.
     note: >
       Floor set below the live count on purpose: the registered set legitimately
       shrinks when a gate is retired, and a floor pinned at today's exact number
@@ -182,11 +312,37 @@ gates:
       the Taskfile parse degrades and the population silently collapses —
       cannot pass.
 
+  - id: check_rule_layer_partition
+    argv: []
+    min_scanned: 0
+    corpus: "the five project rule directories that receive a projected tree (.claude/rules, .cursor/rules, .clinerules, .windsurf/rules, .augment/rules)"
+    status: enforced
+    no_canary_reason: >-
+      cross-tree: the violation is one rule appearing in two projected trees, so it needs both trees, not a file.
+    note: >
+      `min_scanned: 0` is the honest floor and not the false-count shape this file
+      rejects elsewhere. This gate compares a project rule directory against its
+      host's GLOBAL layer, and on a fresh CI checkout neither side exists — the
+      project trees are gitignored and no CI leg installs at user scope. So the
+      population is legitimately zero there, exactly as it is for the diff-scoped
+      gates the header paragraph carves out.
+      What keeps a zero from reading as a pass is inside the gate rather than in
+      this floor: with nothing compared it prints "nothing compared — N skipped.
+      This is not a pass" instead of a success line, and every skip names the host
+      and the unreadable path. Teeth land on a working checkout, where `task
+      preflight` runs it against real global layers.
+      It never reports a duplicate for a host whose global layer cannot be read: a
+      project copy is the only carrier when the global one is absent, so demanding
+      its removal on unread evidence would delete the rule from that host —
+      the failure `partitionEligibility`'s fail-safe ordering exists to prevent.
+
   - id: check_rule_activation_census
     argv: []
     min_scanned: 100
     corpus: "rule files under src/rules/ (117 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      whole-corpus census: it reports an aggregate over every rule; a single planted rule moves a number rather than producing a red.
     note: >
       Floor set below the live count so a legitimate rule retirement does not red
       the gate that watches activation. It is still far above a collapse: if the
@@ -280,22 +436,95 @@ gates:
     min_scanned: 8
     corpus: "declared human-authored suppression surfaces (10 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      cross-file: a suppression is a violation only against the declared surface that authorises it, so the pair is the unit.
     note: >
       The denominator is the INVENTORY, not the entry count — the gate's job is
       that every suppression surface is accounted for, and a surface list that
       collapsed to nothing must not read as "no suppressions to check".
 
+  - id: lint_adr_sweep_routing
+    argv: []
+    min_scanned: 20
+    corpus: "candidate rows (REVIEW-NOW / SUPERSEDE (candidate)) across docs/decisions/adr-evidence-sweep-*.md (26 at baseline, in one artifact)"
+    status: enforced
+    canary:
+      class: unrouted-candidate
+      path: docs/decisions/adr-evidence-sweep-zz-canary-probe.md
+      content: |
+        # ADR evidence sweep — canary probe
+
+        | Record | Disposition | Why |
+        |---|---|---|
+        | ADR-9999 | REVIEW-NOW | canary probe row |
+
+        ## Candidate routing
+
+        | Record | Disposition | Route | Dated follow-up |
+        |---|---|---|---|
+        | ADR-9999 | REVIEW-NOW | council | when we get to it |
+    note: >
+      The floor is 20 rather than 26 because a candidate LEAVING the population
+      is the point of the sweep: every disposition that lands takes its row out
+      of the count, so a tight floor would red on the gate working. It is far
+      above a collapse — a scan that stopped seeing the artifact reports 0.
+
+  - id: check_requirements_trace
+    argv: []
+    min_scanned: 15
+    corpus: "roadmap files at the top level of agents/roadmaps/ (25 at registration, 2026-08-22)"
+    status: enforced
+    no_canary_reason: >-
+      this gate is a LISTING, not an enforcement: `main()` returns 0 on every
+      path and `process.exit(main())` is its only exit, so no planted file can
+      make it red and the harness's "caught the planted defect (exit 1)"
+      observation is unreachable by construction. Verified, not assumed — a probe
+      roadmap carrying an unresolved acceptance-criteria ref left the exit code at
+      0. It is registered for its `scanned:` floor, which is the one thing about
+      it that CAN break, and that floor is the negative control here.
+    note: >
+      A LISTING gate: it exits 0 always, including on a dangling `[AC:]` ref and
+      on an empty corpus. Registered here for its `scanned:` floor rather than
+      for a pass/fail verdict — the floor is the only thing about it that can
+      break, and a scan that stops seeing agents/roadmaps/ would otherwise
+      report an empty inventory as a clean one. Floor 15 against 25 at
+      registration: the active estate is being drained deliberately and is
+      expected to shrink, so a tight floor would red on the drain working.
+
+  - id: check_council_pin_staleness
+    argv: []
+    min_scanned: 3
+    corpus: "council members carrying a `model:` in agents/templates/.ai-council.yml.example (5 at registration, 2026-08-22)"
+    status: enforced
+    no_canary_reason: >-
+      the harness is create-only and this gate reads ONE fixed path
+      (agents/templates/.ai-council.yml.example), so no planted file lands inside
+      its scan scope — making it red means EDITING that template, which the
+      harness does not do. Discrimination is proven by the gate's own
+      `--self-test` instead: 10 cases across the fresh, stale, future-date,
+      malformed, unstamped and vendor-sentinel branches.
+    note: >
+      Floor 3 against 5 at registration: the template's member list is a shipped
+      artifact rather than a draining corpus, but an exact floor would red on a
+      legitimate trim of one member. Collapse is covered more strictly from the
+      other side — `reportScanned` raises DeadScopeError at 0 members, before
+      this floor is consulted at all.
+
   - id: lint_trigger_collisions
     argv: []
     min_scanned: 90
     corpus: "src/rules/*.md frontmatters (111 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      pairwise: a collision needs two rules, and which two is the finding — a single planted file collides with nothing.
 
   - id: lint_rule_skill_pack_reach
     argv: ["--quiet"]
     min_scanned: 90
     corpus: "src/rules/*.md frontmatters joined against src/skills packs and the pack registry (116 rules at baseline)"
     status: enforced
+    no_canary_reason: >-
+      join: rule frontmatter against the skills tree and the pack registry; a planted rule needs a matching planted pack graph to be judged.
     note: >
       Advisory on findings, enforced on COVERAGE: the gate exits 0 while its
       unreachable-route set is non-empty (12 at introduction), so only this
@@ -308,6 +537,8 @@ gates:
     min_scanned: 380
     corpus: "src/ ↔ dist/agent-src/ .md pairs (429 at baseline: 111 rules + 318 skills)"
     status: enforced
+    no_canary_reason: >-
+      byte-equality between src/ and dist/agent-src/ pairs — the property is a relation between two trees, not a file.
 
   - id: check_augment_description_cap
     argv: []
@@ -418,6 +649,8 @@ gates:
     min_scanned: 340
     corpus: "CI + local gate invocations parsed from .github/workflows + taskfiles (360 measured 2026-08-13: 109 CI + 251 local)"
     status: enforced
+    no_canary_reason: >-
+      whole-graph: it parses every workflow and taskfile invocation and reports gates present in one set and absent from the other.
     note: >
       Registered 2026-08-02. It already emitted the contract line on every path,
       including the failing one — it was simply never listed, the same omission
@@ -465,6 +698,8 @@ gates:
     unavailable_exit: 2
     corpus: "built HTML pages under site/dist (25 content sources at baseline)"
     status: enforced
+    no_canary_reason: >-
+      needs the BUILT site under site/dist, which does not exist until a build runs; already reported `unavailable` when absent.
     note: >
       Registered 2026-07-30 after it was caught reporting green over a stale build —
       6 pages against 25 content sources, every source newer than the newest page.
@@ -494,6 +729,8 @@ gates:
     min_scanned: 1200
     corpus: "all .md under src/ + dist/agent-src/ plus the shipped root files (1,566 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      a planted file would be judged, but the gate is a broad scan whose baseline is the corpus size — a single red proves the matcher fires, which its own fixtures already do.
     note: >
       SCAN_DIRS named the retired authoring root, so the entire src/ tree —
       more than half the corpus — was skipped and an identifier authored there
@@ -504,6 +741,8 @@ gates:
     min_scanned: 800
     corpus: ".md under the scanned roots plus memory YAML (1,043 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      a planted broken reference is judged, but every target must exist in the real tree for the resolver to be faithful; an isolated fixture makes every reference broken.
     note: >
       src/ was absent from every reference-resolution candidate list, so a link
       resolvable only under the source of truth was reported BROKEN. The
@@ -515,6 +754,8 @@ gates:
     min_scanned: 400
     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.
     note: >
       A collapse below the floor would mean the gate stopped reading the tree
       that states extraction thresholds, so a bare or diverging threshold
@@ -525,6 +766,8 @@ gates:
     min_scanned: 5
     corpus: "src/agent-src/profiles/*.yml (6 seed profiles at baseline)"
     status: enforced
+    no_canary_reason: >-
+      join: a profile is judged against the persona set it names, so both sides are needed.
     note: >
       Fewer than 5 profiles scanned would mean the gate stopped reading the
       seed-profile dir, so a defaults.personas id that resolves to no persona
@@ -535,6 +778,8 @@ gates:
     min_scanned: 200
     corpus: "src/skills/*/SKILL.md (288 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      ratio gate: the 15% rich-skill cap is a property of the corpus, so one planted skill cannot cross it.
     note: >
       A collapse below the floor would mean the gate stopped reading the skills
       tree, so a rich-tagged skill without its justification section (or a cap
@@ -545,6 +790,8 @@ gates:
     min_scanned: 350
     corpus: "skills / rules / commands .md actually judged (368 of 438 enumerated; the rest carry a declared exemption the ledger names)"
     status: enforced
+    no_canary_reason: >-
+      the allowlist is line-keyed against real files, so a planted file has no allowlist anchor and the exemption path goes untested.
     note: >
       Its human summary prints "N hits across M files", where M is files WITH
       HITS — 0 on a clean run. Reading that as coverage is precisely how a
@@ -555,14 +802,64 @@ gates:
 
   - id: lint_plan_risk_register
     argv: []
-    min_scanned: 12
-    corpus: "ready roadmap files under agents/roadmaps/ top level (19 at baseline: 14 grandfathered + 4 draft-exempt + 1 carrying a live register)"
+    min_scanned: 1
+    corpus: "ready roadmap files under agents/roadmaps/ top level (6 as of 2026-08-21; 19 at the original baseline: 14 grandfathered + 4 draft-exempt + 1 carrying a live register)"
     status: enforced
+    no_canary_reason: >-
+      a planted roadmap is judged, but the gate reads the ready-roadmap population to decide scope; an isolated file changes what it scans.
     note: >
       Gate R1 (docs/contracts/plan-review-gates.md § 1). The count is READY
       FILES INSPECTED incl. grandfathered/draft-exempt ones — exemptions are
-      reported, never silently skipped, so a collapse below the floor means
-      the roadmaps root moved, not that the corpus went clean.
+      reported, never silently skipped.
+
+      Lowered 12 → 5 on 2026-08-21, and the SHAPE of the change matters more
+      than the number. The previous note asserted that "a collapse below the
+      floor means the roadmaps root moved, not that the corpus went clean."
+      That premise is falsified: archiving roadmaps at zero open and zero
+      deferred steps dropped the top-level count from 12 to 10 with the root
+      untouched — the corpus really did go cleaner, which is what
+      road-to-estate-drawdown exists to achieve. A floor pinned to the exact
+      corpus size fails on the drawdown succeeding, which is the wrong thing
+      to detect.
+
+      So the replacement is deliberately NOT today's count. Re-pinning at 10
+      would repeat the defect one archival later and force this note to be
+      rewritten every time a roadmap closes. 5 sits structurally below any
+      plausible active set while still catching the two failures this floor is
+      for: the roadmaps root moving, and the scanner silently reading nothing.
+      It is not a target for how many roadmaps ought to exist.
+
+      Count reconciliation, since two numbers move in this change and they
+      count different populations: this gate counts READY files at the top
+      level of agents/roadmaps/ (12 → 10 here), while
+      estate-count-budget.json::active_roadmaps counts NON-DRAFT candidates as
+      collect() sees them (11 → 10). The gap is the draft-status file each
+      population treats differently; neither number is derivable from the
+      other.
+
+      Revisit-if the active set is deliberately grown past ~15, at which point
+      5 is uninformatively low, or if a drop is ever traced to a scanner
+      defect rather than to archival — either falsifies the number, not the
+      obligation.
+
+      Lowered again 10 → 5 on 2026-08-21, during the PR drain that produced the
+      paragraph above. 10 was measured against 12 and the drain had already
+      taken the corpus to 11 — one file of headroom, so the next archival would
+      have reddened CI for the exact reason this entry says is the wrong thing to
+      detect. 5 keeps the root-moved / scanner-blind signal (both scan 0) and
+      stops the number from needing a commit per archived roadmap.
+
+      Lowered again 5 → 1, and this time the SHAPE changed rather than the
+      number. 5 was picked to have headroom and did not: the drain took the
+      corpus to 6, so a review provoked the red by archiving one roadmap. The
+      lesson is that no absolute floor survives here — this gate's sibling
+      `check_estate_count` forbids growth, so the corpus can only shrink and any
+      floor above 0 is met eventually. 1 is the smallest value that still
+      distinguishes "the scanner read something" from "the root moved or the
+      scope is dead", which is the only thing this field was ever asked to
+      detect. Revisit-if the gate gains a way to express "non-empty" directly,
+      or if a drop to 0 is ever traced to a scanner defect rather than to an
+      empty corpus.
 
   - id: check_estate_count
     argv: []
@@ -597,6 +894,8 @@ gates:
     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)"
     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
@@ -624,6 +923,8 @@ gates:
     min_scanned: 7
     corpus: "archived round records — `*-review.md` under agents/evidence/reviews/, excluding live `*.findings.md` (9 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      git-dependent in effect: it reads archived round records whose identity comes from the committed tree, and its own scan-scope guard fails on an empty corpus.
     note: >
       Contract § 2.7. Unlike the R2 entry above, this floor is genuinely
       trippable: the corpus is 9 frozen records and archived records are not
@@ -653,6 +954,8 @@ gates:
     min_scanned: 250
     corpus: "src/skills/*/SKILL.md (288 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      join: a handoff is a link from one skill to another, so the target skill must exist to judge the link.
     note: >
       The argv here is load-bearing, not decoration. Taskfile injects `--quiet`
       (QUIET_FLAG) and this gate read `args[0]` as a positional path, so the CI
@@ -667,6 +970,8 @@ gates:
     min_scanned: 540
     corpus: "names across src/rules + src/skills + src/agent-src + src/domains/**/command.md (621 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      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.
@@ -676,12 +981,16 @@ gates:
     min_scanned: 540
     corpus: "artefacts 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.
 
   - id: audit_skill_overlap
     argv: ["--quiet", "--print-table", "--strict"]
     min_scanned: 250
     corpus: "src/skills/*/SKILL.md compared pairwise (288 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      pairwise over 288 skills; overlap needs a corpus, and which pair is the finding.
     note: >
       `--strict` is part of the CI invocation and can exit non-zero on a real
       overlap finding. The guard reads the count independently of the exit code —
@@ -692,15 +1001,31 @@ gates:
     min_scanned: 90
     corpus: "src/rules/*.md (111 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      a planted rule IS judgeable — this entry is a genuine authoring gap rather than a structural one, and is the first candidate if the mode is ever built.
     note: >
       Emits on stderr, not stdout: `--format json` owns this gate's stdout and a
       count written there would corrupt the payload. The guard reads both streams.
+      Corpus boundary, decided 2026-08-20 (council, `leave-unscanned`): `src/skills`
+      is deliberately OUT of this gate's corpus. Pointed at it the gate reports 13
+      findings (11 `buried_iron_law`, 2 `deep_iron_law`) that nobody currently sees.
+      Extending the corpus was declined on three grounds — the gate has no warn
+      level, so a staged extension would mean adding a warning mode to an enforced
+      blocking gate; the reverted `lint_skill_top_position` attempt showed two gates
+      defining one construct incompatibly, and the disputed `deep_iron_law` class is
+      still live in those 13; and the premise for scanning skills at all
+      (post-compaction truncation keeps the file start) is unverified, the tree's one
+      measured truncation fact being ENTRY-level. Re-opening this needs a measured
+      reason plus the reported-and-baselined ratchet, not a path added to `argv`.
+      See `agents/roadmaps/archive/road-to-context-fidelity.md` § Phase 3.
 
   - id: check_cli_registry_budget_sync
     argv: []
     min_scanned: 3
     corpus: "the three named inputs it cross-checks — src/cli/registry.ts, src/config/evaluator-budgets.json, internal/bench/reports/evaluator-measurements.json"
     status: enforced
+    no_canary_reason: >-
+      git-dependent cross-check of three named committed inputs; the property is their agreement, not any one file.
     note: >
       Registered because its count became REAL, not to pad the manifest. The
       gate always printed a hardcoded `scanned: 3`; hardening derived it from
@@ -714,6 +1039,8 @@ gates:
     min_scanned: 100
     corpus: "leaf keys in src/config/agent-settings.template.yml (140 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      the only possible violation is a MODIFICATION of two tracked files (a key added to the template, or a row removed from the contract) and the canary harness is create-only by design. Discrimination is proven by the gate's own `--self-test` instead — six rejecting cases including the dead-scan-root one.
     note: >
       Floor set well below the live 140 so retiring a settings key does not red
       the change that retires it, but high enough that the collapse this file
@@ -913,6 +1240,8 @@ gates:
     min_scanned: 1
     corpus: "rows of the `docs/MIGRATION.md` scheduled-deprecations table (3 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      discrimination is proven by the gate's own `--self-test` (10 cases, 6 rejecting) driving the real binary, which covers the due-at-the-cut case a create-only canary could not express.
     note: >
       `argv` carries `--quiet` because that is what the task passes: the
       Taskfile resolves `{{.QUIET_FLAG}}` to `--quiet` unless
@@ -942,6 +1271,8 @@ gates:
     min_scanned: 900
     corpus: "TypeScript sources — src/**/*.ts excluding *.d.ts and *.test.ts, the same two kinds _lib/gate_population excludes (1,063 at baseline)"
     status: enforced
+    no_canary_reason: >-
+      the canary contract is create-only and this gate's violation is a MODIFICATION — a file crossing its line ceiling. Discrimination is proven by the gate's own `--self-test`, including a boundary case and a dead scan root.
     # No `canary:` recipe, and the reason is the canary contract's own shape
     # rather than a gap. The violation this gate detects is a file OVER 1,500
     # lines, so a create-only recipe would have to inline 1,501 lines of content
@@ -955,3 +1286,118 @@ gates:
     # an already-listed file that GREW while the file COUNT stayed at one. That
     # last case is what pins the metric as excess lines rather than a file count;
     # a count-based ratchet passes it, and this gate must not.
+
+  - id: check_no_stub_inventory_table
+    argv: ["--quiet"]
+    min_scanned: 1
+    corpus: "the guarded watch list — agents/roadmaps/stubs/README.md (1 file; the whole scope, not a sample)"
+    status: enforced
+    no_canary_reason: >-
+      the guarded path already EXISTS, so a create-only canary cannot plant the violation. Discrimination is proven by the gate's own `--self-test`.
+    # No `canary:` recipe: the guarded path already EXISTS, and the canary
+    # contract is create-only. A recipe would have to mutate a tracked file
+    # rather than plant one, which the contract does not express. The gate
+    # reports UNPROVEN there rather than green, which is the honest state.
+    #
+    # Discrimination is proven by the gate's own `--self-test` instead, and the
+    # five cases are the sabotage probes it was verified with before landing:
+    # a restored transfer table, the inventory header alone, a DEAD watch list
+    # (the `check_safety_floor_untouched` shape — it must red, never report
+    # clean), plus two accepting cases that pin the narrowness review asked for
+    # — a glossary table and a table citing parent roadmaps one directory up
+    # must both pass. A blanket ban on markdown tables in the file would trade
+    # one regression for a permanent block on legitimate documentation.
+    #
+    # `min_scanned: 1` is the true corpus, not a weak floor: the scope is one
+    # known file. The collapse this file's rule 3 guards against is covered by
+    # `assertWatchlistResolves`, which refuses to report clean when the path
+    # does not resolve — so a rename reds the gate instead of retiring it.
+
+  # check_new_adr_evidence is DELIBERATELY NOT REGISTERED here, following this
+  # file's own two precedents rather than breaking them.
+  #
+  # It is diff-scoped: its corpus is the set of decision records ADDED on the
+  # branch (`git diff --diff-filter=A` over `docs/decisions/ADR-*.md` and
+  # `docs/adrs/<area>/NNNN-*.md`), so ZERO is the honest reading on almost every
+  # run and any floor above 0 reds every branch that adds no ADR. A
+  # `min_scanned: 0` row is the false-count shape this file's header rejects in
+  # as many words, and `lint_evidence_artifacts` and
+  # `check_rule_projection_integrity` both hit this exact wall and resolved it by
+  # staying unregistered. A row was written first and then withdrawn: the
+  # argument for it was that a registered gate at least runs under CI-identical
+  # argv, and that is real but it is not worth being the one instance that
+  # introduces the shape two neighbours were excluded to avoid. Three precedents
+  # agreeing is a convention; two agreeing and one defecting is drift.
+  #
+  # It is NOT unwatched. `task check-new-adr-evidence` and the
+  # `New accepted ADRs disclose their evidence` step in rule-backstops.yml both
+  # run it, so a broken gate fails there.
+  #
+  # And it is NOT unproven, which is the part a floor could never have supplied.
+  # This gate's normal reading is zero added records — precisely the state where
+  # a working gate and a completely broken one emit identical output
+  # (`scanned: 0`, green), so no floor separates them at any value. `--self-test`
+  # does: seven cases, four rejecting, each building a throwaway repo and driving
+  # the real CLI with `--base <sha>`, including the case an `authority_basis:
+  # owner_intent` escape must NOT buy (that field governs authority, never
+  # disclosure). Sabotage-verified — with the `## Evidence` check removed the
+  # self-test exits 1 and names the two cases that stopped firing.
+  #
+  # What is LOST, stated rather than implied: no minimum scan is held against
+  # this gate by this manifest, so a change that silently narrowed its path
+  # regexes to nothing would pass here. The self-test is what catches that, and
+  # it is a test rather than a manifest floor — it runs when someone runs it.
+
+  # adr/evidence_census is DELIBERATELY NOT REGISTERED here either, for the
+  # same structural reason and with a different cost.
+  #
+  # `matchesGatePattern` classifies on a name PREFIX
+  # (`lint|check|audit|skill|verify_`) and `evidence_census.ts` carries neither,
+  # so a row here would red `gate_population.test.ts` exactly as the
+  # `adr_cite_check` row did. The block below weighs the three fixes for that
+  # case and they apply unchanged: widening the pattern, renaming the script, or
+  # inverting the classification to be manifest-driven.
+  #
+  # What is DIFFERENT, and better than the adr_cite_check case: the census is not
+  # unwatched. `task check-adr-evidence-census` regenerates it to a temp path and
+  # diffs against the committed artifact, wired in the `ci` chain and as the
+  # `ADR evidence census up to date` step in rule-backstops.yml, so a corpus that
+  # drifted from the artifact fails there instead of here. The census emits a
+  # `scanned:` line and adopts the ledger, so what is lost is only the MINIMUM
+  # SCAN FLOOR — a change that narrowed its corpus to zero AND regenerated the
+  # artifact to match would pass both. Stated rather than implied, because the
+  # drift check is a byte-comparison and byte-agreement on an empty corpus is
+  # still agreement. Closing it properly is the same rename, in the same change
+  # that renames adr_cite_check.
+
+  # adr_cite_check is DELIBERATELY NOT REGISTERED here, and the reason is a
+  # disagreement between two gates over the same file rather than an oversight.
+  #
+  # The script is gate-shaped by behaviour: it emits one `scanned:` line, adopts
+  # the ledger, asserts its scan scope, and runs in CI as `ADR citations resolve`
+  # (rule-backstops.yml) plus `task check-adr-citations`. So it certifies
+  # something and can lie about it, which is this manifest's own criterion.
+  #
+  # But `gate_population.matchesGatePattern` classifies structurally, on a NAME
+  # PREFIX (`lint|check|audit|skill|verify_`), and `adr_cite_check.ts` carries
+  # `check` as a suffix. Registering it made `gate_population.test.ts` red:
+  # "manifest lists adr_cite_check, population does not". The two gates read the
+  # same file and disagree.
+  #
+  # Three fixes were weighed and each was worse than the gap:
+  #   - widening the pattern to a `_check$` suffix pulls in four unrelated
+  #     scripts (bench_drift_check, worktree_cleanup_check, update_check,
+  #     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
+  #     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
+  #     registers it, so that inverts the real dependency).
+  #
+  # So the row is dropped and the floor is unregistered. What is LOST is stated
+  # rather than implied: the gate runs, but nothing holds it to a minimum scan,
+  # so a future change that silently narrowed its corpus to zero would pass. The
+  # honest close is the rename, in its own change, where 26 files of churn are
+  # the subject rather than a side effect.