@event4u/agent-config 13.0.0 → 14.1.0

package/src/agent-src/scripts/update_roadmap_progress.ts

@@ -180,11 +180,11 @@ class RoadmapStats {
     }
 
     get open_blockers(): Blocker[] {
-        return this.blockers.filter((b) => b.status !== 'resolved');
+        return this.blockers.filter((b) => !blocker_is_resolved(b));
     }
 
     get resolved_blockers(): Blocker[] {
-        return this.blockers.filter((b) => b.status === 'resolved');
+        return this.blockers.filter((b) => blocker_is_resolved(b));
     }
 
     get done(): number {
@@ -365,6 +365,49 @@ interface Blocker {
      * costs one enum entry and turns a silent swallow into a rendered field.
      */
     question: string;
+    /**
+     * Gate taxonomy: `0` auto-run · `1` budget-preauthorized · `2`
+     * consent-once · `3` human-only. Empty string when the entry declares
+     * none, and an absent class READS AS 3 at every consumer.
+     *
+     * The default is the safe end on purpose. An agent that inferred the class
+     * at runtime could promote a Hard-Floor gate into something it executes;
+     * authoring it into the file means a misclassification is a reviewed edit,
+     * and `lint_roadmap_blockers` refuses a runnable class that names no
+     * command.
+     */
+    blockerClass: string;
+    /** The command a class-0/1 entry is resolved by running. */
+    run: string;
+    /** Spend estimate for class 1 — recorded, never enforced by the lint. */
+    budget: string;
+}
+
+/**
+ * Is this blocker settled?
+ *
+ * A PREFIX test, not equality, and the difference was measured: authors write
+ * the resolution into the status line — `**Status:** RESOLVED 2026-08-17 —
+ * **option (b)**, narrowed to two rules` — and an equality check matches
+ * neither `open` nor `resolved`, so the entry falls through to open. Found
+ * 2026-08-17 in `road-to-mixed-trigger-activation-cost`: a decision taken two
+ * days earlier was still being rendered by `agent-config gates` as a live one
+ * the reader owed an answer to, and it inflated every blocker count in the
+ * dashboard by one.
+ *
+ * `lint_roadmap_blockers` already read the same field as a prefix
+ * (`/^-\s*\*\*Status:\*\*\s*resolved/i`), so the two surfaces disagreed about
+ * what "resolved" means — the lint exempted the entry from its decidability
+ * ratchet while the dashboard counted it open.
+ */
+function blocker_is_resolved(b: Blocker): boolean {
+    return /^resolved\b/.test(_strip(b.status).toLowerCase());
+}
+
+/** Class of a blocker, with the absent-field default applied. */
+function blocker_class(b: Blocker): '0' | '1' | '2' | '3' {
+    const c = _strip(b.blockerClass).split(/[\s—–-]/)[0] as string;
+    return c === '0' || c === '1' || c === '2' ? c : '3';
 }
 
 // Strip fenced code blocks before blocker detection — a roadmap that shows the
@@ -508,6 +551,9 @@ function parse_blockers(raw_text: string): Blocker[] {
                 recommendation: _blockerField(body, 'Recommendation') ?? '',
                 ifNothing: _blockerField(body, 'If you do nothing') ?? '',
                 question: _blockerField(body, 'Question') ?? '',
+                blockerClass: _blockerField(body, 'Class') ?? '',
+                run: _blockerField(body, 'Run') ?? '',
+                budget: _blockerField(body, 'Budget') ?? '',
             });
         }
     }
@@ -542,6 +588,9 @@ function parse_blockers(raw_text: string): Blocker[] {
             recommendation: '',
             ifNothing: '',
             question: '',
+            blockerClass: '',
+            run: '',
+            budget: '',
         });
     }
     return blockers;
@@ -1187,6 +1236,8 @@ export {
     is_roadmap_candidate,
     count_checkboxes,
     parse_blockers,
+    blocker_class,
+    blocker_is_resolved,
     blocker_needs_user,
     parse_roadmap,
     bar,

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

@@ -184,6 +184,19 @@ ci_only:
 # worth remote enforcement, OR it should simply be added to a workflow. Prefer
 # adding it: a local-only gate is the direction that let real defects merge.
 local_only:
+  - id: check_pr_ci_current
+    class: pre-push-scoped
+    reason: >
+      Compares the local branch tip against the open PR head and against the SHA
+      the PR's checks actually ran on. In CI that comparison is tautological by
+      construction — a workflow runs ON the PR head, so local, PR head and checks
+      head are the same commit and the gate can only ever pass. Its whole subject
+      is the window BEFORE a push (unpushed work, a green that ran against the
+      pre-fix commit, a PR head the checkout cannot reach because Update branch
+      was pressed), and that window does not exist inside a run. Declared rather
+      than wired: there is no remote equivalent to write, which is the distinction
+      this list exists to record. Sibling `check_branch_freshness` is a no-op in
+      CI for the same reason — the forge owns mergeability there.
   - id: roadmap_progress_hook
     class: git-hook-scoped
     reason: >

package/src/config/evaluator-budgets.json

@@ -58,11 +58,11 @@
       "deterministic": false
     },
     "cli_help_command_count": {
-      "max": 98,
-      "last_measured": 98,
-      "last_measured_at": "2026-08-15",
+      "max": 99,
+      "last_measured": 99,
+      "last_measured_at": "2026-08-17",
       "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. 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. 85 → 86 on 2026-08-06: the `conformance:behavior` verb (road-to-agent-behavior-conformance Phase 5 — replays the local transcript store through the four mechanised conformance checks) registers in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 86. 86 → 88 on 2026-08-07: the `sessions:list` + `sessions:claim` verbs (road-to-parallel-session-coordination — the shell surface of the shared session register, needed because /roadmap:next is command markdown and can only reach the register through a shell call) register in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 88. 88 → 89 on 2026-08-08: the `council:status` verb registers in the same PR that adds the surface, per this record's own contract. It exists because an agent in a consumer project announced \"kein Council konfiguriert (keine .agent-settings.yml)\" and substituted a weaker path while the council was configured user-globally the whole time — there was no verb that answered availability, so the only route was an inference from a filename, and the intuitive filename is the one location ADR-104 guarantees is never consulted. Re-measured via the pinned method: 89. 89 → 91 on 2026-08-08: the `self-repair:status` + `self-repair:release` verbs (the queued-defect reader and the single Hard-Floor-gated outward step of the self-repair loop — the loop is deliberately unable to publish unless a human runs the release command) register in the same PR that adds the surface, per this record's own contract. Landed alongside the +1 council:status move in the same branch. Re-measured via the pinned method: 91. 91 → 94 on 2026-08-08: the `packs:active`, `settings:get` and `mcp:available` verbs (road-to-capability-answerability Phase 2 — the three capability probes for the gaps that had none) register in the same PR that adds the surface, per this record's own contract. Each answers a question that was previously only inferable from a filename: which packs are active and from which file, what a setting resolves to and which file set it, and what is declared in mcp.json versus what can actually launch. 94 -> 95 in the same PR: `brand:status` (Phase 2.4 — brand-layer presence, which the rule depended on and no surface could answer). Re-measured twice via the pinned method on the unchanged tree: 95/95. 95 → 96 on 2026-08-10: the `session:recycle` verb (road-to-token-economy-recycling Phase 2.2 — the deterministic producer of the main-session recycle envelope; the recycle advisory names this exact verb, so it must exist as a shell surface) registers in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 96. 96 -> 97 on 2026-08-10: the `gates` verb registers in the same PR that adds the surface, per this record's own contract. It exists because the blocker fields the dashboard already parses (Owner, What to do, Resolved when — CI-enforced by lint_roadmap_blockers) had no owner-filtered reader: the dashboard counts the open blockers across a 600-line file and links each to a per-roadmap anchor, so \"which of these are mine\" was a manual read of every anchor. The same inference-from-a-filename shape as the council:status entry above, one layer up. This branch and the session:recycle branch each measured 96 independently and landed on the same number for different verbs; the merge makes it 97, re-measured twice via the pinned method on the merged tree: 97/97. 97 -> 98 on 2026-08-15: the `workspace:doctor` verb (road-to-inbox-harvest-2026-08-c-workspace-identity Phase 3 — the read-only report over the new `workspaceIdentity()` resolver) registers in the same PR that adds the surface, per this record's own contract. It exists for the same inference-from-a-filename shape as the council:status and gates entries above, one layer down: the tree answered \"where am I\" in eight ad-hoc places across six files, and the 12.0.0 span shipped the same worktree misclassification twice, so no verb could be asked which checkout is the main one. Read-only by construction — the roadmap's Non-goals put worktree disposal out of scope and its Risk 3 names \"the pressure read becomes a disposal path by accident\" as the failure to design against, so the command carries no --fix and no --prune. Re-measured twice via the pinned method on the unchanged tree: 98/98."
+      "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. 85 → 86 on 2026-08-06: the `conformance:behavior` verb (road-to-agent-behavior-conformance Phase 5 — replays the local transcript store through the four mechanised conformance checks) registers in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 86. 86 → 88 on 2026-08-07: the `sessions:list` + `sessions:claim` verbs (road-to-parallel-session-coordination — the shell surface of the shared session register, needed because /roadmap:next is command markdown and can only reach the register through a shell call) register in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 88. 88 → 89 on 2026-08-08: the `council:status` verb registers in the same PR that adds the surface, per this record's own contract. It exists because an agent in a consumer project announced \"kein Council konfiguriert (keine .agent-settings.yml)\" and substituted a weaker path while the council was configured user-globally the whole time — there was no verb that answered availability, so the only route was an inference from a filename, and the intuitive filename is the one location ADR-104 guarantees is never consulted. Re-measured via the pinned method: 89. 89 → 91 on 2026-08-08: the `self-repair:status` + `self-repair:release` verbs (the queued-defect reader and the single Hard-Floor-gated outward step of the self-repair loop — the loop is deliberately unable to publish unless a human runs the release command) register in the same PR that adds the surface, per this record's own contract. Landed alongside the +1 council:status move in the same branch. Re-measured via the pinned method: 91. 91 → 94 on 2026-08-08: the `packs:active`, `settings:get` and `mcp:available` verbs (road-to-capability-answerability Phase 2 — the three capability probes for the gaps that had none) register in the same PR that adds the surface, per this record's own contract. Each answers a question that was previously only inferable from a filename: which packs are active and from which file, what a setting resolves to and which file set it, and what is declared in mcp.json versus what can actually launch. 94 -> 95 in the same PR: `brand:status` (Phase 2.4 — brand-layer presence, which the rule depended on and no surface could answer). Re-measured twice via the pinned method on the unchanged tree: 95/95. 95 → 96 on 2026-08-10: the `session:recycle` verb (road-to-token-economy-recycling Phase 2.2 — the deterministic producer of the main-session recycle envelope; the recycle advisory names this exact verb, so it must exist as a shell surface) registers in the same PR that adds the surface, per this record's own contract. Re-measured via the pinned method: 96. 96 -> 97 on 2026-08-10: the `gates` verb registers in the same PR that adds the surface, per this record's own contract. It exists because the blocker fields the dashboard already parses (Owner, What to do, Resolved when — CI-enforced by lint_roadmap_blockers) had no owner-filtered reader: the dashboard counts the open blockers across a 600-line file and links each to a per-roadmap anchor, so \"which of these are mine\" was a manual read of every anchor. The same inference-from-a-filename shape as the council:status entry above, one layer up. This branch and the session:recycle branch each measured 96 independently and landed on the same number for different verbs; the merge makes it 97, re-measured twice via the pinned method on the merged tree: 97/97. 97 -> 98 on 2026-08-15: the `workspace:doctor` verb (road-to-inbox-harvest-2026-08-c-workspace-identity Phase 3 — the read-only report over the new `workspaceIdentity()` resolver) registers in the same PR that adds the surface, per this record's own contract. It exists for the same inference-from-a-filename shape as the council:status and gates entries above, one layer down: the tree answered \"where am I\" in eight ad-hoc places across six files, and the 12.0.0 span shipped the same worktree misclassification twice, so no verb could be asked which checkout is the main one. Read-only by construction — the roadmap's Non-goals put worktree disposal out of scope and its Risk 3 names \"the pressure read becomes a disposal path by accident\" as the failure to design against, so the command carries no --fix and no --prune. Re-measured twice via the pinned method on the unchanged tree: 98/98. 98 -> 99 on 2026-08-17: the `council:quota` verb (road-to-council-quota-accounting-truth Phase 2) registers in the same PR that adds the surface, per this record's own contract. Exactly the inference-from-a-filename shape as the council:status entry above, one layer down: `cmd_quota` had existed in council_cli.ts and been reachable only via `scripts-run`, so the documented recovery path for an exhausted shared counter -- read the usage, reset one provider -- did not resolve through `agent-config`, and an operator debugging a quota failure met `unknown command`. The verb is read-only apart from the pre-existing `--reset <provider>`, which already required `--confirm`. Re-measured twice via the pinned method on the unchanged tree: 99/99."
     },
     "mcp_public_tool_count": {
       "max": 20,

package/src/config/gate-coverage.yml

@@ -40,13 +40,26 @@
 #                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-16)
+# COVERAGE — THE HONEST DENOMINATOR (re-measured 2026-08-17)
 # ----------------------------------------------------------
-# 260 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
+# 266 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
 # (the count is computed, not asserted — `check_gate_coverage.count_gate_scripts`).
-# **37 of them emit the machine-readable `scanned: <N>` line under their
-# CI-identical argv, and all 37 are listed below.** The manifest is therefore
-# complete with respect to its own contract, and covers ~14 % of the population.
+# **41 of them emit the machine-readable `scanned: <N>` line under their
+# CI-identical argv, and 40 of those 41 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.
+#
+# 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
+# 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
+# `check_gate_completeness` counts it as an adopter.
+#
+# Counting emitters rather than rows is the point of stating both numbers: the
+# 2026-08-05 and 2026-08-10 readings below were miscounts precisely because one
+# number was updated and the other was not.
 # (The 2026-08-05 reading said "32 … and all 31 are listed" and the 2026-08-10
 # reading said "33 … and all 33" while 34 entries were listed — those two are
 # the MISCOUNTS this paragraph exists to warn about, and they are listed here
@@ -169,6 +182,99 @@ gates:
       the Taskfile parse degrades and the population silently collapses —
       cannot pass.
 
+  - id: check_rule_activation_census
+    argv: []
+    min_scanned: 100
+    corpus: "rule files under src/rules/ (117 at baseline)"
+    status: enforced
+    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
+      rule root moved, this gate's own assertScanned fires first and the manifest
+      row is the second net. The gate exists because commit 33c7c20 moved nineteen
+      rules from path-scoped to always-on with nothing watching, so a version of
+      it that silently scanned zero would be the same failure twice.
+
+  - id: check_rule_stub_ceiling
+    argv: []
+    min_scanned: 100
+    corpus: "rule files under src/rules/ (117 at baseline; 44 carry a migration pointer)"
+    status: enforced
+    note: >
+      Scans the whole rule root and reports that count, not the 44 migrated rules
+      it ratchets — the denominator is what proves the root still exists, and a
+      floor on the migrated subset would fall as rules legitimately finish
+      migrating. Floor set below the live 117 so a rule retirement does not red
+      the gate. The gate's own assertScanned fires first if the root moves; this
+      row is the second net. It exists because the sibling census pins the corpus
+      total with a 2,000-token drift allowance, which is green while one rule
+      grows and another shrinks — measured at adoption, the corpus sat 411 tokens
+      above its pinned baseline with that gate green.
+    canary:
+      class: contract-violation
+      path: src/rules/zz-canary-stub-probe.md
+      content: |
+        ---
+        type: "auto"
+        ---
+
+        # ZZ canary probe
+
+        Body migrated to `guideline:zz-canary-target-that-does-not-exist`.
+      # A created rule is the create-only shape this gate is built for: it carries
+      # a migration pointer whose target resolves nowhere AND has no ceiling in the
+      # baseline, so it trips two independent axes. Without a recipe the gate would
+      # ship permanently UNPROVEN — a green run over a real corpus is not evidence
+      # that the reading changes the verdict, which is the whole point of the
+      # canary. The gate also carries a `--self-test` with seven rejecting cases;
+      # the two prove different things and neither replaces the other.
+
+  - id: check_review_schema
+    argv: []
+    min_scanned: 1
+    corpus: "committed review-findings ledgers under agents/evidence/release-findings/ (1 at baseline)"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: agents/evidence/release-findings/zz-canary-probe.json
+      content: |
+        {
+          "schema_version": 1,
+          "release": "0.0.0-canary",
+          "review_independence": "same-family",
+          "acceptance_status": "accepted",
+          "assurance": "independent",
+          "reviewers": ["anthropic", "anthropic"],
+          "findings": []
+        }
+    note: >
+      Floor is 1 because the corpus genuinely holds one ledger today, and a
+      floor of 0 would let the directory empty out silently — the shape this
+      manifest exists to refuse. The canary plants the exact defect the gate was
+      built for: a same-family reviewer set claiming `accepted`. It must red.
+
+  - id: check_evaluator_schema
+    argv: []
+    min_scanned: 5
+    corpus: "registered evaluator x recorded verifier fixture pairs (6 at baseline)"
+    status: enforced
+    canary:
+      class: contract-violation
+      path: tests/fixtures/evaluator-output/lint_output_slop.degraded.stdout
+      content: |
+        planted canary: output with no clean sentinel and no file:line rows
+    note: >
+      The corpus is (evaluator x fixture) pairs, not evaluators, because the
+      mapping is what can be wrong and each flavour exercises a different branch
+      of it. The floor sits below the live count so retiring one fixture flavour
+      does not red the change that retires it, but above 3 so a corpus that
+      silently collapsed to green-only cannot pass — a green-only corpus cannot
+      distinguish a working adapter from one that hardcodes success, which is
+      the whole reason red and degraded fixtures are committed alongside.
+      The canary plants a `degraded` stdout with no matching `.exit`, so the
+      adapter reads exit 0 with an unparseable body: expected `unreadable`,
+      asserted `present` by the green expectation table -> the gate must fail.
+
   - id: check_suppression_hygiene
     argv: []
     min_scanned: 8

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

@@ -34,9 +34,9 @@
       "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": 216,
-      "landed": "2026-08-12",
-      "note": "Ledger adoption ratchet. 216 of 244 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.",
+      "count": 215,
+      "landed": "2026-08-17",
+      "note": "Ledger adoption ratchet. Gates registered under the CI task roots that carry neither per-target completeness accounting (`_lib/gate_ledger.ts`) nor 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. Lowered 216 -> 215 on 2026-08-17 by discharging the obligation three NEW arrivals had incurred, which is the standing rule being enforced rather than a drain: the registered population grew 244 -> 258 and three of the fourteen arrivals adopted nothing — `build_archive_index`, `check_gate_coverage`, `check_pr_ci_current`. The reading was 218 against this baseline of 216, and the missing arithmetic is that one PRE-existing gate (`lint_rule_skill_pack_reach`) had adopted in the meantime: 216 + 3 - 1 = 218. All three adopted a real ledger. `check_pr_ci_current` first took a reasoned exemption claiming no target population; the completion review refuted it from the file itself — the check rows ARE a population, and rows whose `state` is not a string were being dropped before any verdict ran, so a dropped row could be the failing one. The exemption was withdrawn and the ledger adopted, counting kept rows as read, dropped rows as skips, and rows a pre-row verdict never reached as out of scope. The denominator in this note was 14 stale (it said 244) and is now expressed without one, because a count pinned to a population that grows weekly rots faster than the count itself. Note what this lowering does NOT buy: headroom is zero either way, so the next un-adopted arrival reds this gate immediately — which is the intended behaviour and the reason the number is not padded. The refreshed `landed` is load-bearing rather than bookkeeping: `checkRatchet` returns `improved` BEFORE it evaluates staleness, so an entry left at 216 while the tree measures 215 would never expire at any age (pinned by tests/lib/gate_baseline.test.ts, which asserts `improved` at landed + STALE_AFTER_DAYS + 400 days) — the greenest available state and the worst, since it switches off the anti-fossilization clause exactly when someone has done real work.",
       "falsifier": "./scripts-run src/scripts/check_gate_completeness"
     },
     "check_depth_budget": {
@@ -57,9 +57,9 @@
       "falsifier": "./scripts-run src/scripts/lint_settings_classes"
     },
     "check_source_size_budget": {
-      "count": 19725,
+      "count": 19611,
       "landed": "2026-08-17",
-      "note": "Lowered 19,763 → 19,725 on 2026-08-17 by the T4/T5 endpoint branch, and it is a lowering rather than a re-anchor: that branch grew two already-over-ceiling files (bench_ab_v2_run.ts, bench_ab_v2_stats.ts) by 89 lines and paid it back by EXTRACTION — the workspace/transcript lifecycle and the T5 report adapters moved into `_lib/`, which is exactly what this entry means by lowering happening through splitting a god-file. Trimming comments was tried first and reached 5 of the 89; the extraction went 38 past the baseline, which is the difference between the two moves. Total lines above the 1,500-line source ceiling, summed across the 1,063 hand-written `.ts` files under `src/` — `*.d.ts` and `*.test.ts` are excluded, the same two kinds `_lib/gate_population` excludes and for the same stated reasons (a declaration has no runtime behaviour; a test file is not the reviewable code this ceiling bounds). Latent rather than cosmetic: a GENERATED `.d.ts` over the ceiling would otherwise red a ratchet aimed at hand-written code. Revealed by introducing check_source_size_budget, not created by it: every other size budget in this suite guards prose (rules by char cap, skills by token class, the depth layer by check_depth_budget), and the TypeScript the package actually ships carried none — which is where the largest artefacts in the tree sit. Fifteen files are over the ceiling; the worst three are install.ts (5,461), skill_linter.ts (4,742) and council_cli.ts (4,058). THE METRIC IS EXCESS LINES, NOT A FILE COUNT, and that is the load-bearing choice: a file count would read 15 whether install.ts sits at 5,461 or at 9,000, so the gate would stay green while the exact defect it exists for got worse. Summing the excess costs the same one integer and fails on growth inside an already-listed file — pinned by a self-test case that holds the file count at 1 and moves only the size. Baselined rather than hard-failed because 15 god-files nobody can split in the change that reveals them is the gate-that-lands-as-N-instant-blockers failure this repository has refused before; shrink-only keeps the property that matters, namely that a NEW file over 1,500 lines reds immediately. The ceiling is a growth ratchet, never a quality threshold: 1,500 was chosen by measuring this tree (15 files over 1,500, versus 44 over 1,000 and 75 over 800) as the tightest ceiling whose ledger stays signal rather than becoming the 20-plus-entry allowlist this repository's own rules call evidence that the linter is wrong. Lowering happens by splitting a god-file, and the ordering is deliberate: ratchet BEFORE split, so every later split is a lowering commit whose gain is visible in one integer, instead of a large diff with nothing asserting it improved anything. The 56-day expiry is the point, not a hazard — a ceiling with no forcing function would leave these fifteen files at these fifteen sizes indefinitely with the gate green the whole time. Re-anchored 19,676 → 19,763 on 2026-08-16 when this branch merged current main, and the +87 is population growth rather than a loosening — the same shape the blocker ratchet above records for its own +4. Every one of the 87 lines is `src/scripts/mcp_server/tools.ts` growing on the trunk between this branch's base (8edeae39) and the merge; no file in this branch's own diff is over the ceiling at all, which is checkable in one command: `git diff --stat <base> origin/main -- <the fifteen listed files>`. Recording 19,676 against a 19,763-line tree is the failure this entry's own test asserts against — a baseline below the truth fails the gate on arrival, and one above it silently sells a free regression.",
+      "note": "Lowered 19,626 → 19,611 on 2026-08-17 by the release-gh-transient branch, and it is a LOWERING through extraction, never a raise — the −15 is against the trunk value, reproducible with `git stash && npx tsx src/scripts/check_source_size_budget.ts`. That branch hardened `release.ts` against GitHub's 5xx responses, which is exactly the kind of change that grows an already over-ceiling file: release.ts sits at 2,819 and carries 1,319 of this total. The retry loop, the transient classifier and the argv elider therefore went into a NEW module (`_lib/gh_transient.ts`, 74 lines, under the ceiling and contributing nothing here), leaving release.ts a 20-line wrapper. The payback came from the five call sites the wrapper replaced: each was a `run(['gh', …], {check, capture})` block spread over up to 17 lines, and each collapses to one `gh([…])` call. The ordering is the lesson and it matches the two entries below: extract, then measure — a wrapper written inline would have added ~20 lines and turned a hardening commit into a ratchet regression. Second lesson, learned the hard way on this same branch: pin the baseline ONCE, at the end. Two intermediate pins (19,606 then 19,612) made subsequent legitimate edits read as `N new` against numbers that had never been on the trunk.",
       "falsifier": "./scripts-run src/scripts/check_source_size_budget --quiet"
     }
   }

package/src/config/rule-activation-census.json

@@ -0,0 +1,41 @@
+{
+    "_comment": "Rule-activation ratchet baseline (road-to-mixed-trigger-activation-cost step 4.1). Two axes: the scoped/mixed ID SETS are pinned by identity, and the unconditional token total may only walk DOWN. Raising a number here to clear a failing check is the config-weakening move this repo blocks by construction \u2014 every raise needs a baseline_history entry whose reason is a real sentence. Regenerate with `check_rule_activation_census --write-baseline`; never hand-edit the counts.",
+    "measured_at_commit": "097ab6549",
+    "tokens_exact": true,
+    "unconditional_tokens": 103265,
+    "scoped_ids": [
+        "design-review-after-ui-write",
+        "no-roadmap-references",
+        "roadmap-progress-sync",
+        "rule-type-governance",
+        "skill-quality",
+        "source-confidentiality",
+        "source-of-truth",
+        "ui-audit-gate"
+    ],
+    "mixed_ids": [
+        "augment-edit-discipline",
+        "design-fidelity",
+        "doc-screenshot-hygiene",
+        "domain-adoption-policy",
+        "framework-neutrality-in-generic-skills",
+        "image-likeness-and-rights",
+        "laravel-translations",
+        "lethal-trifecta-guard",
+        "linked-projects-onboarding-gate",
+        "low-impact-corpus-privacy-floor",
+        "markdown-safe-codeblocks",
+        "onboarding-gate",
+        "persona-governance",
+        "php-coding",
+        "provider-lifecycle-discipline",
+        "roadmap-ci-steps-policy",
+        "settings-ask-protocol"
+    ],
+    "baseline_history": [
+        {
+            "date": "2026-08-17",
+            "reason": "Re-anchored WITH the authorized change, not to clear a red. road-to-mixed-trigger-activation-cost Phase 2, amendment option (b) narrowed to the two path-dominant per-edit rules: `design-review-after-ui-write` and `ui-audit-gate` had their `component` and `design token` keyword triggers removed as an authoring decision, so the emitter restores `paths:` for both. Scoped 6 -> 8, mixed 19 -> 17, unconditional corpus 107194 -> the value above. The direction is DOWN on the weight axis and the identity move is the authorized one; the maintainer asked for this entry in the same commit so the ratchet documents its own sanctioned change instead of reporting it as drift."
+        }
+    ]
+}

package/src/config/rule-stub-ceilings.json

@@ -0,0 +1,52 @@
+{
+    "_comment": "Per-rule stub ceilings (road-to-rule-stub-projection Phase 2). One exact-BPE token ceiling per rule carrying a migration pointer. SHRINK-ONLY: a rule may fall below its ceiling freely, and may not rise above it. Raising a ceiling to clear a failing check is the config-weakening move this repo blocks by construction — every raise needs a `history` entry whose `reason` is a real sentence. The ceilings are a floor-plus-residue SNAPSHOT taken at adoption, not a target: a rule at its ceiling is not thereby correct, only not worse. Regenerate with `check_rule_stub_ceiling --write-baseline`; never hand-edit the counts.",
+    "measured_at_commit": "d8e2ee655",
+    "tokens_exact": true,
+    "ceilings": {
+        "active-remediation": 1601,
+        "analysis-skill-routing": 76,
+        "architecture": 955,
+        "artifact-drafting-protocol": 611,
+        "augment-edit-discipline": 137,
+        "autonomous-execution": 1633,
+        "brand-consistency": 133,
+        "broken-access-control": 743,
+        "cli-output-handling": 83,
+        "code-comment-discipline": 692,
+        "commit-conventions": 136,
+        "context-hygiene": 2447,
+        "copilot-routing": 128,
+        "decision-revisit-gate": 545,
+        "design-fidelity": 2245,
+        "devcontainer-routing": 128,
+        "docker-commands": 79,
+        "domain-adoption-policy": 497,
+        "framework-neutrality-in-generic-skills": 621,
+        "git-history-discipline": 1205,
+        "improve-before-implement": 845,
+        "laravel-routing": 126,
+        "laravel-translations": 82,
+        "legal-safety-floor": 1401,
+        "linked-projects-onboarding-gate": 172,
+        "minimal-safe-diff": 893,
+        "missing-tool-handling": 103,
+        "model-recommendation": 156,
+        "no-roadmap-references": 644,
+        "package-ci-checks": 74,
+        "persona-governance": 330,
+        "php-coding": 80,
+        "provider-lifecycle-discipline": 472,
+        "reviewer-awareness": 131,
+        "roadmap-ci-steps-policy": 564,
+        "roadmap-progress-sync": 1424,
+        "rule-type-governance": 87,
+        "skill-improvement-trigger": 81,
+        "skill-quality": 78,
+        "slash-command-routing-policy": 77,
+        "symfony-routing": 129,
+        "ui-audit-gate": 1280,
+        "untrusted-input-defense": 845,
+        "upstream-proposal": 76
+    },
+    "history": []
+}

package/src/scripts/_dispatch.bash

@@ -162,6 +162,9 @@ Tier 1 — power-user (release shape, audit, migration):
                              Usage: council:render <responses.json>
   council:status             Report whether an AI council is configured, and from where
                              (no API call, no spend)
+  council:quota              Show today's per-provider CLI-call usage against the
+                             enforced cap; --reset <provider> --confirm clears one
+                             (no API call, no spend)
   self-repair:status         List queued agent-config defect records (read-only)
   self-repair:release        Publish one defect record — a PR when the fix can be
                              pushed, else an issue. Running it is your Hard-Floor
@@ -1443,6 +1446,7 @@ main() {
     council:run)             cmd_council run "$@" ;;
     council:render)          cmd_council render "$@" ;;
     council:status)         cmd_council status "$@" ;;
+    council:quota)           cmd_council quota "$@" ;;
     self-repair:status)      cmd_self_repair status "$@" ;;
     self-repair:release)     cmd_self_repair release "$@" ;;
     update)                  cmd_update "$@" ;;

package/src/scripts/_lib/evaluator_contract.ts

@@ -0,0 +1,159 @@
+/**
+ * The evaluator-output contract: types, the registry of wrapped verifiers, and
+ * the validator both the gate and any future loop share.
+ *
+ * Contract: `docs/contracts/evaluator-output.md`.
+ * Schema:   `src/scripts/schemas/evaluator-output.schema.json`.
+ *
+ * The adapters below are PURE — each maps a verifier's already-captured
+ * `{stdout, stderr, exitCode}` onto the contract shape. That is deliberate and
+ * it is what makes the gate cheap: the mapping is the part that can be wrong,
+ * and it can be tested against recorded fixtures without paying to re-run three
+ * verifiers CI already runs once. Spike s02 established that none of the three
+ * needs a change on its own side for this to work.
+ */
+import { load_schema, validate, type YamlValue } from '../validate_frontmatter.js';
+
+export type MetricState = 'present' | 'absent' | 'unreadable';
+export type Direction = 'maximize' | 'minimize';
+
+export interface EvaluatorOutput {
+    readonly schema_version: 1;
+    readonly name: string;
+    readonly pass: boolean;
+    readonly score: number;
+    readonly metric?: number;
+    readonly metric_state?: MetricState;
+    readonly direction?: Direction;
+    readonly error?: string;
+}
+
+/** What a verifier invocation produced, before any interpretation. */
+export interface RawRun {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number;
+}
+
+export interface EvaluatorAdapter {
+    readonly name: string;
+    /** The verifier this adapter wraps, as its CI-identical script name. */
+    readonly wraps: string;
+    readonly direction: Direction;
+    readonly parse: (raw: RawRun) => EvaluatorOutput;
+}
+
+/**
+ * Read a count off either stream.
+ *
+ * Both streams on purpose: `check_references` writes its count to stderr
+ * (measured, spike s02), and a stdout-only reader returned a null metric beside
+ * `pass: true` — a degraded reading that looked clean. A wrapper reads both; it
+ * still emits its own verdict on stdout alone, per the contract.
+ */
+function readCount(raw: RawRun, re: RegExp): number | null {
+    const m = `${raw.stdout}\n${raw.stderr}`.match(re);
+    if (m === null || m[1] === undefined) return null;
+    const n = Number(m[1]);
+    return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * Fold a possibly-missing count into the three contract fields.
+ *
+ * `expected` says whether this verifier is supposed to have a number at all.
+ * When it is and the number is missing, the result is `unreadable` — never
+ * `absent`, and never a silent zero. That collapse is the exact defect the
+ * `metric_state` field exists to prevent.
+ */
+function withMetric(
+    base: Omit<EvaluatorOutput, 'metric' | 'metric_state' | 'score'>,
+    count: number | null,
+    expected: boolean,
+): EvaluatorOutput {
+    if (count !== null) {
+        return { ...base, metric: count, metric_state: 'present', score: -count };
+    }
+    // `metric` is OMITTED rather than set to null: the subset validator this
+    // estate ships rejects an array-typed `type`, so the schema spells the field
+    // as an optional number. Absence is the null.
+    if (!expected) {
+        return { ...base, metric_state: 'absent', score: base.pass ? 0 : -1 };
+    }
+    return {
+        ...base,
+        metric_state: 'unreadable',
+        score: -1,
+        error: 'expected a count in the verifier output and found none',
+    };
+}
+
+export const EVALUATORS: readonly EvaluatorAdapter[] = [
+    {
+        name: 'validate_frontmatter',
+        wraps: 'validate_frontmatter',
+        direction: 'minimize',
+        parse: (raw) =>
+            withMetric(
+                { schema_version: 1, name: 'validate_frontmatter', pass: raw.exitCode === 0, direction: 'minimize' },
+                // Group 2 is the failing count; group 1 is the corpus size, which
+                // is the denominator and not the thing being minimized.
+                readCount(raw, /\d+\s+artefacts,\s+(\d+)\s+failing/),
+                true,
+            ),
+    },
+    {
+        name: 'lint_output_slop',
+        wraps: 'lint_output_slop',
+        direction: 'minimize',
+        parse: (raw) => {
+            const text = `${raw.stdout}\n${raw.stderr}`;
+            const clean = /clean\s+—\s+no placeholder-prose patterns found/.test(text);
+            const count = clean ? 0 : (text.match(/^\s*\S+:\d+/gm) ?? []).length;
+            return withMetric(
+                { schema_version: 1, name: 'lint_output_slop', pass: raw.exitCode === 0, direction: 'minimize' },
+                count,
+                true,
+            );
+        },
+    },
+    {
+        name: 'check_references',
+        wraps: 'check_references',
+        direction: 'minimize',
+        parse: (raw) => {
+            const text = `${raw.stdout}\n${raw.stderr}`;
+            const scanned = readCount(raw, /scanned:\s*(\d+)/);
+            // A gate that scanned nothing has not measured a clean tree — it has
+            // not measured. Report that as unreadable rather than as zero broken
+            // references, which is the manufactured-green shape this estate names.
+            if (scanned === null || scanned === 0) {
+                return withMetric(
+                    { schema_version: 1, name: 'check_references', pass: raw.exitCode === 0, direction: 'minimize' },
+                    null,
+                    true,
+                );
+            }
+            const clean = /No broken references found/.test(text);
+            return withMetric(
+                { schema_version: 1, name: 'check_references', pass: raw.exitCode === 0, direction: 'minimize' },
+                clean ? 0 : (text.match(/^\s*broken:/gim) ?? []).length || 1,
+                true,
+            );
+        },
+    },
+];
+
+/**
+ * Schema violations for one evaluator output. Empty array = conformant.
+ *
+ * `SchemaError.format()` rather than `String(e)`: the class carries no
+ * `toString`, so stringifying it yields `[object Object]` — a violation list
+ * that names nothing, which is indistinguishable from a broken validator.
+ */
+export function validateEvaluatorOutput(value: unknown): string[] {
+    const schema = load_schema('evaluator-output');
+    return validate(value as YamlValue, schema)
+        .filter((e) => e.severity !== 'warning')
+        .map((e) => e.format());
+}

package/src/scripts/_lib/gate_ledger.ts

@@ -57,7 +57,9 @@ export type GateSkipReason =
     | 'generated_artifact'
     | 'dead_scan_root'
     | 'declared_exemption'
-    | 'not_applicable_kind';
+    | 'not_applicable_kind'
+    | 'precondition_unmet'
+    | 'check_did_not_run';
 
 /**
  * One sentence per skip code, printed verbatim in the ledger's own output.
@@ -79,6 +81,8 @@ export const SKIP_REASON_MESSAGE: Record<GateSkipReason, string> = {
     dead_scan_root: 'the root this target was enumerated from no longer exists',
     declared_exemption: 'the target carries an explicit, reviewable exemption from this check',
     not_applicable_kind: 'the target is a kind of artifact this check does not apply to',
+    precondition_unmet: 'a precondition of this run settled the verdict before the target could be inspected',
+    check_did_not_run: 'the check itself could not be executed, so the target was never read',
 };
 
 /** Terminal outcomes a planned target can reach. Exactly one, exactly once. */