@event4u/agent-config 11.0.0 → 12.1.0

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

@@ -347,6 +347,24 @@ interface Blocker {
     blocks: string;
     todo: string[];
     resolvedWhen: string;
+    /**
+     * The two fields that make a blocker *decidable* rather than merely
+     * described. Empty string when the entry predates them — the ratchet in
+     * `lint_roadmap_blockers` keeps the backlog legal, so the renderer has to
+     * cope with absence rather than assume it away.
+     */
+    recommendation: string;
+    ifNothing: string;
+    /**
+     * Optional one-line statement of what is actually being decided.
+     *
+     * Not required, but recognised: three entries in the tree already used
+     * `- **Question:**` and, because the field list did not know it, the
+     * continuation logic silently appended it to `Blocks` — the decision's
+     * subject arrived glued to the end of an unrelated sentence. Naming it
+     * costs one enum entry and turns a silent swallow into a rendered field.
+     */
+    question: string;
 }
 
 // Strip fenced code blocks before blocker detection — a roadmap that shows the
@@ -362,7 +380,8 @@ function _stripFencedCode(text: string): string {
     return text.replace(FENCED_CODE_RE, (m) => '\n'.repeat(_splitlines(m).length));
 }
 
-const BLOCKER_FIELD_RE = /^-[ \t]*\*\*(Status|Owner|Blocks|Resolved when|What to do):\*\*/i;
+const BLOCKER_FIELD_RE =
+    /^-[ \t]*\*\*(Status|Owner|Blocks|Resolved when|What to do|Recommendation|If you do nothing|Question):\*\*/i;
 
 /** Strip an inline `<!-- comment -->` and trim. */
 function _stripComment(s: string): string {
@@ -471,6 +490,9 @@ function parse_blockers(raw_text: string): Blocker[] {
                 blocks: _blockerField(body, 'Blocks') ?? '(unspecified)',
                 todo: _blockerTodo(body),
                 resolvedWhen: _blockerField(body, 'Resolved when') ?? '(unspecified)',
+                recommendation: _blockerField(body, 'Recommendation') ?? '',
+                ifNothing: _blockerField(body, 'If you do nothing') ?? '',
+                question: _blockerField(body, 'Question') ?? '',
             });
         }
     }
@@ -502,6 +524,9 @@ function parse_blockers(raw_text: string): Blocker[] {
             blocks: 'entire roadmap',
             todo: [parts.join(' ')],
             resolvedWhen: 'condition described above clears',
+            recommendation: '',
+            ifNothing: '',
+            question: '',
         });
     }
     return blockers;
@@ -869,6 +894,12 @@ function render(roadmaps: RoadmapStats[], bundles: Bundle[] | null = null): stri
             lines.push('**Blockers**\n');
             for (const b of openBlockers) {
                 lines.push(`- **${b.id}** (owner: ${b.owner}) — blocks ${b.blocks}`);
+                if (b.recommendation) {
+                    lines.push(`  - **Recommendation:** ${b.recommendation}`);
+                }
+                if (b.ifNothing) {
+                    lines.push(`  - **If you do nothing:** ${b.ifNothing}`);
+                }
                 lines.push('  - **What to do:**');
                 for (const step of b.todo) {
                     lines.push(`    ${step}`);

package/src/config/agent-settings.template.yml

@@ -133,6 +133,40 @@ projection:
 # (vendor-granular unknown_defaults in src/config/host-capabilities.yml).
 discipline_profile: __DISCIPLINE_PROFILE__
 
+# OPT-IN PRESET — the measured-lift configuration, shown but NOT shipped.
+#
+# The evidence above says `essential` carries the significant discipline lift
+# (+0.458, p=0.0135) while `full`'s residual over it is not significant
+# (p=0.37). That reads like an argument to flip the shipped default. It is not,
+# for two independent reasons, and both are worth stating where the key lives
+# rather than in a roadmap nobody reads at install time.
+#
+#   1. This key family is marked "do not set this from automation". That reads
+#      as ABSOLUTE — it forbids an automated CHOICE of default for the family,
+#      not merely a script rewriting your file. No measurement, however clean,
+#      licenses an agent to flip it on your behalf.
+#   2. The flip was pre-registered against a fresh-install census of
+#      <= 30k tokens of always-on rule prose. Measured at audit time: ~163k as
+#      loaded, i.e. 5.4x the target. The criterion fails on its own terms
+#      regardless of point 1.
+#
+# So the better-evidenced value is carried here as a visible option you may
+# uncomment, with its cost stated inline. Uncomment the line below to replace
+# the resolved value above:
+#
+#   discipline_profile: essential      # ~3.3x kernel tokens (vs ~11.7x for full)
+#
+# Read the two factors as what they are: multiples of the kernel-only baseline
+# from the cost-factor sweep, NOT the fresh-install census. They answer "what
+# does this tier cost relative to `off`", never "does this tier reach 30k" —
+# nothing has measured the latter for `essential`, and this comment does not
+# claim it does.
+#
+# Recorded 2026-08-14 on an outside opinion (1 seat, 2 rounds; the second seat
+# failed to start, so a single-model judgement on its checkable merit and NOT a
+# convergence). It rejected both the flip and the do-nothing, and proposed this
+# third route: you see the option, nothing automated chose for you.
+
 # --- Cost profile (legacy knob — superseded by discipline_profile above) ---
 #
 # Master switch that controls which rule tiers load each session.

package/src/config/evaluator-budgets.json

@@ -58,11 +58,11 @@
       "deterministic": false
     },
     "cli_help_command_count": {
-      "max": 97,
-      "last_measured": 97,
-      "last_measured_at": "2026-08-10",
+      "max": 98,
+      "last_measured": 98,
+      "last_measured_at": "2026-08-15",
       "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."
+      "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."
     },
     "mcp_public_tool_count": {
       "max": 19,

package/src/config/gate-coverage.yml

@@ -42,18 +42,19 @@
 #
 # COVERAGE — THE HONEST DENOMINATOR (re-measured 2026-08-13)
 # ----------------------------------------------------------
-# 257 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
+# 259 `lint_*` / `check_*` / `audit_*` scripts live under `src/scripts/`
 # (the count is computed, not asserted — `check_gate_coverage.count_gate_scripts`).
-# **35 of them emit the machine-readable `scanned: <N>` line under their
-# CI-identical argv, and all 35 are listed below.** The manifest is therefore
+# **36 of them emit the machine-readable `scanned: <N>` line under their
+# CI-identical argv, and all 36 are listed below.** The manifest is therefore
 # complete with respect to its own contract, and covers ~14 % of the population.
 # (The 2026-08-05 reading said "32 … and all 31 are listed"; the 2026-08-10
-# reading said "33 … and all 33" while 34 entries were listed. Both halves are
-# RECOUNTED here: 257 is what `count_gate_scripts()` returns on the tree that
-# carries this change, and 35 is the entries counted directly. It read 255 while
-# this change was being written and 257 after `main` merged in two further gate
-# scripts — re-measured at the merge rather than left at the earlier reading,
-# which is the same discipline the note below records failing.)
+# reading said "33 … and all 33" while 34 entries were listed; the 2026-08-13
+# reading said "257 … 35 of them" and both halves were correct at the time.
+# Both halves are RECOUNTED here on 2026-08-15: 259 is what
+# `count_gate_scripts()` returns on the tree that carries this change — the
+# reading was 258 with `lint_scheduled_deprecations` absent — and 36 is
+# `grep -c '^  - id:'` on this file. Neither number was derived by adding one to
+# the previous prose, which is the move the note below forbids.)
 #
 # A 2026-08-13 revision of this paragraph first wrote 256, derived as "255 before
 # this change plus the one it adds" — inside the sentence claiming to have
@@ -769,3 +770,32 @@ gates:
       The canary plants a manifest whose declared CSV does not exist — the exact
       gap `corpus-grounding/scripts/schema_validator.ts` leaves open, since it
       computes the path and never opens the file.
+
+  - id: lint_scheduled_deprecations
+    argv: ["--quiet"]
+    min_scanned: 1
+    corpus: "rows of the `docs/MIGRATION.md` scheduled-deprecations table (3 at baseline)"
+    status: enforced
+    note: >
+      `argv` carries `--quiet` because that is what the task passes: the
+      Taskfile resolves `{{.QUIET_FLAG}}` to `--quiet` unless
+      AGENT_SCRIPT_VERBOSITY=verbose, and the consistency workflow goes through
+      the same task. It passed as a bare call only because `reportScanned` is
+      not quiet-gated while this gate's success line and ledger report are — a
+      coincidence, not the contract rule 2 states.
+      The floor is 1, not "a floor comfortably below the corpus", and the reason
+      is worth stating rather than hiding: the corpus is three rows, so no floor
+      exists that is both below it and far above a collapse. What the floor
+      actually buys here is the contract that the count is PUBLISHED; the
+      collapse case — a drifted heading or a reformatted table parsing to zero
+      rows — is caught one layer up by the gate's own `reportScanned`
+      assertion, which reds instead of printing a green line over nothing.
+      That case is the gate's own subject, so it is pinned by a test fixture
+      too (`a table that parses to zero rows reds rather than exiting green`).
+      No `canary:` recipe: this gate's only violation shape is a MODIFICATION of
+      a tracked artefact (`docs/MIGRATION.md`), and the canary contract is
+      create-only, so it reports UNPROVEN rather than green. Discrimination is
+      proven instead by paired fixtures in
+      `tests/scripts/lint_scheduled_deprecations.test.ts`, verified by mutation:
+      widening the overdue threshold fails the overdue-by-construction case, and
+      granting `allowEmpty` fails the zero-row case.

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

@@ -8,9 +8,9 @@
       "falsifier": "./scripts-run src/scripts/check_ci_local_parity"
     },
     "check_no_new_legacy_path:hardcoded-scan-roots": {
-      "count": 48,
-      "landed": "2026-08-09",
-      "note": "Lines under src/scripts/**/*.{ts,mts,mjs} that pass the retired `.agent-src.uncondensed` directory into `path.join(...)` — a filesystem path CONSTRUCTED against the tree ADR-051 abandoned, which is the exact shape of all 14 dead gates. Deliberately narrow so the number is signal, not noise: 236 raw mentions under src/scripts → 147 string-literal lines → 67 path-constructing lines when the pass was written, after exempting src/scripts/_lib/agent_src.ts (the shared resolver, whose job IS owning the constant — gates that route through it survived the move). Detectors holding the literal as data to match, strip, or print are not counted, and no prose, docs, tests or fixtures are read: that full-tree shape was measured at 44 files / 213 hits and rejected as the wrong lint (see the note in check_no_new_legacy_path.ts::find_offenders). Recorded at 58 rather than 67 because Phase 1's scan-root repairs were landing on this branch while the pass was being written and had already removed 9 — a baseline above the truth silently permits new violations. This count goes to ZERO as the remaining repairs land; every repair is a lowering commit. Lowered 56→51 by the road-to-renewal-foundation Phase 1 dead-root sweep (check_always_budget, check_portability, check_references, lint_framework_leakage, lint_agents_md). Lowered 51→49 by the gate-hardening adoption PR: skill_collision_clusters and skill_overlap were repointed at the live skills tree via the shared resolver — two gates that had been reading the retired container and scoring 0 of 288 skills. Lowered 49→48 by road-to-rule-delivery-integrity P2.2: score_skill_selection was repointed at the live skills tree via the shared resolver. It is the same shape as the two gates lowered before it — a scorer reading the retired container and scoring 0 of 288 skills — and here the consequence was sharper than a dead gate: the roadmap's pre-registered selection-accuracy criteria would have been compared against a baseline of silent zeros."
+      "count": 47,
+      "landed": "2026-08-13",
+      "note": "Lines under src/scripts/**/*.{ts,mts,mjs} that pass the retired `.agent-src.uncondensed` directory into `path.join(...)` — a filesystem path CONSTRUCTED against the tree ADR-051 abandoned, which is the exact shape of all 14 dead gates. Deliberately narrow so the number is signal, not noise: 236 raw mentions under src/scripts → 147 string-literal lines → 67 path-constructing lines when the pass was written, after exempting src/scripts/_lib/agent_src.ts (the shared resolver, whose job IS owning the constant — gates that route through it survived the move). Detectors holding the literal as data to match, strip, or print are not counted, and no prose, docs, tests or fixtures are read: that full-tree shape was measured at 44 files / 213 hits and rejected as the wrong lint (see the note in check_no_new_legacy_path.ts::find_offenders). Recorded at 58 rather than 67 because Phase 1's scan-root repairs were landing on this branch while the pass was being written and had already removed 9 — a baseline above the truth silently permits new violations. This count goes to ZERO as the remaining repairs land; every repair is a lowering commit. Lowered 56→51 by the road-to-renewal-foundation Phase 1 dead-root sweep (check_always_budget, check_portability, check_references, lint_framework_leakage, lint_agents_md). Lowered 51→49 by the gate-hardening adoption PR: skill_collision_clusters and skill_overlap were repointed at the live skills tree via the shared resolver — two gates that had been reading the retired container and scoring 0 of 288 skills. Lowered 49→48 by road-to-rule-delivery-integrity P2.2: score_skill_selection was repointed at the live skills tree via the shared resolver. It is the same shape as the two gates lowered before it — a scorer reading the retired container and scoring 0 of 288 skills — and here the consequence was sharper than a dead gate: the roadmap's pre-registered selection-accuracy criteria would have been compared against a baseline of silent zeros. Lowered 48→47 on 2026-08-13, and this one is a catch-up rather than a repair: the pass reported 47 against a baseline of 48, so a gain had already landed without the ratchet following it. Attributed to 455160160 (fix(evals): resolve the eval orchestrator against the live skills tree), the most recent repair in this branch's base that removes a path-constructing line — SKILLS_ROOT repointed through _lib/agent_src.ts::SRC_SKILLS(). A loose ratchet is not harmless: it silently permits one new violation to be added back without any gate noticing, which is the shape this entry exists to prevent."
     },
     "audit_user_type_axis": {
       "count": 1,
@@ -22,6 +22,12 @@
       "landed": "2026-08-02",
       "note": "All 18 are `handoff_tier_mismatch`: a senior-tier skill links to a peer whose frontmatter carries no `tier` (reported as tier='unset') — e.g. build-buy-partner → adr-create, customer-research → po-discovery, gated-reach → threat-modeling. This is a tier-metadata backfill backlog on the LINKED-TO skills, not a broken link. The one genuinely dangling link revealed by the same repair (competitive-positioning → a non-existent ../analyze-reference-repo/SKILL.md; it is a command, not a skill) was FIXED in the repairing commit rather than baselined. Clearing this entry means backfilling `tier` on the linked-to skills, or deciding that `tier: unset` on a link target is not a violation and narrowing the rule."
     },
+    "lint_roadmap_blockers:decidability": {
+      "count": 34,
+      "landed": "2026-08-15",
+      "note": "Open blocker entries that are not yet DECIDABLE by the person who owns them — missing `Recommendation:` (which option and why), missing `If you do nothing:` (the cost of the non-decision), or a `What to do:` carrying no command, path or enumerated option set. Revealed by adding the decidability half to lint_roadmap_blockers, not created by it: the five original fields describe a situation and never made it actionable, so a blocker could pass the contract while handing the analysis back to the person least equipped to redo it. Measured at introduction: 36 open entries, ALL 36 undecidable, and 14 of the 46 total entries carry no command/path/option at all in `What to do`. Baselined rather than hard-failed because 36 findings nobody can clear in the change that reveals them is the gate-that-lands-as-N-instant-blockers failure this repository has refused before — the same reasoning as ci-parity:local-only above. First measured at 34 rather than 36 because the two blockers on the branch that introduced this (`ac3-false-positive-reading`, `publish-side-marker-invariant`) were rewritten to the new standard and then closed in the same change; a baseline above the truth silently permits new violations. Re-measured at 38 when the branch was re-pointed at current main, and the +4 is population growth rather than a loosening: main gained the four `road-to-inbox-harvest-2026-08-d-*` roadmaps (context-ledger, runtime-skill-routing, scheduled-deprecation, top-band-model-economy), each carrying one open blocker authored before this requirement existed. That is the honest number for the population this gate now scans — recording 34 against a 38-entry tree would have failed the gate on its own introducing commit and taught the next reader to distrust it. Lowering happens one blocker at a time, and every roadmap touched for other reasons is a chance to lower it. Lowered 38→37 by the scheduled-deprecation PR, which is exactly that shape: code-graph-removal-authorisation was rewritten to the new standard because the roadmap was being touched anyway. Its `If you do nothing:` was one of the few that was not the common no-cost answer — the release gate that PR ships would have refused the next major cut while the blocker stayed open. Recorded in the past tense because the maintainer then RESOLVED that blocker on the trunk by withdrawing the commitment, so nothing refuses a cut today. The lowering stands on the rewrite, not on the consequence, and the sentence is corrected rather than deleted because a baseline note arguing from a retracted state is how a ratchet's rationale rots. The 56-day expiry is the point, not a hazard: if this number has not moved in two months, the fields are not being written and the gate should fail until someone decides whether the requirement is real. Lowered 37→34 when the scheduled-deprecation branch merged current main: three blockers were resolved or rewritten on the trunk in the meantime, so the drop is a genuine drain plus a merge, not a loosening. Re-tightened here rather than left loose because a ratchet that lags its own tree permits violations back in silently.",
+      "falsifier": "./scripts-run src/scripts/lint_roadmap_blockers --quiet"
+    },
     "lint_pack_boundaries": {
       "count": 337,
       "landed": "2026-08-02",

package/src/config/hook-token-budget.json

@@ -58,10 +58,16 @@
             "instrument": "rule-trips.json warn counters per concern"
         },
         "unbounded_output_advisory_rate": {
-            "definition": "Roadmap 4.3 + 4.4 registration (advisory-degraded per the resolved pretooluse-rewrite-semantics blocker: no updatedInput in the v1 contract, so nothing caps and nothing can be bypassed - the demand signal is the fire count itself). rtk-wrap cap-advisory fires per session from the OUTPUT_CAP_TABLE branch; adoption (did the next run use a bounded form) via conformance audits. HONEST GAP: bytes-into-context from tool RESULTS is not instrumented anywhere (the census covers hook payloads only) - the pre/post bytes half of roadmap 4.4 is registered as unmeasurable until a tool-result byte counter exists.",
+            "definition": "Roadmap 4.3 + 4.4 registration (advisory-degraded per the resolved pretooluse-rewrite-semantics blocker: no updatedInput in the v1 contract, so nothing caps and nothing can be bypassed - the demand signal is the fire count itself). rtk-wrap cap-advisory fires per session from the OUTPUT_CAP_TABLE branch; adoption (did the next run use a bounded form) via conformance audits. GAP CLOSED 2026-08-15 (road-to-inbox-harvest-2026-08-d-context-ledger Step 1.1): the tool-result byte counter now exists and its stream is registered below as `tool_result_bytes`. The pre/post bytes half of roadmap 4.4 is measurable from that census once it carries data; it stays unread, not unmeasurable, until a baseline is published.",
             "instrument": "rule-trips.json warn counters for the rtk-wrap concern + conformance audits",
             "threshold": "none committed before data - baseline first, threshold at review date"
         },
+        "tool_result_bytes": {
+            "definition": "road-to-inbox-harvest-2026-08-d-context-ledger 1.1: UTF-8 bytes of every tool RESULT entering context, per call, keyed by tool name. Closes the gap `unbounded_output_advisory_rate` registered above - the injection census measures what this suite puts into context, this measures what the host's tools do, and the second is the larger term. CAPTURE ONLY: the concern emits zero bytes to the model, so it carries no per-concern injection cap; it is registered here because this file already owns the owner/review discipline for context-cost instruments.",
+            "instrument": "the `tool-result-bytes` concern (src/scripts/hooks/tool_result_bytes_hook.ts) on post_tool_use, appending {ts, tool, bytes, measurable} to agents/runtime/state/tool-result-census.jsonl",
+            "privacy": "census lines carry a tool NAME, a byte COUNT and a timestamp - the record type has no field able to hold file contents, command output or any free text, so there is no scrubber that can fail",
+            "threshold": "none committed before data - baseline first, threshold at review date. A `measurable: false` line means the host's payload carried no readable result; that absence is itself a coverage finding and is never counted as zero bytes"
+        },
         "turns_per_task": {
             "definition": "user_prompt_submit count keyed to the task envelope - the invisible multiplier (every turn re-pays the accumulated context at read rates).",
             "instrument": "session-register / chat-history turn counters; HONEST GAP: no task-envelope key exists yet in those counters - the number is per-SESSION until a task key ships; registered with that stated limitation rather than silently redefined",

package/src/config/preamble-payload-budget.json

@@ -35,6 +35,34 @@
         "p95": 50000,
         "_comment": "The roadmap's candidate numbers, kept as the destination. Reaching them needs reductions this package has not built yet; scope-dedup (C-3) removes a redundant COPY at the consumer, it does not shrink the suite itself."
     },
+    "target_schedule": {
+        "_comment": "road-to-inbox-harvest-2026-08-d-context-ledger Step 5.3. The target above was a destination with no route: the ratchet fails on GROWTH only, so the corpus can drift away from 40k indefinitely without any gate objecting. These milestones give the destination a schedule. They are DATES WITH NUMBERS, not a derivation - no measurement in this tree says the estate can reach 85k by a given day, and pretending otherwise would be the invented-threshold failure this file's own baseline_history is careful to avoid. What they buy is that a miss becomes a published fact with an owner instead of a silent drift.",
+        "owner": "maintainer",
+        "measured_at_registration": {
+            "tokens": 125593,
+            "at": "2026-08-15",
+            "note": "MEASURED total at registration time, from check_preamble_payload_budget. It is ~23k ABOVE both baseline_tokens (102520) and the derived ceiling, i.e. the gate is red on the tree as it stands. The baseline is deliberately NOT raised to meet it - raising a ratchet baseline to clear a failing check is the config-weakening move this repo blocks by construction. It is recorded here so the milestones below are planned against the real starting point rather than a stale one. Per-rule ranking: agents/evidence/analysis/rule-paths-coverage-census.md"
+        },
+        "milestones": [
+            {
+                "by": "2026-11-10",
+                "tokens": 102520,
+                "why": "Return to the registered baseline. This is a RECOVERY milestone, not progress toward 40k - it undoes drift rather than shrinking the estate. The date is the review_by both budget files already carry, so it needs no new calendar."
+            },
+            {
+                "by": "2027-02-10",
+                "tokens": 85000,
+                "why": "First real reduction. The rule-paths census shows 92.1% of rule weight sits in the auto tier and the top 20 files carry 35.5% of it, so a scoped tranche is the plausible mechanism - GATED on the paths-scoping consumer decision, which is a human call and may resolve against scoping entirely."
+            },
+            {
+                "by": "2027-05-10",
+                "tokens": 60000,
+                "why": "Second reduction. No mechanism is committed for this one; it exists so the destination keeps a date after the first tranche lands, and it is the milestone most likely to be revised on evidence."
+            }
+        ],
+        "on_miss": "A missed milestone is PUBLISHED - recorded here with the measured number and the reason - and never silently re-dated. Two consecutive misses mean the schedule was wrong or the destination is unreachable with the mechanisms available; either outcome is a decision to surface, not a date to move again.",
+        "revisit_if": "The paths-scoping decision resolves against scoping (removing the only named mechanism for the 85k milestone), or a measured reduction lands ahead of schedule and the remaining milestones are re-derived from it."
+    },
     "reference_measurements": {
         "measured_cold_start_median_tokens": 230930,
         "c3_scope_dedup_reduction_pct": 38,

package/src/scripts/_dispatch.bash

@@ -250,6 +250,11 @@ Tier 2 — maintenance / internal (hooks, MCP, memory, telemetry):
                              router + projection freshness, host bridge status.
                              Flags: --platform <p>, --workspace <path>, --json, --strict,
                              --no-freshness
+  workspace:doctor           One answer to "where am I": repo root, main worktree, current
+                             worktree, branch, PR base — each with its provenance — plus
+                             session claim, conflicting records and worktree pressure.
+                             Read-only; no disposal path by design.
+                             Flags: --from <dir>, --json, --strict
   route:explain              Deterministic rule-routing trace for one prompt: matched
                              triggers, tier, injected-vs-pointer disposition, budget
                              consumption, rejected candidates. Trigger-match level only
@@ -447,6 +452,9 @@ require_tsx() {
 # command surface (`sync`, `doctor`, `validate`, `upgrade`, …) and its
 # basenames are unique, so the mapping is collision-free. Other exec_ts
 # callers (resolve_script results, the work engine, …) are unaffected.
+#
+# In a DEV tree the bundle is also suppressed when any `src/**/*.ts` is newer
+# than it — see cli_delegate_bundle_is_stale.
 cli_delegate_bundle() {
   local ts_abs="$1"
   case "$ts_abs" in
@@ -457,18 +465,52 @@ cli_delegate_bundle() {
   name="$(basename "${ts_abs%.ts}")"
   local bundle="$PACKAGE_ROOT/dist/cli-delegate/$name.js"
   if [[ -f "$bundle" ]] && command -v node >/dev/null 2>&1; then
+    cli_delegate_bundle_is_stale "$bundle" && return 0
     printf '%s' "$bundle"
   fi
 }
 
+# Is a `dist/cli-delegate/` bundle older than the sources it was built from?
+#
+# Only asked in a DEV tree — `$PACKAGE_ROOT/src` exists there and nowhere else.
+# A consumer install ships no `src/`, so it returns "not stale" without a single
+# stat and the ADR-204 fast path is untouched.
+#
+# The scan covers `src` WHOLE, not `src/scripts`: `_cli/*.ts` imports reach into
+# `src/shared`, `src/install`, `src/server`, `src/agent`, `src/config` and
+# `src/agent-src`, and the defect this guard exists for lived two hops away in
+# `src/scripts/_lib/cc_transcript.ts` — a scan narrowed to the entry point's own
+# directory would have missed it.
+#
+# Cost, measured 2026-08-14 on the local tree (1075 `.ts` files): 78 ms when the
+# bundle is current (the full walk) and ~12 ms when it is not (`-quit` exits at
+# the first newer file). The bundle saves ~290 ms against the tsx path, so the
+# worst case still leaves most of that — and buys the guarantee that a dev-tree
+# edit is never silently ignored in favour of a stale compile.
+cli_delegate_bundle_is_stale() {
+  local bundle="$1"
+  [[ -d "$PACKAGE_ROOT/src" ]] || return 1
+  local newer
+  newer="$(find "$PACKAGE_ROOT/src" -name '*.ts' -newer "$bundle" -print -quit 2>/dev/null)"
+  [[ -n "$newer" ]]
+}
+
 # Run an absolute script path. The argument is an absolute path that may carry
 # a `.py` (legacy) or `.ts` extension; we resolve the `.ts` twin.
 #
-# A precompiled `dist/cli-delegate/` bundle wins when present — the consumer
-# tree ships no tsx (see require_tsx), and the bundle is also ~5.7x faster
-# than the npx path it replaces (p50 56-71 ms vs 346-392 ms, measured
-# 2026-07-31; see docs/decisions/ADR-204). The tsx path stays as the dev-tree
-# route and as the fallback for every non-`_cli` caller.
+# A precompiled `dist/cli-delegate/` bundle wins when present AND not stale —
+# the consumer tree ships no tsx (see require_tsx), and the bundle is also
+# ~5.7x faster than the npx path it replaces (p50 56-71 ms vs 346-392 ms,
+# measured 2026-07-31; see docs/decisions/ADR-204). The tsx path stays as the
+# dev-tree route and as the fallback for every non-`_cli` caller.
+#
+# "Not stale" is the load-bearing qualifier, and it was added because the
+# unqualified version shipped a real failure: a dev-tree `dist/cli-delegate/`
+# built before a `projectStoreSlug` fix kept running the OLD slug, so
+# `agent-config handoff --list` reported "no recent sessions" in any worktree
+# whose path carried a `+`, while the fixed source right next to it listed ten.
+# A compiled copy that silently outranks the source it was built from turns
+# every edit into a coin flip — see cli_delegate_bundle_is_stale.
 #
 # Argv/stdin/stdout/stderr/exit-code pass through unchanged in both routes —
 # mirrors src/scripts/run.ts resolution.
@@ -862,6 +904,10 @@ cmd_routing_doctor() {
   exec_hook "src/scripts/routing_doctor" "$@"
 }
 
+cmd_workspace_doctor() {
+  exec_hook "src/scripts/workspace_doctor" "$@"
+}
+
 cmd_hooks_replay() {
   exec_hook "src/scripts/hooks/replay_hook" "$@"
 }
@@ -1385,6 +1431,7 @@ main() {
     hooks:status)            cmd_hooks_status "$@" ;;
     hooks:doctor)            cmd_hooks_doctor "$@" ;;
     routing:doctor)          cmd_routing_doctor "$@" ;;
+    workspace:doctor)        cmd_workspace_doctor "$@" ;;
     route:explain)           cmd_route_explain "$@" ;;
     route:audit)             cmd_route_audit "$@" ;;
     hooks:replay)            cmd_hooks_replay "$@" ;;

package/src/scripts/_lib/git_common_dir.ts

@@ -126,3 +126,176 @@ export function git_common_dir(project_root: string): string | null {
         return null;
     }
 }
+
+// ---------------------------------------------------------------------------
+// Workspace identity
+// ---------------------------------------------------------------------------
+
+/**
+ * One answer to one identity question, and never a silent default.
+ *
+ * The census that motivated this type (`agents/evidence/analysis/
+ * workspace-identity-census.md`) found three of eight repo-root sites falling
+ * back to a value that is *plausible but wrong* when git cannot answer —
+ * `process.cwd()`, a path derived from the script's own location, an
+ * exception. A caller cannot distinguish those from a real answer, which is
+ * how a gate ends up scanning the wrong tree and exiting green.
+ */
+export type IdentityField =
+    | { readonly resolved: true; readonly value: string; readonly provenance: string }
+    | { readonly resolved: false; readonly reason: string };
+
+/** The five workspace-identity questions, each independently resolvable. */
+export interface WorkspaceIdentity {
+    /**
+     * Top level of the working tree the caller is in — the drop-in for
+     * `git rev-parse --show-toplevel`. Inside a linked worktree this is the
+     * worktree's own root, exactly as git reports it.
+     */
+    readonly repoRoot: IdentityField;
+    /**
+     * The main (non-linked) checkout. Derived from the common git dir, so it
+     * is the same value from every worktree of the repo. This is the field the
+     * two shipped misclassification defects needed and did not have.
+     */
+    readonly mainWorktree: IdentityField;
+    /**
+     * The checkout the caller is in. Its `value` equals `repoRoot` by git's own
+     * definition; the two fields exist separately because the *provenance*
+     * differs and that is the part callers need — `main-checkout` versus
+     * `linked-worktree` is precisely the question `isStandardLocation` got
+     * wrong twice.
+     */
+    readonly currentWorktree: IdentityField;
+    /** Branch of the current checkout; unresolved on a detached HEAD. */
+    readonly branch: IdentityField;
+    /**
+     * The remote's default branch, as a `refs/remotes/<remote>/<name>` ref —
+     * the offline notion of "what a PR from here would target".
+     *
+     * Deliberately NOT the `gh`-derived base of an actual open PR: that needs
+     * network and auth, and `check_branch_freshness.ts` already owns it. This
+     * field answers the question a gate can answer without leaving the disk,
+     * and reports `unresolved` rather than guessing `main` when the repo has
+     * no recorded default.
+     */
+    readonly prBase: IdentityField;
+}
+
+function resolved(value: string, provenance: string): IdentityField {
+    return { resolved: true, value, provenance };
+}
+
+function unresolved(reason: string): IdentityField {
+    return { resolved: false, reason };
+}
+
+/**
+ * Walk up from `start` to the first directory holding a `.git` entry.
+ *
+ * File-based on purpose, like everything else here: `rev-parse --show-toplevel`
+ * would be redirected by an inherited `GIT_DIR`, and the symptom is a wrong
+ * path rather than an error.
+ */
+function discover_root(start: string): string | null {
+    let dir = realpath_or_self(path.resolve(start));
+    for (;;) {
+        if (fs.existsSync(path.join(dir, '.git'))) return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) return null;
+        dir = parent;
+    }
+}
+
+/**
+ * Is `project_root`'s `.git` a linked-worktree pointer file rather than a
+ * directory? Returns `null` when there is no `.git` entry at all.
+ */
+function is_linked_worktree(project_root: string): boolean | null {
+    try {
+        return !fs.statSync(path.join(project_root, '.git')).isDirectory();
+    } catch {
+        return null;
+    }
+}
+
+/** The remote default branch ref, read from disk. `null` when unrecorded. */
+function remote_head_ref(common_dir: string, remote: string): string | null {
+    // A symbolic ref is stored loose; `git pack-refs` never packs one, so
+    // packed-refs is not a fallback for this specific ref — a repo that has
+    // never run `git remote set-head` simply has no answer on disk.
+    try {
+        const raw = fs.readFileSync(path.join(common_dir, 'refs', 'remotes', remote, 'HEAD'), 'utf-8');
+        const m = raw.match(/^ref:\s*(refs\/remotes\/.+?)\s*$/m);
+        return m === null ? null : m[1]!.trim();
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Resolve all five workspace-identity questions from `start` (default: the
+ * process cwd), reading files only.
+ *
+ * Every field is either a value with its provenance or an explicit reason it
+ * could not be resolved. Nothing here throws and nothing guesses.
+ */
+export function workspaceIdentity(
+    start: string = process.cwd(),
+    remote = 'origin',
+): WorkspaceIdentity {
+    const root = discover_root(start);
+    if (root === null) {
+        const why = `no .git entry in ${path.resolve(start)} or any ancestor`;
+        return {
+            repoRoot: unresolved(why),
+            mainWorktree: unresolved(why),
+            currentWorktree: unresolved(why),
+            branch: unresolved(why),
+            prBase: unresolved(why),
+        };
+    }
+
+    const linked = is_linked_worktree(root);
+    const repoRoot = resolved(root, 'upward .git walk from cwd');
+    const currentWorktree = resolved(
+        root,
+        linked === true
+            ? 'linked-worktree (.git is a gitdir pointer file)'
+            : 'main-checkout (.git is a directory)',
+    );
+
+    const common = git_common_dir(root);
+    let mainWorktree: IdentityField;
+    if (common === null) {
+        mainWorktree = unresolved('no common git dir resolvable from the repo root');
+    } else if (path.basename(common) === '.git') {
+        mainWorktree = resolved(path.dirname(common), 'dirname of the common git dir');
+    } else {
+        // Bare repo, `core.worktree`, or a separate-gitdir layout: the common
+        // dir is not `<main>/.git`, so `dirname` would name a directory that is
+        // not a checkout. Refusing is the point of the type.
+        mainWorktree = unresolved(
+            `common git dir ${common} is not named .git — bare or separate-gitdir layout has no main worktree to derive`,
+        );
+    }
+
+    const br = current_branch(root);
+    const branch = br === null
+        ? unresolved('detached HEAD, or HEAD unreadable in the per-worktree git dir')
+        : resolved(br, 'ref line of <git-dir>/HEAD');
+
+    let prBase: IdentityField;
+    if (common === null) {
+        prBase = unresolved('no common git dir resolvable from the repo root');
+    } else {
+        const ref = remote_head_ref(common, remote);
+        prBase = ref === null
+            ? unresolved(
+                `no refs/remotes/${remote}/HEAD on disk — run \`git remote set-head ${remote} -a\`; not guessed`,
+            )
+            : resolved(ref, `symbolic ref refs/remotes/${remote}/HEAD`);
+    }
+
+    return { repoRoot, mainWorktree, currentWorktree, branch, prBase };
+}

package/src/scripts/_lib/model_tier.ts

@@ -25,7 +25,16 @@ import fs from "node:fs";
 
 // Tier → Claude model. The ONLY per-vendor mapping the package maintains
 // (ADR-035 § 3); other agents resolve the tier band to their own line-up.
+//
+// `frontier` was added by ADR-232, which amends ADR-035 § Decision 1 on that
+// record's own reopen condition. The asymmetry that triggered it is worth
+// keeping visible here: `MODEL_FAMILIES` in the orchestration-record hook has
+// enumerated four families since it shipped, while this map named three — so a
+// dispatch on the fourth band was recordable but not declarable. Adding the row
+// here rather than a second table elsewhere is what keeps ADR-035 § 3 intact:
+// one mapping, one owner, no two-clocks drift.
 export const TIER_TO_CLAUDE_MODEL: Record<string, string> = {
+  frontier: "fable",
   high: "opus",
   medium: "sonnet",
   lite: "haiku",