@event4u/agent-config 12.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/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

@@ -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
@@ -899,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" "$@"
 }
@@ -1422,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",

package/src/scripts/_lib/release_highlights.ts

@@ -76,6 +76,91 @@ const _PUBLIC_SURFACE_PREFIXES = [
 
 const _RULE_OR_SCHEMA_PREFIXES = ['src/rules/', 'src/scripts/schemas/'];
 
+/**
+ * Paths whose repair is a correctness fix to shipped *behaviour* rather than a
+ * record of one. The distinction is load-bearing: 43 % of `fix(...)` commits
+ * over the six spans measured in
+ * `agents/evidence/analysis/release-head-derivation-recall.md` touch no
+ * executable file at all — `52d7fe1 fix(worktrees): the inventory
+ * misclassifies from inside a worktree, totally` changes two markdown files and
+ * repairs nothing. Keying on the touched surface is what separates a bug fix
+ * from a bug report, and it moves hand-judged precision from 54 % to 96 %.
+ */
+const _EXECUTABLE_SUFFIX = /\.(?:ts|tsx|js|mjs|cjs|sh|py)$/u;
+const _EXECUTABLE_PREFIXES = ['.github/workflows/', '.github/actions/'];
+
+/**
+ * Shebang entry points with no extension, which a suffix test cannot see. An
+ * exact set rather than a heuristic: the alternative is reading file contents,
+ * which a span commit does not carry.
+ *
+ * The recall limit that remains, named rather than left for a reader to
+ * discover: a NEW extensionless entry point is invisible until it is added
+ * here. Precision was measured over six spans; this predicate's recall was not,
+ * and adding to this set is the maintenance that follows a new entry point.
+ */
+const _EXECUTABLE_EXACT: ReadonlySet<string> = new Set([
+    'scripts-run',
+    'src/scripts/agent-config',
+]);
+
+function _touches_executable(files: SpanCommit['files']): boolean {
+    return files.some(
+        (f) =>
+            _EXECUTABLE_SUFFIX.test(f.path) ||
+            _EXECUTABLE_EXACT.has(f.path) ||
+            _EXECUTABLE_PREFIXES.some((p) => f.path.startsWith(p)),
+    );
+}
+
+/**
+ * Conventional-commit type, lower-cased, or `''` when the subject carries no
+ * conventional prefix.
+ *
+ * Two things this deliberately does, both of which an earlier version got
+ * wrong. It requires the conventional `:` separator, so `fix the flaky runner`
+ * is not classified as type `fix` — otherwise this function disagrees with the
+ * scope regex three lines below it and with every prose description of the
+ * rule. And it recognises `Revert "<subject>"`, the form `git revert` writes by
+ * default, which is not conventional at all: without it the documented revert
+ * half only ever applied to a hand-written `revert(scope):`, and a revert of
+ * shipped behaviour is the commit class most likely to be a correctness repair.
+ */
+function _commit_type(subject: string): string {
+    if (/^Revert\s+"/u.test(subject)) {
+        return 'revert';
+    }
+    const m = /^(\w+)(?:\([^)]*\))?!?:/u.exec(subject);
+    return m ? m[1]!.toLowerCase() : '';
+}
+
+/**
+ * Recorded-null forms beyond the literal marker, taken from real subjects and
+ * bodies over the six measured spans rather than invented: a waived-rather-than-
+ * met condition, a published or recorded null, an archival on a roadmap's own
+ * falsifier. All six commits these add across the six spans are true positives.
+ */
+const _NULL_FORMS: readonly RegExp[] = [
+    /honest[ -]null/iu,
+    /\bwaived,? (?:rather than|not) met\b/iu,
+    /\bsoak was waived\b/iu,
+    // The trailing lookahead keeps a recorded *result* apart from a field that
+    // merely holds null. This pattern is applied to the body as well as the
+    // subject, and a body is where "records null token_delta" appears — a
+    // telemetry field, not a null result. Excluding an identifier-shaped token
+    // after `null` costs nothing real: "records the null result" and "closed as
+    // a published null" both still derive. The lookahead is deliberately
+    // SAME-LINE (`[ \t]`, never `\s`): the first version used `\s+` and dropped
+    // a true positive, because 92f9b9a ends its subject on "closed as a
+    // published null" and its body then opens with `count_open reached 0` — an
+    // identifier on the NEXT line, which `\s+` happily crossed. The residual
+    // limit, named rather than left to be discovered: a field name with no
+    // underscore ("records null delta") is still caught.
+    /\b(?:publish(?:es|ed|ing)?|record(?:s|ed|ing)?|report(?:s|ed|ing)?) (?:the |an |a |its )?(?:honest )?null\b(?![ \t]+`?[a-z][a-z0-9]*_[a-z0-9_]*)/iu,
+    /\bnull(?: result)? (?:stands|is the answer)\b/iu,
+    /\bon (?:its|the) own falsifier\b/iu,
+];
+
 /**
  * Why a label fired, in generator-facing prose. Keyed by label; a label absent
  * here is never derived (`Known limitations` is pure prose, not checkable).
@@ -83,25 +168,37 @@ const _RULE_OR_SCHEMA_PREFIXES = ['src/rules/', 'src/scripts/schemas/'];
 const _DERIVED_REASON: Readonly<Record<string, string>> = {
     'Behaviour changes': 'rule/schema diffs, breaking commits or removed public surface',
     'Default changes + migration': 'commits naming a default, migration or migrate',
-    'Security and correctness': 'security-scoped commits',
-    'Honest nulls': 'commits carrying an honest-null marker',
+    'Security and correctness': 'security-scoped commits or fixes to executable surface',
+    'Honest nulls': 'commits recording a null, waived or falsified result',
 };
 
 /**
  * Derive evidence per curated label from the span. Rules per label:
  *
  * - Security and correctness: conventional scope matching /secur/i, or the
- *   whole word "security" in the subject.
+ *   whole word "security" in the subject — plus the *correctness* half the
+ *   label names: a `fix` or `revert` commit touching executable surface.
  * - Behaviour changes: breaking (`!` / BREAKING CHANGE) commits, diffs
  *   touching `src/rules/` or `src/scripts/schemas/`, and deletions under the
  *   public artefact trees (removed public surface).
  * - Default changes + migration: subject carrying the whole word "default",
  *   "migration", or "migrate".
- * - Honest nulls: subject or body carrying an "honest null" marker.
+ * - Honest nulls: subject or body carrying one of the recorded-null forms —
+ *   the literal marker, a waived-rather-than-met condition, a published or
+ *   recorded null, an archival on a roadmap's own falsifier.
  * - Known limitations: never derived — pure prose, not gate-checkable.
  *
  * Derivation is deliberately conservative: a false red makes every release
- * annoying, a miss only returns the head to the pre-gate state.
+ * annoying, a miss only returns the head to the pre-gate state. Conservative
+ * is not the same as silent, and two labels had crossed that line: measured
+ * over the six spans in
+ * `agents/evidence/analysis/release-head-derivation-recall.md`, `Security and
+ * correctness` fired **1 of 45** hand-confirmed in-category commits and
+ * `Honest nulls` **3 of 9**, so the
+ * curated `_none_` shipped uncontested where the span carried the evidence.
+ * The widening is aimed at those two and measured before it landed; the naive
+ * "any `fix(` counts" alternative was rejected on data (54 % precision against
+ * 96 %), not on taste.
  */
 export function derive_category_hits(
     commits: readonly SpanCommit[],
@@ -113,7 +210,10 @@ export function derive_category_hits(
     for (const c of commits) {
         const scopeMatch = /^\w+\(([^)]*)\)!?:/u.exec(c.subject);
         const scope = scopeMatch ? scopeMatch[1]! : '';
-        if (/secur/iu.test(scope) || /\bsecurity\b/iu.test(c.subject)) {
+        const type = _commit_type(c.subject);
+        const correctnessFix =
+            (type === 'fix' || type === 'revert') && _touches_executable(c.files);
+        if (/secur/iu.test(scope) || /\bsecurity\b/iu.test(c.subject) || correctnessFix) {
             out['Security and correctness']!.push({ sha: c.sha, text: c.subject });
         }
         const removedPublic = c.files.filter(
@@ -134,7 +234,8 @@ export function derive_category_hits(
         if (/\b(default|migration|migrate)\b/iu.test(c.subject)) {
             out['Default changes + migration']!.push({ sha: c.sha, text: c.subject });
         }
-        if (/honest[ -]null/iu.test(`${c.subject}\n${c.body}`)) {
+        const subjectAndBody = `${c.subject}\n${c.body}`;
+        if (_NULL_FORMS.some((re) => re.test(subjectAndBody))) {
             out['Honest nulls']!.push({ sha: c.sha, text: c.subject });
         }
     }