@event4u/agent-config 9.22.0 → 9.23.0

package/docs/guidelines/agent-infra/false-green.md

@@ -0,0 +1,187 @@
+# False Green — the ways a passing result can be wrong here
+
+> Nine failure modes, each with the detection command that distinguishes "found nothing" from "looked at nothing". Every one is drawn from this repository's own history, not from a generic checklist.
+
+_Origin: `road-to-skill-ecosystem-gate-integrity` Phase 3. The recurring shape is not that a gate reports a wrong finding — it is that a gate reports **no** finding for a reason unrelated to the property it guards, and no output distinguishes the two cases._
+
+## The catalogue
+
+### 1. Dead scan root
+
+The gate walks a directory that moved or was deleted. Zero units, zero findings,
+exit 0, green checkmark. Fourteen gates in this tree were in this state
+simultaneously after a container move; their own output said `0 file(s) scanned`
+and nothing asserted on the number.
+
+```bash
+./scripts-run src/scripts/<gate> | grep -E '^scanned: '   # 0, or absent entirely
+./scripts-run src/scripts/sweep_dead_scan_roots
+```
+
+**Structural fix:** `assertScanned` from `_lib/scan_scope.ts`. A gate that read
+nothing has not passed.
+
+### 2. Planned-but-never-judged targets
+
+The root is alive and the corpus is real, but the loop `continue`s past most of
+it on unwritten conditions. The published count says "enumerated", the reader
+hears "checked". `lint_framework_leakage` published 438 while judging 368.
+
+```bash
+./scripts-run src/scripts/<gate> | grep 'ledger:'   # scanned=N planned=M — compare N and M
+```
+
+**Structural fix:** `_lib/gate_ledger.ts`. Every planned target reaches exactly
+one terminal outcome, and the skip codes are counted per reason.
+
+### 3. Allowlist growth
+
+The gate is honest, the corpus is real, and the finding was suppressed. Count-
+based ratchets cannot see swap-one-out-add-one-in: remove a real entry, add a
+fresh suppression, the number is identical and the estate moved backwards.
+
+```bash
+./scripts-run src/scripts/check_suppression_hygiene     # entry SETS vs the base ref
+git diff origin/main -- 'src/scripts/*allowlist*.json' 'src/config/*baselines*.json'
+```
+
+**Structural fix:** `_lib/ratchet_base_ref.ts` — compare entry sets against
+`git show <baseRef>:<path>`, the one reading of the baseline the change under
+review cannot rewrite.
+
+### 4. Ratchet-entry deletion
+
+Subtler than growth: deleting a baseline entry whose `count` is 0 is **weaker**
+than leaving it, because the absence of an entry means "unbaselined" and an
+unbaselined gate's `ok` flips to `actual === 0` with no recorded intent. Harden
+first, then delete, and pin the absence.
+
+```bash
+git diff origin/main -- src/config/gate-violation-baselines.json | grep '^-'
+```
+
+### 5. Threshold re-anchoring
+
+The gate still runs, the corpus is real, and the bar moved. A lowered floor and
+a genuine improvement look identical in the exit code.
+
+```bash
+git diff origin/main -- src/config/gate-coverage.yml | grep -E '^[-+].*min_scanned'
+git diff origin/main -- 'src/config/*budget*.json'
+```
+
+**Discriminator:** a legitimate ratchet lowers *severity* while keeping *reach*;
+threshold-lowering reduces reach. Ask which one the diff does.
+
+### 6. Suppression sweep
+
+Not one entry — twenty. Allowlist growth past ~20 entries in a session is the
+signal that the linter (or the content) is wrong, not that the list is short by
+twenty. The tool-call guard blocks past that count; the honest response is to
+fix the gate's shape.
+
+```bash
+./scripts-run src/scripts/check_suppression_hygiene | grep 'entry(ies)'
+```
+
+### 7. Crashed gate read as passing gate
+
+A gate that throws is not a gate that passed, but an aggregator that only
+inspects exit codes cannot tell an exception from a clean run when the harness
+swallows it. Three of this repository's recorded traps are estate invalidation
+misreported as a per-gate red, or the reverse.
+
+```bash
+./scripts-run src/scripts/<gate>; echo "EXIT=$?"     # capture BEFORE any $( )
+```
+
+**Structural fix:** capture `EXIT=$?` on the line immediately after the command,
+never after a command substitution; and fail closed when a registered gate
+reports a null or missing verdict.
+
+### 8. A derived page reporting an unmeasured dimension
+
+The generator has no data for a category and renders a `0`, or worse a computed
+share, which reads as a measurement. The always-budget report printed `60.1%`
+for a dimension it counted **zero** artefacts in.
+
+```bash
+./scripts-run src/scripts/check_derived_page_truthfulness   # where present
+grep -rn '0%\|0 of 0' docs/*.md
+```
+
+**Structural fix:** an unmeasured category renders as absent or explicitly
+"not measured" — never as a zero and never as a share.
+
+### 9. Equality without validity
+
+Two things are compared and found equal — because neither exists. `diff a b`
+over two absent files returns equal; two empty lists both serialize to `[]`; an
+empty rendered template equals an absent target file. The gate reports
+"in sync" having compared nothing.
+
+```bash
+./scripts-run src/scripts/<gate>            # then delete ONE side and re-run
+```
+
+**Structural fix:** assert both sides exist and are well-formed BEFORE
+comparing. Two absences are the absence of a comparison, not the presence of a
+match. The estate-wide audit is below.
+
+## The audited sync/parity gates
+
+Comparison-shaped gates carry entry #9's failure mode by default: `diff a b`
+where neither side exists returns **equal**. Audited 2026-08-05 across
+`src/scripts/` — **27 comparison gates, 19 guarded, 8 vulnerable, 0 undecided.**
+
+A gate is GUARDED when it asserts both sides exist and are well-formed *before*
+comparing — in this tree, almost always via `assertScanned` /
+`assertWatchlistResolves` from `_lib/scan_scope.ts`.
+
+### Guarded (19)
+
+`check_release_surface_equality` · `check_trunk_drift` · `lint_glama_drift` ·
+`check_ci_strict_superset` · `check_condensation` · `check_artefact_checksums` ·
+`check_bridge_derivation` · `check_discovery_determinism` ·
+`check_cli_registry_budget_sync` · `check_template_pin_drift` ·
+`check_gitignore_freshness` · `check_token_optimizer_freshness` ·
+`lint_eval_freshness` · `lint_behavioural_eval_freshness` ·
+`check_release_trunk_sync` · `sync_gitattributes` · `sync_gitignore` ·
+`iron_law_sha` · `check_test_coverage_diff`
+
+Two carry caveats worth knowing: `check_template_pin_drift` has an
+`--allow-empty` opt-in that is a deliberate empty-side pass, and
+`check_test_coverage_diff` is guarded but warn-only, so its guard is currently
+inert.
+
+### Vulnerable (8) — shrink-only from here
+
+| Gate | The both-absent / both-empty path |
+|---|---|
+| ~~`verify_physical_move`~~ | **FIXED in this change.** `_diff_manifest(null, null)` returned `[]`, and an empty issue list means clean. |
+| `check_ci_local_parity` | a missing workflow dir reads as `''` and a missing taskfile is skipped; two empty corpora ⇒ no delta ⇒ exit 0 |
+| `mcp_parity_smoke` | two empty lists both serialize to `[]`; prints "0 entries match" and returns 0 |
+| `probe_projection_fidelity` | a fixture that loses its `entries:` key yields 0 checks and `fail=0` |
+| `sync_agent_settings` | empty template + absent target ⇒ `'' === ''` ⇒ "already in sync" under `--check` |
+| `sync_github_metadata` | two empty topic lists ⇒ no drift ⇒ exit 0 **even under `--strict`** |
+| `check_kernel_prefix_stability` | deleting the committed snapshot returns `'warmup'` ⇒ exit 0 |
+| `bench_drift_check` | fewer than 2 reports ⇒ "no drift gate yet" ⇒ exit 0 |
+
+The seven open rows are recorded rather than swept: fixing release, sync, and
+bench gates in one change would be a large diff across surfaces this change does
+not otherwise touch, which is the unreviewable-batch failure the authoring
+guideline warns about. The fixed row shows the pattern — assert both sides
+exist, and treat two absences as the absence of a comparison.
+
+## The ease tripwire
+
+A verification that was **far easier than expected** is a signal to check the
+path, not a signal of success. Every entry above felt like a pass at the moment
+it happened. When a gate you expected to fight goes green on the first run, run
+one of the detection commands before believing it.
+
+## See also
+
+- [`gate-authoring.md`](gate-authoring.md) — the authoring path that prevents these at the source.
+- `docs/contracts/ci-green-floor.md` § CI delta — what a local pass does and does not cover.
+- `src/scripts/_lib/gate_ledger.ts`, `_lib/scan_scope.ts`, `_lib/ratchet_base_ref.ts` — the three structural fixes above.

package/docs/guidelines/agent-infra/gate-authoring.md

@@ -0,0 +1,177 @@
+# Gate Authoring — the single path for a new gate
+
+> Lifecycle, gaming-risk block, paired fixtures, ledger obligation, and finding format. Read this BEFORE writing a new `lint_*` / `check_*` / `audit_*` script.
+
+_Origin: `road-to-skill-ecosystem-gate-integrity` Phase 3. It exists because the estate re-learned the same lesson four times at four instances and never wrote the general rule down: a gate that scanned nothing exited green, a budget report printed a share for a dimension it never measured, release gates verified an empty corpus, shape gates ran over frozen corpora. Each was fixed where it was found. This is the authoring surface that stops the fifth._
+
+## The five obligations
+
+A new gate is not done until all five hold. They are ordered by how expensive
+they are to add later — the first two are nearly free at authoring time and
+nearly impossible to retrofit honestly.
+
+### 1. Account for the work — the ledger obligation
+
+Use `src/scripts/_lib/gate_ledger.ts`. Plan every target, then give each one
+exactly one terminal outcome: `complete`, `fail`, `skip(reason)`, or
+`outOfScope(reason)`. `finalize()` throws when a planned target reached none.
+
+```ts
+const ledger = new GateLedger('lint_example');
+ledger.plan(files.map(rel));
+for (const f of files) {
+    if (isGenerated(f)) { ledger.outOfScope(rel(f), 'generated_artifact'); continue; }
+    const finding = check(f);
+    if (finding) ledger.fail(rel(f), finding); else ledger.complete(rel(f));
+}
+ledger.report();   // prints `scanned=N planned=N skipped=N`, throws on unaccounted
+```
+
+Skip reasons come from the closed union in that module. An unlisted reason does
+not typecheck — deliberately, because "excluded dir" / "too big" / "binary?" in
+free prose is not aggregatable, and adding a genuinely new code should be a
+one-line diff a reviewer sees.
+
+A gate that genuinely has no per-target structure (a single scalar probe, a
+watch-list guard) carries `// ledger-exempt: <reason>` on its own line instead.
+`check_gate_completeness` ratchets the un-adopted count; it may only shrink.
+
+**This is not the scan-root guard.** Keep `assertScanned` /
+`assertWatchlistResolves` from `_lib/scan_scope.ts` as well. One covers the root,
+the other the items under it, and a gate wants both.
+
+### 2. Print the denominator on the green path
+
+Success output states what was inspected, not only that nothing was found.
+`ledger.report()` does this; if the gate also carries a floor in
+`src/config/gate-coverage.yml`, emit the machine-read `scanned: <N>` line via
+`reportScanned` or directly.
+
+Publish the number that was **judged**, not the number that was *enumerated*.
+`lint_framework_leakage` published 438 against 368 actually judged until the
+ledger made the honest number the cheap one to emit — a 19% over-report of its
+own coverage, invisible to every consumer of that line.
+
+### 3. Land advisory, promote on empty
+
+```
+A NEW GATE LANDS ADVISORY. ITS FINDINGS ARE CLASSIFIED ON THE REAL CORPUS.
+THE BASELINE SHRINKS TO EMPTY. ONLY THEN IS IT PROMOTED TO ERROR.
+```
+
+The failure this prevents is recorded: a shape gate wired straight to error over
+a frozen corpus produced 8 hits, all 8 unfixable, and could therefore only ever
+block. Running a new gate against the real corpus and classifying every hit
+BEFORE wiring it is the difference between a ratchet and a wall.
+
+Record the promotion condition in the gate's own header comment, in the form
+*"promote to error when `<baseline entry>` reaches 0"*, so the next reader knows
+whether advisory is a stage or a permanent hedge.
+
+Use `checkRatchet` from `_lib/gate_baseline.ts` with an entry in
+`src/config/gate-violation-baselines.json`; it returns a verdict rather than
+printing or exiting, so the gate stays in control of its own output.
+
+### 4. Name one degenerate pass — the gaming-risk block
+
+Every new gate or ratchet carries a `**Gaming risk**` paragraph in its header
+comment naming **at least one** concrete way the metric passes without the
+underlying property holding, plus the mitigation and — honestly — the residual.
+
+If one degenerate pass is nameable at authoring time, it will be found in
+practice. Worked examples from this very roadmap:
+
+| Gate | Degenerate pass | Mitigation | Residual |
+|---|---|---|---|
+| `check_gate_completeness` | sprinkle `// ledger-exempt:` markers with plausible boilerplate | minimum reason length; the marker lands in the diff | cannot judge whether a reason is *true* |
+| `check_suppression_hygiene` | a `falsifier` holding a command that always exits 0 | literal degenerate forms rejected; minimum length | cannot execute the command to prove it discriminates |
+| `_lib/gate_ledger` | mark every target `outOfScope` to reach a clean tally | the report prints skip counts per code beside the scanned count | a reviewer must still read the ratio |
+
+The residual column is the point. A gaming-risk block that claims full coverage
+is itself a false green.
+
+### 5. Ship a paired fixture
+
+A gate with no negative fixture cannot be shown to discriminate. Minimum set:
+
+- the **real repo tree** passes, and the denominator is asserted (not just the
+  exit code — a gate that scanned nothing also exits 0);
+- a **planted violation** fails, and the message names the offender;
+- the **boundary** case, where the gate declares one (exactly-at-cap, exactly-
+  at-minimum);
+- a **dead scan root** fails rather than passing green;
+- `--quiet` changes the output, not the verdict.
+
+Where the gate has a self-test mode (§ Second-order guards below), the
+assertion-count floor is itself asserted: a truncated fixture block must fail
+rather than print success.
+
+## Finding format — the suppression key is in the message
+
+A finding message carries its own suppression key inline, copy-pasteable:
+
+```
+❌  src/skills/example/SKILL.md:42  framework-leakage  /artisan/  …
+    suppress: {"file":"src/skills/example/SKILL.md","anchor":"php artisan migrate","reason":"<why>","falsifier":"<command>"}
+```
+
+Friction in the suppression path is what drives a maintainer to disable the gate
+instead of narrowing it. Make the honest narrow easier than the blunt off-switch.
+
+Prefer a **content anchor** over a line number in any new suppression entry.
+Position-keyed entries re-fire on an insertion nobody made, and this repository
+has already paid for that: 18 of 18 framework-leakage entries are line-keyed,
+and `check_suppression_hygiene` prints that count every run until they migrate.
+
+## Derived pages — render only what was measured
+
+```
+A CATEGORY WITH NO MEASUREMENT RENDERS AS ABSENT OR EXPLICITLY "NOT MEASURED".
+NEVER AS A ZERO. NEVER AS A COMPUTED SHARE.
+```
+
+Any generator that writes a derived page uses `_lib/measured_render.ts`:
+`renderShare` returns `not measured` for an empty denominator instead of
+`0.0%`, and `renderCoverage` prints the **gap list** beside the coverage number.
+
+The recorded failure: the always-budget report printed a share for a dimension
+it counted zero artefacts in. `0 / 0` became `0.0%`, which reads as a
+measurement that came back low — the most confident possible way to say nothing.
+
+Two rules follow from it:
+
+- **A coverage number is published with its gaps.** Naming the un-covered
+  artefacts costs one line and removes the reader's assumption that the
+  remainder is small. When the list is capped for length, the true remainder is
+  still stated — a silently truncated gap list reads as "covered everything"
+  exactly like the bare number it was meant to qualify.
+- **The paired test asserts the NEGATIVE.** Given an unmeasured dimension, the
+  rendered output must contain no `%` at all. Asserting only that it says "not
+  measured" still passes a renderer that helpfully appends `(0.0%)` beside it.
+
+Adoption is a ratchet, not a sweep: `check_gate_completeness` is the worked
+example, and a generator that neither imports the helper nor carries the
+negative assertion is the gap this section exists to close as generators are
+touched.
+
+## Registering the gate
+
+1. Task stanza in `taskfiles/ci-fast.yml`, `cmd: ./scripts-run src/scripts/<id> {{.QUIET_FLAG}}`.
+2. `- task: <name>` in the `ci:` list in `Taskfile.yml`.
+3. `src/config/gate-coverage.yml` entry **if** the gate emits `scanned: <N>` — a
+   test fails the build on an emitting-but-unregistered gate.
+4. Verify under **both** argv forms — bare and the CI-injected `--quiet`. A
+   wrongly-consumed flag has silently become a scan root in this repo before.
+
+Set the coverage floor **below** the live count. A floor pinned at today's exact
+number reds on the very change that legitimately retires one unit, while a floor
+well above zero still catches the collapse that matters.
+
+## See also
+
+- [`false-green.md`](false-green.md) — the catalogue of ways a green result can be false, each with its detection command.
+- `src/scripts/_lib/gate_ledger.ts` — completeness accounting.
+- `src/scripts/_lib/scan_scope.ts` — scan-root and watch-list assertions.
+- `src/scripts/_lib/ratchet_base_ref.ts` — shrink-only against the base ref.
+- `src/scripts/_lib/gate_baseline.ts` — the count ratchet and its staleness expiry.
+- `docs/contracts/ci-green-floor.md` — what CI guarantees, and the local↔remote delta.

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@event4u/agent-config",
     "mcpName": "io.github.event4u-app/agent-config",
-    "version": "9.22.0",
+    "version": "9.23.0",
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) — every claim machine-checked, including \"zero runtime daemon\".",
     "license": "MIT",
     "private": false,
@@ -39,8 +39,10 @@
         "docs/guidelines/",
         "docs/contracts/persona-schema.md",
         "docs/contracts/provider-lifecycle.md",
+        "docs/contracts/settings-classes.md",
         "src/scripts/",
         "src/server/schemas/",
+        "src/server/io/yamlIO.ts",
         "src/shared/",
         "src/install/",
         "src/agent-src/scripts/",

package/src/config/ci-local-parity.yml

@@ -69,6 +69,18 @@ pre_push_budget_seconds: 25
 #   resolver       not a gate at all — a helper a workflow step calls to compute
 #                  something (a diff base, a scope); it decides and blocks nothing
 ci_only:
+  - id: check_release_surface_equality
+    class: release
+    reason: "shells out to `gh pr diff <n>` for a live release PR — there is no PR body to compare the CHANGELOG against on a local checkout"
+  - id: check_release_highlights
+    class: release
+    reason: "requires `--version X.Y.Z` and derives evidence from a release span; exits 2 without one, so a local run gates nothing"
+  - id: check_finding_dispositions
+    class: release
+    reason: "adjudicates the release-PR self-review findings ledger, whose input JSON is produced by the self-review workflow job"
+  - id: rule_trigger_eval
+    class: network
+    reason: "live cross-model LLM trigger evaluation in the secret-gated canary workflow; advisory, paid, and never gating"
   - id: check_evaluator_budgets
     class: benchmark
     reason: "asserts against a measurements JSON that only the nightly evaluator-umbrella run produces — with no artifact there is nothing local to compare against"

package/src/config/evaluator-budgets.json

@@ -58,11 +58,11 @@
             "deterministic": false
         },
         "cli_help_command_count": {
-            "max": 84,
-            "last_measured": 84,
-            "last_measured_at": "2026-08-04",
+            "max": 85,
+            "last_measured": 85,
+            "last_measured_at": "2026-08-05",
             "method": "registry enumeration — count of `{ name: '...', disposition` entries in src/cli/registry.ts (NOT --help prose parsing; methods historically disagreed 74 vs 76 vs 79)",
-            "baseline_note": "80 → 81 on 2026-08-03 (release 9.15.0 gate). This RECORDS growth that already shipped through its own reviewed PR; it does not authorize new surface. The +1 is f02db54c2 (fix(cli): register routing:doctor in the CLI registry) — the command existed, only its registry entry was missing, and the registering PR did not move this budget. The gate did its job again: breach WARNS on main and BLOCKS on release, which is the conscious-decision point rather than a silently raised cap. Re-measured 2026-08-03 via the pinned method: 81. Headroom stays zero by design — the next registry addition must move this number in its own PR. 81 → 82 on 2026-08-04: the `handoff` subcommand (road-to-agent-handoff-resume Phase 4) registers in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 82. 82 → 84 on 2026-08-04: the `route:explain` + `route:audit` verbs (routing-correctness validation surface) register in the same PR that adds the surface. Re-measured via the pinned method: 84."
+            "baseline_note": "80 → 81 on 2026-08-03 (release 9.15.0 gate). This RECORDS growth that already shipped through its own reviewed PR; it does not authorize new surface. The +1 is f02db54c2 (fix(cli): register routing:doctor in the CLI registry) — the command existed, only its registry entry was missing, and the registering PR did not move this budget. The gate did its job again: breach WARNS on main and BLOCKS on release, which is the conscious-decision point rather than a silently raised cap. Re-measured 2026-08-03 via the pinned method: 81. Headroom stays zero by design — the next registry addition must move this number in its own PR. 81 → 82 on 2026-08-04: the `handoff` subcommand (road-to-agent-handoff-resume Phase 4) registers in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 82. 82 → 84 on 2026-08-04: the `route:explain` + `route:audit` verbs (routing-correctness validation surface) register in the same PR that adds the surface. Re-measured via the pinned method: 84. 84 → 85 on 2026-08-05: the `settings:set` verb (road-to-zero-ceremony-settings Phase 2 — the one agent-reachable settings writer) registers in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 85."
         },
         "mcp_public_tool_count": {
             "max": 19,

package/src/config/gate-coverage.yml

@@ -40,21 +40,24 @@
 #                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-04)
+# COVERAGE — THE HONEST DENOMINATOR (re-measured 2026-08-05)
 # ----------------------------------------------------------
-# 223 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
+# 224 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
 # (the count is computed, not asserted — `check_gate_coverage.count_gate_scripts`).
-# **22 of them emit the machine-readable `scanned: <N>` line under their
-# CI-identical argv, and all 22 are listed below.** The manifest is therefore
-# complete with respect to its own contract, and covers ~10 % of the population.
+# **27 of them emit the machine-readable `scanned: <N>` line under their
+# CI-identical argv, and all 27 are listed below.** The manifest is therefore
+# complete with respect to its own contract, and covers ~12 % of the population.
 #
-# The previous revision of this header claimed "8 of 211". Both halves had
-# drifted: entries were added without the header following, and the population
-# grew by 12. Numbers written in prose beside a mechanism that can compute them
-# is how a denominator goes stale — the population figure now comes from the
-# function, and the honest-denominator test bounds the drift.
+# Two revisions of this header have now gone stale the same way. It claimed
+# "8 of 211", then "22 of 223" while 26 entries were listed. Both halves drift
+# for the same reason: entries are added without the header following. Numbers
+# written in prose beside a mechanism that can compute them is how a denominator
+# goes stale — the population figure comes from the function, the
+# honest-denominator test bounds the drift on that half, and the emitter half
+# stays a manual count until something computes it too. If you add an entry,
+# the two numbers in the paragraph above are part of the diff.
 #
-# The other ~201 are NOT covered, for one reason: rule 1. They print their count
+# The other ~197 are NOT covered, for one reason: rule 1. They print their count
 # in prose ("111 file(s) scanned", "0 declarer(s)") or not at all, and a guard
 # that parses prose is the fragile thing being replaced. Padding this list with
 # them would manufacture exactly the false green the file exists to prevent.
@@ -107,6 +110,29 @@
 # 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_gate_completeness
+    argv: []
+    min_scanned: 180
+    corpus: "gates reachable from the `ci` / `consistency` task roots (220 at baseline)"
+    status: enforced
+    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
+      would red on the very change that removes one. It is still high enough
+      that a broken closure walk — the dead-scan-root shape one level up, where
+      the Taskfile parse degrades and the population silently collapses —
+      cannot pass.
+
+  - id: check_suppression_hygiene
+    argv: []
+    min_scanned: 8
+    corpus: "declared human-authored suppression surfaces (10 at baseline)"
+    status: enforced
+    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_trigger_collisions
     argv: []
     min_scanned: 90
@@ -322,7 +348,7 @@ gates:
   - id: lint_framework_leakage
     argv: []
     min_scanned: 350
-    corpus: "skills / rules / commands .md (431 at baseline)"
+    corpus: "skills / rules / commands .md actually judged (368 of 438 enumerated; the rest carry a declared exemption the ledger names)"
     status: enforced
     note: >
       Its human summary prints "N hits across M files", where M is files WITH
@@ -459,3 +485,19 @@ gates:
       meaningful — it now falls when one of the three inputs is renamed away.
       `argv: []` is the CI-identical invocation: both `taskfiles/ci-fast.yml`
       and `.github/workflows/tests.yml` call it bare.
+
+  - id: lint_settings_classes
+    argv: ["--quiet"]
+    min_scanned: 100
+    corpus: "leaf keys in src/config/agent-settings.template.yml (140 at baseline)"
+    status: enforced
+    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
+      exists to catch — the template moving and the gate classifying an empty
+      map — cannot pass. No `canary:` recipe: this gate's 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 instead by the gate's own
+      `--self-test`, which drives the real binary through six rejecting cases
+      including the dead-scan-root one.

package/src/config/gate-violation-baselines.json

@@ -20,6 +20,12 @@
       "count": 337,
       "landed": "2026-08-02",
       "note": "Markdown links between source artefacts that cross a pack boundary the source pack's `requires` graph does not reach — revealed when the scan root moved off the deleted packages/ tree to the live corpus (0 -> 753 artefacts scanned). 82 distinct pack pairs across 131 source files; largest single class is engineering-base -> meta (73), skills in a consumer-installable pack citing this package's own maintenance skills. Each is a link that dangles for a consumer who installs the source pack without the target's. Judged real drift rather than an over-strict gate because it is long-tailed — top bucket 22%, no single systematic cause — unlike the lint_artefact_frontmatter case, where one required shape had 0-of-288 adoption. Fix per finding: add the edge to packs.yml requires, retarget the link, or move the artefact."
+    },
+    "check_gate_completeness": {
+      "count": 217,
+      "landed": "2026-08-05",
+      "note": "Ledger adoption ratchet. 217 of 221 CI-registered gates do not yet carry per-target completeness accounting (`_lib/gate_ledger.ts`) or a `// ledger-exempt:` marker. This is deliberately NOT a sweep: road-to-skill-ecosystem-gate-integrity Phase 1 adopts exactly three gates (lint_framework_leakage, check_references, lint_roadmap_complexity) plus the checker itself to prove the interface, and the remainder migrates as gates are touched. Shrink-only from here — the number may not grow, so a NEW gate must adopt or exempt.",
+      "falsifier": "./scripts-run src/scripts/check_gate_completeness"
     }
   }
 }

package/src/config/pack-size-budget.json

@@ -7,9 +7,10 @@
     "measurement_conditions": "npm pack --dry-run --json --ignore-scripts, run at the repo root on a clean checkout. `--ignore-scripts` means NO build runs, so dist/cli, dist/ui, dist/mcp and dist/hooks are absent and the figure covers only the TRACKED payload (src/scripts/, dist/agent-src/, dist/install/, docs/guidelines/, templates). That is deliberate: this gate is always-on for every PR, and the tracked content tree is exactly the surface that grows by accretion. The built artifact is ~5.4 MB larger and is gated separately, at release time, by evaluator-budgets.unpacked_size_mb.",
     "budgets": {
         "packed_size_mb": {
-            "max": 6.4,
-            "last_measured": 5.903,
-            "method": "npm pack --dry-run --json --ignore-scripts → dist.size / 1e6 (the compressed tarball a consumer actually downloads)"
+            "max": 6.9,
+            "last_measured": 6.398,
+            "method": "npm pack --dry-run --json --ignore-scripts → dist.size / 1e6 (the compressed tarball a consumer actually downloads)",
+            "baseline_note": "5.903 → 6.398 re-baselined 2026-08-05. This is a RE-BASELINE, not a carve-out for the change that tripped it: measured on the tracked tree, `origin/main` alone was already at 6.372 of a 6.4 cap, so 28 KB of headroom remained after months of accretion and the next legitimate addition of any size was going to cross it. The addition here is 26 KB — docs/contracts/settings-classes.md (the A/B/C fence, read at RUNTIME by the settings writer, so it must ship) plus src/server/io/yamlIO.ts (imported by that writer to preserve the user's comments). CI measures ~4 KB above the local figure because it regenerates dist/agent-src first. Max set to 6.9 rather than to a number that merely clears: a cap pinned 2 KB above the measurement reds on the next commit and teaches the reader to raise it again, which is how a budget becomes a formality. That restores the ~8% headroom the 5.903/6.4 pair originally carried. The `owner: maintainer` on this file stands — this raise is surfaced in the PR for that decision, not smuggled."
         }
     },
     "per_skill_share": {