@event4u/agent-config 14.9.0 → 14.11.0

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

@@ -1,8 +1,8 @@
 {
-    "_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.",
+    "_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 — 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": "unrecorded",
     "tokens_exact": true,
-    "unconditional_tokens": 111012,
+    "unconditional_tokens": 113699,
     "scoped_ids": [
         "design-review-after-ui-write",
         "roadmap-progress-sync",
@@ -39,11 +39,15 @@
         },
         {
             "date": "2026-08-20",
-            "reason": "Re-anchored WITH an authorized addition, not to clear a red: the new `recurring-criticism` rule plus the reconciling edits to `self-repair-loop` and `decision-revisit-gate`. The cost is structural, not sloppy authoring \u2014 the rule fires on a recurrence phrase in the USER PROMPT, and on Claude the emitter writes no `paths:` at all once any non-path trigger is present, so a prompt-triggered rule is unconditional by construction. There is no scoped variant of this obligation to choose instead: a path-scoped version would never see the prompt that triggers it, which is the whole mechanism. The body was already cut once for this reason (~45 percent, depth moved to guideline:agent-infra/recurring-criticism-mechanics, which is read on demand and costs nothing at session start); what remains is the Iron Law, the three-outcome table that is the anti-sycophancy guard, and the honest-enforcement paragraph. Trimming further would remove the reasoning the rule itself marks as the clause most likely to be trimmed. Delta 3575 tokens against a 2000 allowance, standing cost per session, stated rather than hidden."
+            "reason": "Re-anchored WITH an authorized addition, not to clear a red: the new `recurring-criticism` rule plus the reconciling edits to `self-repair-loop` and `decision-revisit-gate`. The cost is structural, not sloppy authoring — the rule fires on a recurrence phrase in the USER PROMPT, and on Claude the emitter writes no `paths:` at all once any non-path trigger is present, so a prompt-triggered rule is unconditional by construction. There is no scoped variant of this obligation to choose instead: a path-scoped version would never see the prompt that triggers it, which is the whole mechanism. The body was already cut once for this reason (~45 percent, depth moved to guideline:agent-infra/recurring-criticism-mechanics, which is read on demand and costs nothing at session start); what remains is the Iron Law, the three-outcome table that is the anti-sycophancy guard, and the honest-enforcement paragraph. Trimming further would remove the reasoning the rule itself marks as the clause most likely to be trimmed. Delta 3575 tokens against a 2000 allowance, standing cost per session, stated rather than hidden."
         },
         {
             "date": "2026-08-20",
             "reason": "Raised 103,265 -> 106,386 (+3,121) for one new rule, fix-what-you-see, added on maintainer instruction after a session identified a red check's cause, named the file's author, and handed it back unfixed. The rule permits exactly two dispositions -- fix it, or ship a tracked follow-up roadmap in the same change -- and removes ownership and note-only as escapes from active-remediation's ladder. WHAT THIS RE-ANCHOR EXPOSES, and it is the reason the entry is this long: the rule ships type auto rather than always because check_always_budget has two characters of headroom and its cap may only move down. That switch cleared the always gate and did NOT reduce the cost, because this census counts a rule as standing payload unless it is path-SCOPED, and a red CI check has no file pattern to scope on. So the two gates disagree about what a keyword-triggered rule costs, and the auto downgrade moved the same 3,121 tokens from a budget that refuses them into one that only asks for a sentence. Stated rather than exploited: the honest reading is that this rule costs standing payload whatever its type says, and the always-vs-auto choice bought delivery breadth, not weight."
+        },
+        {
+            "date": "2026-08-23",
+            "reason": "Re-anchored for one new rule, playbook-precedence, which ships with ADR-244's sixth context type and states that a repository's OWN configured playbook outranks a shipped skill for the same task. WHY THE DELTA IS THIS LARGE, stated rather than implied: the rule is 4,398 chars of source, but it declares seven triggers and every one of them is a keyword or phrase, so the emitter writes NO `paths:` block at all and the host loads it in every session -- the same mixed-trigger cost `ui-audit-gate` and `design-review-after-ui-write` each paid before being re-scoped to paths in road-to-mixed-trigger-activation-cost Phase 2. That is the honest reading of this number: it is not the price of the obligation, it is the price of expressing the obligation with keywords. A playbook lives at a known location, so a path-scoped form is available and would return most of these tokens; it is not cut here because the trigger set is the rule author's design decision and re-cutting it inside a merge-queue drain would change routing behaviour nobody reviewed. Recorded as the next candidate for that Phase-2 treatment rather than silently absorbed."
         }
     ]
 }

package/src/config/rule-enforcement-baseline.json

@@ -19,7 +19,6 @@
   "content-quoting-floor.md",
   "copilot-routing.md",
   "cross-source-consistency.md",
-  "decision-revisit-gate.md",
   "delegation-policy.md",
   "design-fidelity.md",
   "devcontainer-routing.md",

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

@@ -1,94 +1,115 @@
 {
-    "_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 \u2014 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": "05eeb5ca3",
-    "tokens_exact": true,
-    "ceilings": {
-        "active-remediation": 1601,
-        "analysis-skill-routing": 76,
-        "architecture": 955,
-        "artifact-drafting-protocol": 680,
-        "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": 2470,
-        "copilot-routing": 128,
-        "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": 2479,
-        "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": 934,
-        "upstream-proposal": 76
+  "_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 \u2014 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": "178b89235",
+  "tokens_exact": true,
+  "ceilings": {
+    "active-remediation": 1601,
+    "analysis-skill-routing": 76,
+    "architecture": 955,
+    "artifact-drafting-protocol": 680,
+    "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": 2470,
+    "copilot-routing": 128,
+    "design-fidelity": 2540,
+    "devcontainer-routing": 128,
+    "docker-commands": 79,
+    "domain-adoption-policy": 497,
+    "framework-neutrality-in-generic-skills": 636,
+    "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": 2479,
+    "rule-type-governance": 87,
+    "skill-improvement-trigger": 81,
+    "skill-quality": 78,
+    "slash-command-routing-policy": 77,
+    "symfony-routing": 129,
+    "ui-audit-gate": 1491,
+    "untrusted-input-defense": 934,
+    "upstream-proposal": 76
+  },
+  "history": [
+    {
+      "date": "2026-08-19",
+      "rule": "roadmap-progress-sync",
+      "from": 1424,
+      "to": 2117,
+      "reason": "Iron Law 3 gained the preservation test that decides WHO resolves a deferred item \u2014 a routing table plus the two council refinements that make it binding (a follow-up naming a roadmap that does not exist yet fails closed to the user; a council resolution is recorded at the item or it did not happen) and the residual limit both authoring seats named. This is obligation surface, not explanation: the table decides a route and the two refinements are the conditions under which the route is legal, so a reader who reaches only the pointer target has already made the decision. It could not move to the pointer target either \u2014 roadmap-progress-mechanics.md sits at the 16,000-char check_depth_budget ceiling in this same change, and pushing prose there reds a count ratchet whose whole job is refusing a fifth over-ceiling file. The section was condensed once before this raise (2201 -> 2117) by turning four prose paragraphs into bullets; further cutting would delete substance, which preservation-guard forbids."
     },
-    "history": [
-        {
-            "date": "2026-08-19",
-            "rule": "roadmap-progress-sync",
-            "from": 1424,
-            "to": 2117,
-            "reason": "Iron Law 3 gained the preservation test that decides WHO resolves a deferred item \u2014 a routing table plus the two council refinements that make it binding (a follow-up naming a roadmap that does not exist yet fails closed to the user; a council resolution is recorded at the item or it did not happen) and the residual limit both authoring seats named. This is obligation surface, not explanation: the table decides a route and the two refinements are the conditions under which the route is legal, so a reader who reaches only the pointer target has already made the decision. It could not move to the pointer target either \u2014 roadmap-progress-mechanics.md sits at the 16,000-char check_depth_budget ceiling in this same change, and pushing prose there reds a count ratchet whose whole job is refusing a fifth over-ceiling file. The section was condensed once before this raise (2201 -> 2117) by turning four prose paragraphs into bullets; further cutting would delete substance, which preservation-guard forbids."
-        },
-        {
-            "date": "2026-08-20",
-            "rule": "context-hygiene",
-            "from": 2447,
-            "to": 2470,
-            "reason": "One sentence, +23 tokens, and it is obligation surface rather than explanation: for CI, do not hand-write the wait loop. The mechanics went to the pointer target where this rule's own migration note already sends them (context-hygiene-mechanics gains the exit codes, the four not-settled states and the measured incident) \u2014 that move is what took the growth from +179 to +23, and the residue is the pointer itself, which cannot live in the guideline because a rule that does not name the helper is a rule nobody follows to it. The incident it encodes: a hand-written `until ! gh pr checks N | grep -q pending` exited when the API failed, because the error text contains no `pending`, and the session reported a settle that had not happened and retracted it in the next reply. The rule's neighbouring waiter law already says one waiter per condition; what it did not say is that the exit condition is the part that gets written wrong, which is why the helper is named here rather than described."
-        },
-        {
-            "date": "2026-08-20",
-            "rule": "roadmap-progress-sync",
-            "from": 2117,
-            "to": 2185,
-            "reason": "One sentence in Iron Law 1, +68 tokens, and it is obligation surface rather than explanation: `roadmap:progress` now passes `--archive`, so the law's operational meaning changed \u2014 a complete roadmap is moved by the same run instead of reported to a human, and the two exclusions a reader must know before trusting that (`--check` never archives, the PostToolUse hook never archives) are exactly the part that cannot be deferred to a pointer. The prose was NOT moved to docs/guidelines/agent-infra/roadmap-progress-mechanics.md, which is where this rule's migration note sends its mechanics, because that file has roughly a hundred characters of headroom under the 16,000-char depth ceiling and check_depth_budget is shrink-only with four files already over it \u2014 a FIFTH over-ceiling file reds, so moving 400 characters there would have traded this gate for that one. The full contract, the council record and its recorded dissent live with the code in src/agent-src/scripts/archival_sweep.ts, which is the third home and the one with room."
-        },
-        {
-            "date": "2026-08-20",
-            "rule": "artifact-drafting-protocol",
-            "from": 611,
-            "to": 680,
-            "reason": "Three lines plus a pointer extension, +69 tokens, for a new contract field that governs what a run may author without asking: an artifact discovered AFTER an accepted execution contract halts by default, and `late_artifacts: auto-research` is the only declared value that continues, capped at three per run. The five-step auto-research procedure, the reasoning for the default and its reversibility argument all went to the pointer target (artifact-drafting-protocol-mechanics gains a Late artifacts section) rather than here, which is what held the growth to a bullet. The residue is obligation surface and cannot live in the guideline: this rule's own batch-mode bullet already tells the reader that a mid-run artifact triggers the full interactive protocol, so a reader who never opens the guideline would conclude that a declared value cannot change it. Named default rather than described behaviour, because the default direction is the decision -- AI council 2/2 (anthropic + openai) chose `halt` over `auto-research` on the autonomy-defaults-sheet fork of road-to-user-out-of-the-loop, record agents/evidence/council/drain-blocker-dispositions-a.md."
-        },
-        {
-            "date": "2026-08-20",
-            "rule": "roadmap-progress-sync",
-            "from": 2185,
-            "to": 2479,
-            "reason": "One subsection, +294 tokens, for the `deferred_policy` contract field: a declared policy removes the synchronous options ROUND at closure without moving any row of the preservation test's routing table. It is obligation surface and it cannot live anywhere else. Not in the pointer target -- roadmap-progress-mechanics.md sits at 16,039 chars against check_depth_budget's 16,000-char ceiling, and that gate is a count ratchet whose next failure is a FIFTH over-ceiling file, so prose pushed there is the one move that turns a warn into a red. Not in the contract context either: Iron Law 3 is the gate being amended, and a reader who learns from roadmap-execution-contract that a field exists but never reads this rule would not know that `cancel-with-memo` still stops for the user. The three-row table is the delta in full; the reasoning, both alternatives and the reversibility argument went to the contract context's own decision comment. Condensed once before this raise (2509 -> 2411) by cutting a paragraph that restated the preservation test. AI council 2/2 (anthropic + openai) on the autonomy-defaults-sheet fork of road-to-user-out-of-the-loop, record agents/evidence/council/drain-blocker-dispositions-a.md. RE-BASED on merge with origin/main, 2026-08-20: this entry was authored against a base of 2117 and raised to 2411. main had independently raised the same ceiling 2117 -> 2185 for its own reason, so the merged tree measures 2479 and the honest arithmetic for THIS raise is 2185 -> 2479 -- the same +294 for the same subsection, re-based rather than re-argued. Recorded rather than silently regenerated because the gate's own failure text names a history-versus-ceilings disagreement as the signature of a hand-edited count, and a merge that quietly adopted one side's numbers would produce exactly that signature with nothing saying why."
-        },
-        {
-            "date": "2026-08-22",
-            "rule": "untrusted-input-defense",
-            "from": 845,
-            "to": 934,
-            "reason": "Six lines, +89 tokens, correcting a claim the section itself had made false. It said no content-scanning backstop existed and that a future one would be the first candidate to change enforced_by; injection_scan_hook.ts now exists, so the first half is false, and the second was always wrong because a warn-only hook cannot refuse and therefore cannot enforce. Every sentence left carries one of those claims. The measurement half -- slot, 15 channels, 99.00 percent recall, 0.85 percent false positives, the manifest keys -- did move to the pointer target, which is what cut the overshoot from +194 to +89; what stays is the rule's own enforcement disclosure, and a stub ceiling that forbids correcting a false statement about the rule's own enforcement is the wrong constraint applied to the right file."
-        }
-    ]
+    {
+      "date": "2026-08-20",
+      "rule": "context-hygiene",
+      "from": 2447,
+      "to": 2470,
+      "reason": "One sentence, +23 tokens, and it is obligation surface rather than explanation: for CI, do not hand-write the wait loop. The mechanics went to the pointer target where this rule's own migration note already sends them (context-hygiene-mechanics gains the exit codes, the four not-settled states and the measured incident) \u2014 that move is what took the growth from +179 to +23, and the residue is the pointer itself, which cannot live in the guideline because a rule that does not name the helper is a rule nobody follows to it. The incident it encodes: a hand-written `until ! gh pr checks N | grep -q pending` exited when the API failed, because the error text contains no `pending`, and the session reported a settle that had not happened and retracted it in the next reply. The rule's neighbouring waiter law already says one waiter per condition; what it did not say is that the exit condition is the part that gets written wrong, which is why the helper is named here rather than described."
+    },
+    {
+      "date": "2026-08-20",
+      "rule": "roadmap-progress-sync",
+      "from": 2117,
+      "to": 2185,
+      "reason": "One sentence in Iron Law 1, +68 tokens, and it is obligation surface rather than explanation: `roadmap:progress` now passes `--archive`, so the law's operational meaning changed \u2014 a complete roadmap is moved by the same run instead of reported to a human, and the two exclusions a reader must know before trusting that (`--check` never archives, the PostToolUse hook never archives) are exactly the part that cannot be deferred to a pointer. The prose was NOT moved to docs/guidelines/agent-infra/roadmap-progress-mechanics.md, which is where this rule's migration note sends its mechanics, because that file has roughly a hundred characters of headroom under the 16,000-char depth ceiling and check_depth_budget is shrink-only with four files already over it \u2014 a FIFTH over-ceiling file reds, so moving 400 characters there would have traded this gate for that one. The full contract, the council record and its recorded dissent live with the code in src/agent-src/scripts/archival_sweep.ts, which is the third home and the one with room."
+    },
+    {
+      "date": "2026-08-20",
+      "rule": "artifact-drafting-protocol",
+      "from": 611,
+      "to": 680,
+      "reason": "Three lines plus a pointer extension, +69 tokens, for a new contract field that governs what a run may author without asking: an artifact discovered AFTER an accepted execution contract halts by default, and `late_artifacts: auto-research` is the only declared value that continues, capped at three per run. The five-step auto-research procedure, the reasoning for the default and its reversibility argument all went to the pointer target (artifact-drafting-protocol-mechanics gains a Late artifacts section) rather than here, which is what held the growth to a bullet. The residue is obligation surface and cannot live in the guideline: this rule's own batch-mode bullet already tells the reader that a mid-run artifact triggers the full interactive protocol, so a reader who never opens the guideline would conclude that a declared value cannot change it. Named default rather than described behaviour, because the default direction is the decision -- AI council 2/2 (anthropic + openai) chose `halt` over `auto-research` on the autonomy-defaults-sheet fork of road-to-user-out-of-the-loop, record agents/evidence/council/drain-blocker-dispositions-a.md."
+    },
+    {
+      "date": "2026-08-20",
+      "rule": "roadmap-progress-sync",
+      "from": 2185,
+      "to": 2479,
+      "reason": "One subsection, +294 tokens, for the `deferred_policy` contract field: a declared policy removes the synchronous options ROUND at closure without moving any row of the preservation test's routing table. It is obligation surface and it cannot live anywhere else. Not in the pointer target -- roadmap-progress-mechanics.md sits at 16,039 chars against check_depth_budget's 16,000-char ceiling, and that gate is a count ratchet whose next failure is a FIFTH over-ceiling file, so prose pushed there is the one move that turns a warn into a red. Not in the contract context either: Iron Law 3 is the gate being amended, and a reader who learns from roadmap-execution-contract that a field exists but never reads this rule would not know that `cancel-with-memo` still stops for the user. The three-row table is the delta in full; the reasoning, both alternatives and the reversibility argument went to the contract context's own decision comment. Condensed once before this raise (2509 -> 2411) by cutting a paragraph that restated the preservation test. AI council 2/2 (anthropic + openai) on the autonomy-defaults-sheet fork of road-to-user-out-of-the-loop, record agents/evidence/council/drain-blocker-dispositions-a.md. RE-BASED on merge with origin/main, 2026-08-20: this entry was authored against a base of 2117 and raised to 2411. main had independently raised the same ceiling 2117 -> 2185 for its own reason, so the merged tree measures 2479 and the honest arithmetic for THIS raise is 2185 -> 2479 -- the same +294 for the same subsection, re-based rather than re-argued. Recorded rather than silently regenerated because the gate's own failure text names a history-versus-ceilings disagreement as the signature of a hand-edited count, and a merge that quietly adopted one side's numbers would produce exactly that signature with nothing saying why."
+    },
+    {
+      "date": "2026-08-22",
+      "rule": "untrusted-input-defense",
+      "from": 845,
+      "to": 934,
+      "reason": "Six lines, +89 tokens, correcting a claim the section itself had made false. It said no content-scanning backstop existed and that a future one would be the first candidate to change enforced_by; injection_scan_hook.ts now exists, so the first half is false, and the second was always wrong because a warn-only hook cannot refuse and therefore cannot enforce. Every sentence left carries one of those claims. The measurement half -- slot, 15 channels, 99.00 percent recall, 0.85 percent false positives, the manifest keys -- did move to the pointer target, which is what cut the overshoot from +194 to +89; what stays is the rule's own enforcement disclosure, and a stub ceiling that forbids correcting a false statement about the rule's own enforcement is the wrong constraint applied to the right file."
+    },
+    {
+      "date": "2026-08-23",
+      "rule": "design-fidelity",
+      "from": 2245,
+      "to": 2540,
+      "reason": "One subsection, +295 tokens, for the second axis: artefact MATURITY is a property of the handed-over artefact, instruction MANDATE is a property of the prose, and `strict` on a self-declared wireframe is a structure mandate rather than a pixel mandate. It is an Iron Law plus the two discriminator clauses that decide it -- obligation surface, which this repository's rule/mechanics split puts in the rule by construction. The lookup half ALREADY went to the pointer target in the same change: the maturity-to-spec table and the pinned `daf-wireframe-near-miss` row live in design-fidelity-mechanics.md \u00a7 Artefact maturity, and the rule links them. Pushing the remaining prose there too is the one move that is not available -- that migration is exactly what took the mechanics file from 15,265 to 16,524 chars past check_depth_budget's 16,000 ceiling, and paying for it required splitting the asset & imagery block out into its own guideline in this same commit series. A second push would re-red the ratchet the split just cleared. Raised rather than condensed because the two clauses that would compress are the ones that carry the decision: 'the discriminator reads the ARTEFACT, never the prose' and 'an undeclared artefact is treated as finished' -- drop either and the rule authorises the redesign it exists to prevent."
+    },
+    {
+      "date": "2026-08-23",
+      "rule": "ui-audit-gate",
+      "from": 1280,
+      "to": 1491,
+      "reason": "road-to-frontend-power E2.2 moved this rule's `enforced_by:` from `none` to `hook:design-pass`, because `agent-config ui:audit` now writes the artefact the rule previously had nothing to point at. +127 tokens, and every one of them is the SCOPE of that change rather than a description of the mechanism: the check is FRESHNESS not existence (a stale artefact looks like evidence, which is worse than a missing one), the carrier is default-OFF and warns before it blocks, and the greenfield asymmetry is NOT closed -- `_lib/ui_surface.ts` is a path predicate, measured recall 20/23 with all three misses being a UI request that has produced no UI file yet, so this gate cannot fire on the first write of a new surface. Condensed first, from +279 to +127, by cutting the narrative framing and the changed-in-both-directions paragraph. The three limits are what remains and they are the reason the raise is legitimate: a rule that newly claims a carrier and does not state where the carrier stops is a stronger claim than the tree supports, which is the exact over-claim this repository has already had to correct twice in the hook-architecture host table. Not pushed to the pointer target: `existing-ui-audit` is a SKILL describing how to run an audit, and the boundary of a gate's enforcement is an obligation-surface fact -- putting it there would file the limit where nobody reading the gate will find it. Amended in the same change, 1407 -> 1491 (+84): landing the carrier revealed that `design-pass-stop` is `severity: advisory` and the dispatcher enforces advisory as a CEILING, so an EXIT_BLOCK from it is downgraded and then mapped to exit 0. Claiming a block in this rule while the transport discards it would be the inert-refusal defect `run-continuation` already recorded once. Limit 2 therefore states what actually happens -- the stop verdict is REPORTED as would-block, not enforced -- and names what would make it real: an entry in concern_severity.test.ts's BLOCKING_ALLOWLIST, which that file calls a security-relevant decision and which would be the third turn-END refusal in the tree. That is a stronger reason to spend the tokens than the original raise had: a rule whose enforced_by names a carrier, and which does not say the carrier cannot refuse, is the over-claim this whole section exists to prevent."
+    },
+    {
+      "date": "2026-08-23",
+      "rule": "framework-neutrality-in-generic-skills",
+      "from": 621,
+      "to": 636,
+      "reason": "Two entries on the exempt list, +15 tokens: `^monorepo-workspace$` and `^workspace-link$`, the two skills road-to-monorepo-scope-and-detection adds. The list is not lookup material and cannot go to the pointer target: it is the rule's own ACTIVATION condition -- the gate decides from it whether an artefact is generic at all, so a rule whose exempt list lives elsewhere cannot answer its own first question. Every prior addition to that list moved this number for the same reason, and the alternative the gate offers (move prose to the pointer target) has nothing to move here: the two entries ARE the change. Raised rather than condensed because 15 tokens of pattern cannot be condensed without deleting one of the two patterns, which would make a framework-specific skill fail a rule it is exempt from."
+    }
+  ]
 }

package/src/scripts/_cli/cmd_doctor.ts

@@ -82,6 +82,13 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import * as YAML from 'yaml';
 
+import { _check_overrides } from './doctor_overrides.js';
+import { _is_global_only_consumer } from './doctor_install_mode.js';
+// Forwarded, not re-declared: both names moved to doctor_install_mode.ts and existing
+// importers of cmd_doctor.js keep resolving. `export ... from` rather than an import,
+// because INSTALL_MODE_MARKER_RELATIVE is not referenced here any more and an unused
+// import would be dropped — silently breaking whoever imports it from this path.
+export { INSTALL_MODE_MARKER_RELATIVE, _is_global_only_consumer } from './doctor_install_mode.js';
 import * as claude_plugin from '../_lib/claude_plugin.js';
 import * as claude_settings_hooks from '../_lib/claude_settings_hooks.js';
 import { _is_source_repo } from './cmd_refresh.js';
@@ -765,6 +772,7 @@ const CHECK_IDS = [
     'surface-state',
     'hook-wiring',
     'stale-orphans',
+    'overrides',
     'rule-scope-drift',
     'manifest-integrity',
     'lockfile-freshness',
@@ -795,6 +803,7 @@ const GLOBAL_CHECK_IDS: ReadonlySet<string> = new Set([
     'surface-state',
     'hook-wiring',
     'stale-orphans',
+    'overrides',
     'rule-scope-drift',
     'mcp-mode',
     'mcp-beta-readiness',
@@ -818,20 +827,6 @@ const MANIFEST_REQUIRED_CHECK_IDS: ReadonlySet<string> = new Set([
     'unsupported-combos',
 ]);
 
-/**
- * Signals a set-up global-only consumer. The `.event4u-bridge.yml` marker was
- * retired (ADR-020 amendment 2026-07-13); the durable project-side signal is
- * the install-mode marker (written on every install) or the `agents/overrides/`
- * scaffold. Either is sufficient.
- */
-const INSTALL_MODE_MARKER_RELATIVE = 'agents/.agent-state/install-mode.txt';
-
-function _is_global_only_consumer(project_root: string): boolean {
-    return (
-        isFile(path.join(project_root, INSTALL_MODE_MARKER_RELATIVE)) ||
-        isDir(path.join(project_root, 'agents', 'overrides'))
-    );
-}
 
 /** Repair targets that `--repair <id>` accepts. */
 const REPAIR_IDS = ['wizard-state'] as const;
@@ -2976,6 +2971,7 @@ function _run_checks(
         'surface-state': _check_surface_state,
         'hook-wiring': _check_hook_wiring,
         'stale-orphans': _check_stale_orphans,
+        overrides: () => _check_overrides(project_root),
         'rule-scope-drift': () => _check_rule_scope_drift(project_root),
         'manifest-integrity': () => _check_manifest_integrity(manifest),
         'lockfile-freshness': () => _check_lockfile_freshness(manifest),
@@ -3059,6 +3055,11 @@ function _run_checks_no_manifest(
         'surface-state': _check_surface_state,
         'hook-wiring': _check_hook_wiring,
         'stale-orphans': _check_stale_orphans,
+        // BOTH registries need the id. Registering only the first one crashed with
+        // `runners[cid] is not a function` on a global-only consumer, which is the
+        // path that has no manifest — a loud failure rather than a silent skip, and
+        // worth the comment because the duplication is easy to miss.
+        overrides: () => _check_overrides(project_root),
         'rule-scope-drift': () => _check_rule_scope_drift(project_root),
         'manifest-integrity': () => _skipped_manifest_check('manifest-integrity'),
         'lockfile-freshness': () => _skipped_manifest_check('lockfile-freshness'),
@@ -3710,8 +3711,6 @@ export {
     CHECK_IDS,
     GLOBAL_CHECK_IDS,
     MANIFEST_REQUIRED_CHECK_IDS,
-    INSTALL_MODE_MARKER_RELATIVE,
-    _is_global_only_consumer,
     REPAIR_IDS,
     MCP_BETA_GATES,
     STATUS_SYMBOLS,

package/src/scripts/_cli/doctor_install_mode.ts

@@ -0,0 +1,49 @@
+/**
+ * Install-mode detection, extracted from `cmd_doctor.ts`.
+ *
+ * A PURE MOVE, and the reason is arithmetic. `cmd_doctor.ts` sits ~2,200 lines above the
+ * 1,500-line ceiling, so `check_source_size_budget` refuses ANY net growth in it: the
+ * override-delivery check cost 128 lines, extracting that check into
+ * `doctor_overrides.ts` paid 119, and this pays the residual 9.
+ *
+ * Extracting a NEIGHBOUR rather than shaving the new feature is deliberate. The
+ * alternative was compressing the new check's comments until the number fit, which buys
+ * the same green from worse code. A file under the ceiling contributes zero excess, so
+ * the total falls by exactly what leaves.
+ *
+ * It is also a genuinely separate concern: "which install shape is this project in" is
+ * asked before any check runs, and it reads markers rather than performing a check.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+function isFile(p: string): boolean {
+    try {
+        return fs.statSync(p).isFile();
+    } catch {
+        return false;
+    }
+}
+
+function isDir(p: string): boolean {
+    try {
+        return fs.statSync(p).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Signals a set-up global-only consumer. The `.event4u-bridge.yml` marker was
+ * retired (ADR-020 amendment 2026-07-13); the durable project-side signal is
+ * the install-mode marker (written on every install) or the `agents/overrides/`
+ * scaffold. Either is sufficient.
+ */
+export const INSTALL_MODE_MARKER_RELATIVE = 'agents/.agent-state/install-mode.txt';
+
+export function _is_global_only_consumer(project_root: string): boolean {
+    return (
+        isFile(path.join(project_root, INSTALL_MODE_MARKER_RELATIVE)) ||
+        isDir(path.join(project_root, 'agents', 'overrides'))
+    );
+}

package/src/scripts/_cli/doctor_overrides.ts

@@ -0,0 +1,154 @@
+/**
+ * The doctor's override-delivery check, extracted from `cmd_doctor.ts`.
+ *
+ * Extracted rather than inlined because `cmd_doctor.ts` sits at 3,852 lines against
+ * the 1,500-line ceiling, so `check_source_size_budget` refuses ANY net growth in it
+ * — the same ratchet that refused two earlier attempts at an unrelated feature. The
+ * check landed inline first and the gate said so (128 new violations); this file is
+ * the fix, and it is a pure move. A new file under the ceiling contributes zero
+ * excess, so the total falls by exactly what left.
+ *
+ * Kept as its own module rather than folded into a grab-bag of checks: it is the only
+ * consumer of `KERNEL_RULE_ID_SET` in the doctor, and that import came with it.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { KERNEL_RULE_ID_SET } from '../_lib/kernel_rules.js';
+
+type Dict = Record<string, unknown>;
+
+function isDir(p: string): boolean {
+    try {
+        return fs.statSync(p).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+function isFile(p: string): boolean {
+    try {
+        return fs.statSync(p).isFile();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Override DELIVERY and audit state — steps 3.1 and 3.2 of
+ * `road-to-override-efficacy-proof`.
+ *
+ * The report already knew `agents/overrides/` existed, as an install-mode marker
+ * (`_is_global_only_consumer`). It never said what was IN it, so a consumer who
+ * placed an override had no surface anywhere that confirmed the file was seen.
+ *
+ * THE VOCABULARY IS THE CONTRACT, and step 3.2 makes it a checkable one. This line
+ * says `present`, `registered`, `cited` — never `enforced`, `applied`, `honoured`
+ * or `honored`. Those four words would make it read as a claim that the agent
+ * changed its behaviour, which is Phase 2's number and is deferred on population
+ * validity. A delivery check quoted as an efficacy claim is the exact defect this
+ * roadmap exists to close, so the words it must not use are asserted against by
+ * `agent-config doctor 2>&1 | grep -iE 'override.*(enforced|applied|honoured|honored)'`
+ * returning nothing.
+ *
+ * `warn` rather than `error` on an uncited or unregistered override: the strict
+ * gate (`lint_override_kernel_guard --strict`) is what refuses those in CI. Two
+ * surfaces failing the same fact would make `doctor` a second gate with no
+ * authority, and the doctor's job is to tell a consumer what state they are in.
+ */
+export function _check_overrides(project_root: string): Dict {
+    const dir = path.join(project_root, 'agents', 'overrides', 'rules');
+    if (!isDir(dir)) {
+        return {
+            id: 'overrides',
+            status: 'skip',
+            message: 'no agents/overrides/rules/ — no overrides declared',
+            remedy: '',
+        };
+    }
+    let names: string[];
+    try {
+        names = fs
+            .readdirSync(dir)
+            .filter((n) => n.endsWith('.md'))
+            .sort();
+    } catch {
+        return {
+            id: 'overrides',
+            status: 'warn',
+            message: 'agents/overrides/rules/ is present but unreadable',
+            remedy: 'check permissions on agents/overrides/rules/',
+        };
+    }
+    if (names.length === 0) {
+        return {
+            id: 'overrides',
+            status: 'ok',
+            message: 'agents/overrides/rules/ present, 0 overrides declared',
+            remedy: '',
+        };
+    }
+    const registryPath = path.join(project_root, 'agents', 'overrides', 'kernel-exceptions.yml');
+    // Parse the `exceptions:` block the same way the audit does, rather than
+    // grepping for the rule name anywhere in the file. The first version did grep,
+    // and it read `verify-before-complete` as UNREGISTERED even though the registry
+    // lists it — the name appears inside a `justification:` block and the entry key
+    // is `rule:`, so a bare name match neither confirms nor denies registration. A
+    // doctor line that contradicts the strict gate is worse than no line.
+    const registered = new Set<string>();
+    if (isFile(registryPath)) {
+        let inExceptions = false;
+        for (const raw of fs.readFileSync(registryPath, 'utf-8').split('\n')) {
+            const line = raw.replace(/\s+$/, '');
+            if (/^exceptions:\s*$/.test(line)) {
+                inExceptions = true;
+                continue;
+            }
+            if (!inExceptions) continue;
+            if (/^\S/.test(line)) break;
+            const m = /^\s*-?\s*rule:\s*"?([a-z0-9-]+)"?\s*$/i.exec(line);
+            if (m?.[1] !== undefined) registered.add(m[1]);
+        }
+    }
+    let kernel = 0;
+    let uncited = 0;
+    let unregisteredKernel = 0;
+    for (const n of names) {
+        const rule = n.replace(/\.md$/, '');
+        const isKernel = KERNEL_RULE_ID_SET.has(rule);
+        if (isKernel) kernel += 1;
+        const text = fs.readFileSync(path.join(dir, n), 'utf-8');
+        // Same shape the audit's `has_citation` looks for. Duplicated rather than
+        // imported because cmd_doctor must not pull a lint module into the CLI's
+        // startup path; the strict gate owns the authoritative check and this is a
+        // report.
+        if (!/^>\s*Overrides:/m.test(text)) uncited += 1;
+        if (isKernel && !registered.has(rule)) {
+            unregisteredKernel += 1;
+        }
+    }
+    const parts = [
+        `${String(names.length)} override(s) present`,
+        `${String(kernel)} kernel`,
+    ];
+    // Registration is stated POSITIVELY, not only on failure. Step 3.1's verify
+    // names four words the line must carry — one override, kernel, registered,
+    // cited — and a count that appears only when it is wrong leaves a reader
+    // unable to tell "all registered" from "registration not checked".
+    if (kernel > 0) {
+        parts.push(`${String(kernel - unregisteredKernel)}/${String(kernel)} kernel registered`);
+    }
+    parts.push(`${String(names.length - uncited)}/${String(names.length)} cited`);
+    // Deliberately last and deliberately blunt: without it the counts read as a
+    // verdict on whether the overrides work.
+    parts.push('delivery only — efficacy unmeasured');
+    return {
+        id: 'overrides',
+        status: uncited > 0 || unregisteredKernel > 0 ? 'warn' : 'ok',
+        message: parts.join(', '),
+        remedy:
+            uncited > 0 || unregisteredKernel > 0
+                ? 'run `./scripts-run src/scripts/lint_override_kernel_guard --strict` for the detail'
+                : '',
+    };
+}

package/src/scripts/_dispatch.bash

@@ -71,6 +71,10 @@ TS-shell native (run via the installed `agent-config` binary):
   config                     Open the configuration GUI (global default; --project for the project surface)
   settings                   Open the local Settings GUI (alias of config)
   ui:serve                   Start the local UI server (127.0.0.1, auto-picked port)
+  ui:audit [path]            Inventory a UI tree into agents/runtime/state/ui-audit.json
+                             (Class A). The artefact ui-audit-gate reads.
+  ui:render <path|url>       Headless capture at desktop / 375px / 320px into
+                             agents/runtime/state/render/ (Class A; no process survives).
   workspaces ls              List workspaces from the discovery manifest
   packs ls                   List packs from the discovery manifest
   brand:status               Is a consumer brand layer present, and at which of the
@@ -224,6 +228,10 @@ Tier 2 — maintenance / internal (hooks, MCP, memory, telemetry):
   session:recycle            Validate + write the main-session recycle envelope (--verify validates only)
                              (deliberate recycle instead of auto-compact). Flags:
                              --file <json> | --template; default reads stdin
+  roadmap:context            One live situational-awareness probe: open PRs and the
+                             files they change, remote branches carrying a roadmap
+                             slug, live sessions, agents/tmp/ note NAMES, and sibling
+                             roadmaps on the same topic. --roadmap <slug>, --json
   roadmap:progress           Regenerate agents/roadmaps-progress.md from open roadmaps
                              (archives completed roadmaps; --no-archive to skip)
   roadmap:progress-check     Fail if agents/roadmaps-progress.md is stale (for CI)
@@ -693,6 +701,14 @@ cmd_mcp_run() {
 # PACKAGE_ROOT, not the consumer projection: the CLI imports the register library
 # under src/scripts/_lib/, which is package-internal and never shipped into
 # dist/agent-src/scripts/. Same shape as cmd_settings_set.
+# Situational-awareness probe (road-to-roadmap-situational-awareness Phase 1).
+# PACKAGE_ROOT, not the consumer projection: it imports src/scripts/_lib/, which
+# is package-internal and never shipped into dist/agent-src/scripts/. Same shape
+# as cmd_sessions_list below, and for the same reason.
+cmd_roadmap_context() {
+  exec_ts "$PACKAGE_ROOT/src/scripts/roadmap_context.ts" "$@"
+}
+
 cmd_sessions_list() {
   exec_ts "$PACKAGE_ROOT/src/scripts/sessions_cli.ts" list "$@"
 }
@@ -1461,6 +1477,7 @@ main() {
     settings:get)            cmd_settings_get "$@" ;;
     mcp:available)           cmd_mcp_available "$@" ;;
     brand:status)            cmd_brand_status "$@" ;;
+    roadmap:context)         cmd_roadmap_context "$@" ;;
     roadmap:progress)        cmd_roadmap_progress "$@" ;;
     roadmap:progress-check)  cmd_roadmap_progress_check "$@" ;;
     roadmap:archive)         cmd_roadmap_archive "$@" ;;