@event4u/agent-config 14.11.0 → 14.12.0

package/dist/install/install.mjs

@@ -15505,6 +15505,11 @@ var settingsSchema = external_exports.object({
       enabled: external_exports.boolean().default(false).describe(
         "PreToolUse code-graph nudge (ADR-124 Phase 4). Default off. When on AND a native code-graph cache or a consumer-shipped graph.json/SCIP index is present, warns once per session (never blocks) as the agent is about to Grep/Glob or Read a source file \u2014 query the graph first for who-calls/where-used/impact questions (or rebuild if stale, build if absent). Source G\u2019s strict block-first-read mode is deliberately un-ported."
       )
+    }).default({}),
+    suggestion_capture: external_exports.object({
+      enabled: external_exports.boolean().default(false).describe(
+        'Suggestion-block capture (road-to-suggestion-block-capture Phase 2). Default off. Two slots: `stop` reads `last_assistant_message` \u2014 a payload field, so no transcript file is read \u2014 and latches that the assistant turn carried a numbered-options block; `user_prompt_submit` CONSUMES that latch and classifies the answering turn as option_n / as_is / other / stale_block. Consume-once is the correctness guard: the latch is deleted on read, so a bare "1" three turns later meets no latch and classifies `other`, and a latch past its TTL or unparseable is `stale_block` rather than a guess. Writes COUNTS ONLY to agents/runtime/state/audit/suggestion-capture.jsonl \u2014 the record type has no field able to hold a prompt, an option label or a command name, and a test asserts the written key set against src/config/suggestion-capture.json. Off by default because this is an INSTRUMENT rather than a feature: it exists so a capture rate can be measured on a maintainer workspace over a fixed soak window, and there is nothing in it for a consumer to gain.'
+      )
     }).default({})
     // `turn_end_gate` is deliberately ABSENT. The stop-slot turn-end gate is
     // always armed (2026-08-12) and has no settings surface: whether it

package/dist/mcp/registry-manifest.json

@@ -3,13 +3,13 @@
     "artefact_count": 623,
     "scanner_version": "de0a22b4ac4c"
   },
-  "generated_at": "2026-08-24",
+  "generated_at": "2026-08-25",
   "package": {
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) \u2014 every claim machine-checked, including \"zero runtime daemon\".",
     "homepage": "https://event4u-app.github.io/agent-config",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "14.11.0"
+    "version": "14.12.0"
   },
   "registries": [
     {

package/dist/mcp/server.json

@@ -9,12 +9,12 @@
       "transport": {
         "type": "stdio"
       },
-      "version": "14.11.0"
+      "version": "14.12.0"
     }
   ],
   "repository": {
     "source": "github",
     "url": "https://github.com/event4u-app/agent-config"
   },
-  "version": "14.11.0"
+  "version": "14.12.0"
 }

package/dist/server/schemas/settings.js

@@ -275,6 +275,9 @@ export const settingsSchema = z.object({
         code_graph: z.object({
             enabled: z.boolean().default(false).describe('PreToolUse code-graph nudge (ADR-124 Phase 4). Default off. When on AND a native code-graph cache or a consumer-shipped graph.json/SCIP index is present, warns once per session (never blocks) as the agent is about to Grep/Glob or Read a source file — query the graph first for who-calls/where-used/impact questions (or rebuild if stale, build if absent). Source G’s strict block-first-read mode is deliberately un-ported.'),
         }).default({}),
+        suggestion_capture: z.object({
+            enabled: z.boolean().default(false).describe('Suggestion-block capture (road-to-suggestion-block-capture Phase 2). Default off. Two slots: `stop` reads `last_assistant_message` — a payload field, so no transcript file is read — and latches that the assistant turn carried a numbered-options block; `user_prompt_submit` CONSUMES that latch and classifies the answering turn as option_n / as_is / other / stale_block. Consume-once is the correctness guard: the latch is deleted on read, so a bare "1" three turns later meets no latch and classifies `other`, and a latch past its TTL or unparseable is `stale_block` rather than a guess. Writes COUNTS ONLY to agents/runtime/state/audit/suggestion-capture.jsonl — the record type has no field able to hold a prompt, an option label or a command name, and a test asserts the written key set against src/config/suggestion-capture.json. Off by default because this is an INSTRUMENT rather than a feature: it exists so a capture rate can be measured on a maintainer workspace over a fixed soak window, and there is nothing in it for a consumer to gain.'),
+        }).default({}),
         // `turn_end_gate` is deliberately ABSENT. The stop-slot turn-end gate is
         // always armed (2026-08-12) and has no settings surface: whether it
         // fires is decided by each detector's own trigger conditions, not by a

package/docs/contracts/settings-classes.md

@@ -242,8 +242,8 @@ dispatch runs, not WHETHER the layer exists, so they keep their own C rows.
 |---|---|
 | A — preference | 26 |
 | B — consent | 3 |
-| C — guarded | 108 |
-| **Total** | **137** |
+| C — guarded | 109 |
+| **Total** | **138** |
 
 The total was 140 until 2026-08-12, when five of the six keys no code path read were
 deleted, minus the one held open (§ The six unread keys, below): one A
@@ -257,6 +257,25 @@ It rose to 136 on 2026-08-20 when `road-to-gate-autonomy`'s
 first keys added to this contract since the deletions above, and both are C on
 test 1 (money).
 
+It rose to 138 on 2026-08-24 when `road-to-suggestion-block-capture` Phase 2
+added `hooks.suggestion_capture.enabled`. C on test 1 — it configures code that
+runs at every turn end and every prompt — and the third `hooks.*` key here.
+
+Its disposition is **`consent`**, and the first draft of this row said
+`derivable`, which was wrong in the way the disposition axis exists to catch. The
+`derivable` argument was that the sink's own line count answers whether the soak
+window is running — true, and it answers the wrong question. What the key
+authorises is *the package observing this operator's turns and writing a record
+of them*, and no predicate computes whether someone consents to that. The
+`derivable-surface` ratchet caught it immediately: it is shrink-only, so a new
+`derivable` key reds by construction, and being unable to add one is the
+mechanism working rather than an obstacle.
+
+The distinction against its `design_pass` neighbour still holds and is the reason
+this is not `policy` either: that concern can **block**, so arming it is a risk
+preference. This one only observes and exits 0 on every path — the question is
+not risk, it is permission.
+
 It rose to 137 on 2026-08-23 when `road-to-frontend-power` E1.1–E1.3 added
 `hooks.design_pass.enabled`. C on test 1 (it configures code that runs on every
 tool call and at every turn end), and the only hook key in this contract whose
@@ -314,9 +333,9 @@ the template, which is the drift this contract exists to prevent.
 |---|---|
 | derivable | 83 |
 | un-inferrable | 9 |
-| consent | 39 |
+| consent | 40 |
 | policy | 6 |
-| **Total** | **137** |
+| **Total** | **138** |
 
 First measured 2026-08-12 at 140 leaves (derivable 88 · consent 38 ·
 un-inferrable 9 · policy 5), from the table below rather than predicted — the
@@ -534,6 +553,7 @@ Rows follow template order, so a diff against the template reads straight down.
 | `hooks.ui_route_nudge.enabled` | C | `false` | configures code that runs on every tool call | derivable — the UI-surface predicate plus the hook's own two-nudges-per-session cap |
 | `hooks.design_pass.enabled` | C | `false` | C-test 1 — it configures code that runs on every tool call and at every turn end, and unlike its two `hooks.*` neighbours its stop pass can BLOCK rather than warn | policy — whether an operator accepts a gate that can refuse a turn is a risk preference, not a fact the tree can compute. The two neighbours are `derivable` because they only ever warn; the block is the discriminator. `road-to-frontend-power` transfers the default flip to the owner for the same reason |
 | `hooks.code_graph.enabled` | C | `false` | configures code that runs on every tool call | derivable — the index-detection probe the nudge already runs; no index means silence |
+| `hooks.suggestion_capture.enabled` | C | `false` | configures code that runs at every turn end and every prompt | consent |
 | `decision_engine.surface_traces` | C | `false` | the decision engine’s own black box; the agent must not be able to close it | derivable — the engine's own active-gate state; there is nothing to surface when no gate fired |
 | `decision_engine.min_confidence` | C | `"off"` | the confidence gate | derivable — the confidence band the scoring engine already computes at the plan phase |
 | `decision_engine.block_on_risk` | C | `"off"` | the risk-class gate | derivable — the risk class the engine already computes at the implement phase; the Hard Floor covers the irreversible end unconditionally |

package/docs/guidelines/agent-infra/downstream-changes-mechanics.md

@@ -0,0 +1,91 @@
+# Downstream-Changes Mechanics — closed-set evolution
+
+> The procedure behind [`downstream-changes`](../../../src/rules/downstream-changes.md)
+> for one change class its table does not reach: a **closed set** whose member
+> list changed. Cited by `skill:code-review` (the propagation dimension) and
+> `skill:code-refactoring` (the reference sweep).
+>
+> It lives here rather than in the rule for a measured reason. Project-scope
+> rules are a gated bucket of the per-spawn standing payload, and that payload
+> currently measures **at** its grace ceiling
+> (`src/config/preamble-payload-budget.json`), so the rule cannot grow by a
+> single line without reddening `check_preamble_payload_budget`. Guidelines are
+> an excluded bucket — read on demand, not re-sent per spawn. The obligation is
+> therefore carried by the two skills that fire at the moment it matters, and
+> the rule keeps its current size until a reduction lands.
+
+## The Iron Law
+
+```
+CHANGING A MEMBER OF A CLOSED SET IS NEVER DONE WHEN THE TYPE COMPILES.
+EVERY CONSUMER IS CLASSIFIED: EXHAUSTIVE, DELIBERATE FALLBACK, OR MISSING CASE.
+A `default` THAT SWALLOWS THE NEW MEMBER IS A MISSING CASE WEARING A BRANCH.
+```
+
+## Why the ordinary sweep misses it
+
+`downstream-changes` enumerates callers, tests, imports, type definitions,
+config bindings, routes and docs — all of which are found by searching for the
+**identifier**. A closed set breaks that assumption: the member list changes,
+the type still compiles, and a serializer, a badge variant, an OpenAPI schema or
+a transition table silently keeps the old set. None of them names the type, so
+no identifier search reaches them. This is the shotgun-surgery shape — one
+conceptual change scattered across many small sites, where forgetting one is the
+default outcome rather than the unlucky one.
+
+## What counts as a closed set
+
+PHP enums · TypeScript enums · discriminated unions · literal-union state types ·
+Rust enums · sealed types · Python `enum` classes · DB enum and check
+constraints · OpenAPI / JSON-Schema `enum` · state machines · role and permission
+sets · finite component variants.
+
+## Discover by shape, not by identifier
+
+- the member name and its **backing value** (the wire value often differs);
+- `match` / `switch` / if-chains over the type;
+- `Record<Member, …>`, lookup tables and maps keyed by it;
+- `cases()` / `values()` iteration;
+- validators and serializers;
+- DB constraints and migrations;
+- API schemas;
+- UI option sources and variant maps;
+- translation keys;
+- tests, factories and fixtures.
+
+## Classify every hit — three outcomes, one defect
+
+| Class | What it means | Action |
+|---|---|---|
+| Exhaustive | The compiler or the data structure forces completeness (a fully-typed `Record<Member, …>`, a `match` with no default) | nothing — this is the outcome to prefer |
+| Deliberate fallback | The fallback is part of the contract: a forward-compatible external value, a protocol unknown, a defensive boundary parse | record why, leave it |
+| Missing case | The new member reaches code written for the old set | fix it |
+
+**There is deliberately no blanket rule that a `default` branch is wrong.** Such
+a rule would be refuted by every protocol parser and boundary parse in the tree.
+What is true is sharper and easier to miss: where an exhaustiveness check exists,
+**a `default` clause suppresses its report entirely**, so adding one to quiet the
+check removes exactly the signal it existed to give.
+<!-- harvest:exhaustiveness-default-clause-masks-the-check -->
+
+Prefer the language-native guarantee over a comment. In TypeScript a
+`Record<Member, T>` where every member needs a value fails to compile on a new
+member, while a partially-typed string-keyed map does not. In PHP an exhaustive
+`match` without a masking `default` throws on an unhandled case.
+
+## Prove the sweep, do not assert it
+
+Add a **synthetic member** to the set, confirm the checks you are relying on go
+red, then update the consumers and confirm they go green. A sweep never seen red
+has unknown coverage — the same sensitivity argument
+[`downstream-changes`](../../../src/rules/downstream-changes.md) § Verification
+makes for tests, applied to the discovery step.
+
+## See also
+
+- [`downstream-changes`](../../../src/rules/downstream-changes.md) — the rule this
+  extends; its § Defect-pattern search is the sibling-occurrence half.
+- [`redundancy-taxonomy`](../redundancy-taxonomy.md) — the naming half: one
+  concept, several terms.
+- [`prefer-enums-over-literals`](../../../src/rules/prefer-enums-over-literals.md)
+  — how a closed set comes to exist in the first place.

package/docs/guidelines/code-clarity.md

@@ -246,6 +246,24 @@ Before emitting a comment or docblock, all three must be true:
 
 One "no" → drop it. When in doubt: no comment.
 
+Those three conditions are the code-comment instance of a wider test. The
+generalised form — five questions covering comments, docblocks, labels, hints,
+tooltips, placeholders, badges and empty states alike — is the Information Delta
+Test in [`redundancy-taxonomy`](redundancy-taxonomy.md), together with the
+representation classes that name what a redundant surface *is*. Reach for it
+whenever the surface is not a code comment, and whenever a reduction would touch
+the semantic channel: an accessibility name is required information, so it is a
+hard guard and never a deletion candidate. The rule is not "less text" — it is
+that if removing the text loses no information in any required channel, remove
+it, and if the information is required, express it once, in the strongest native
+form available.
+
+The same document carries the **naming** half, which fires earlier than any of
+this: before introducing a term for a concept, search for the term the tree
+already uses. A second word for an existing concept costs a reader more than a
+redundant sentence does — a redundant sentence is skipped, a second name makes
+them check whether they are looking at one thing or two.
+
 ### Additional worked examples
 
 (The TypeScript `formatPrice` pair above is the canonical TS example; these
@@ -309,3 +327,6 @@ criteria are proven by `tests/scripts/code_comment_fixtures.test.ts`.
   removals on untouched code".
 - `direct-answers` rule — same spirit at the prose level: shortest
   version that fully answers the question.
+- [`redundancy-taxonomy`](redundancy-taxonomy.md) — the shared classes,
+  verdicts and Information Delta Test this section instantiates for code
+  comments; also cited by the review and refactoring skills.

package/docs/guidelines/redundancy-taxonomy.md

@@ -0,0 +1,180 @@
+# Redundancy Taxonomy
+
+> The one place this package names what duplication *is*, what may be decided
+> about it, and how to tell a second explanation that adds information from one
+> that only adds length. Cited by [`code-clarity`](code-clarity.md) at the
+> authoring moment, by `skill:code-review` at the review moment, and by
+> `skill:code-refactoring` at the refactoring moment. Those three cite it —
+> they do not restate it, because three copies of a redundancy taxonomy would
+> be the defect it describes.
+
+Finding duplication is not a decision. Every finding reaches a **named verdict**
+with a reason, and several of the verdicts keep the duplication. The goal is not
+the lowest clone percentage — it is **one honest authority per shared fact**,
+without marrying independent concepts through a wrong abstraction.
+
+## The classes
+
+**Implementation** — the same code exists twice.
+
+| Class | What it is |
+|---|---|
+| Exact clone | Same tokens. |
+| Renamed clone | Same structure; identifiers or literals differ. |
+| Near clone | Shared core with local additions or deletions. |
+| Structural pattern | Same shape, no copy/paste lineage. |
+| Boilerplate | Framework, protocol, or generated ceremony. |
+| Test repetition | Repeated setup or assertion structure. |
+| Intentional independence | Similar today, meant to diverge. |
+| Wrong abstraction | Already shared, now growing caller flags and modes. |
+
+**Knowledge** — the same *fact* is encoded twice. Usually more actionable than
+raw clone percentage, because a clone can be harmless and a divided fact rarely is.
+
+| Class | What it is |
+|---|---|
+| Knowledge duplication | One business rule, constant, or algorithm encoded more than once. |
+| Policy duplication | One governance decision represented across independent surfaces. |
+| Contract duplication | One external protocol or CLI contract reimplemented instead of consumed. |
+| Delivery-authority duplication | Two authored sources can produce the same shipped artifact. |
+
+**Representation** — the same *meaning* is presented twice to a reader: a
+comment, label, hint, tooltip, placeholder, badge, heading, caption, or toast.
+
+| Class | What it is |
+|---|---|
+| Exact text echo | The same text repeated in the same context. |
+| Paraphrase echo | A second surface restating the first in other words. |
+| Structural narration | Prose naming what the code or UI already shows. |
+| Decorative metadata | An eyebrow, badge, or heading with no scanning or semantic value. |
+| Feedback echo | Status text duplicating already-obvious state. |
+| Accessibility conflict | Removing it would delete required semantic information. |
+
+An accessibility conflict is a **hard guard, never a deletion candidate**. A
+reduction that improves the visual channel by breaking the semantic one is not a
+reduction; it is a defect.
+
+**Naming** — the *dual* of a representation echo. An echo says one meaning twice;
+divergent naming says one meaning with two words, so the reader cannot tell
+whether they are looking at one concept or two. It is a modelling defect rather
+than a style preference: a concept carries one term across the whole model, and
+several terms for one concept is the model telling you it has not decided.
+<!-- harvest:one-language-per-concept-inconsistency-is-a-model-defect -->
+
+| Class | What it is |
+|---|---|
+| Spelling variant | One word, two spellings (`artifact` / `artefact`). No semantic difference; decidable without judgement. |
+| Synonym drift | One concept, several terms. Needs a term map, because the terms may denote different things. |
+| Homonym collision | One term, several meanings. The opposite failure, and usually `keep-duplicated` when the meanings are module-local. |
+
+Naming verdicts: `canonicalize-term` · `keep-distinct` (with the recorded reason
+— an external compatibility value, a quoted name, a genuinely different concept)
+· `defer-for-context`.
+
+**Only a spelling variant is mechanically decidable, and the split between the
+prose layer and the identifier layer is decisive.** Prose is a substitution;
+filenames, symbols and their test and task references are a rename refactor with
+its own blast radius, and the same cluster can be committed to different sides on
+each layer. Measure both before proposing either — the measured example is in
+`agents/evidence/analysis/wording-baseline-2026-08-25.md`, where nothing imports
+across the split and the identifier layer is therefore `keep-duplicated` while
+the prose layer is `canonicalize-term`.
+
+Synonym drift is the class to be slowest about. Words that read as synonyms in
+translation frequently denote different mechanisms — here `route`, `dispatch`,
+`delegate`, `spawn` and `forward` are five mechanisms, not one concept spelled
+five ways — so a sweep over them destroys information the echo classes exist to
+protect.
+
+## Why any of this is worth a gate at all
+
+Generated code trends toward duplication rather than reuse: measured
+longitudinally over roughly 211 million changed lines, copy/pasted code rose from
+8.3 % to 12.3 % of changes over the period assistance became common.
+<!-- harvest:ai-agents-raise-copy-paste-share --> The pressure this document
+resists is therefore not a hypothetical — it is the default direction of the tool
+writing the code, which is why `keep-duplicated` needs to be a recorded verdict
+rather than an unstated outcome.
+
+Where enforcement follows, the shape is already known: separate the term list
+from the rules, and control false positives by **syntax awareness** — skip
+frontmatter, fenced code and inline code rather than matching inside them.
+<!-- harvest:prose-linter-vocabulary-accept-reject --> `check_md_language.ts`
+already carries exactly that skip machinery.
+
+## The verdicts
+
+For implementation and knowledge findings: `extract-local` · `extract-module` ·
+`canonicalize-knowledge` · `canonicalize-contract` · `single-copy-delivery` ·
+`data-drive` · `compose-strategy` · `generate` · **`keep-duplicated`** ·
+`defer-for-evidence` · **`de-abstract`**.
+
+For representation findings: `keep` · `drop` · `consolidate` ·
+`rewrite-for-signal` · `accessibility-block` · `defer-for-context`.
+
+`keep-duplicated` and `de-abstract` are **successful outcomes**, not failures to
+act. A wrong abstraction costs more than the duplication it replaced, so a
+recorded decision to leave two copies alone — or to split one shared unit back
+apart — closes a finding as legitimately as an extraction does. What is not
+allowed is silence: a finding with no recorded verdict stays open.
+
+## Before sharing an implementation
+
+1. Is it the same knowledge, or two facts that currently look alike?
+2. Would both copies change for the same reason?
+3. Is there one honest domain name that fits every call site?
+4. Can the common core stay free of caller-specific flags and modes?
+5. Is the dependency direction healthy?
+6. Does this reduce maintenance risk, or only line count?
+7. Are public contracts preserved, and do tests prove behavioural equivalence?
+8. Is this generated or protocol ceremony that should stay explicit?
+9. **If the two copies diverged tomorrow, would that be a defect or legitimate
+   evolution?**
+
+A "legitimate evolution" answer to the last question is decisive: prefer
+independence, verdict `keep-duplicated`.
+
+## The Information Delta Test
+
+Before adding any comment, docblock, label, hint, tooltip, placeholder, badge,
+caption, empty-state line, or explanatory sentence, in code or in a user
+interface:
+
+- **A — Information delta.** What fact becomes unavailable if this text is
+  deleted? A non-obvious reason, an invariant, a required format, a unit, a
+  consequence, a safety warning, a recovery action, a privacy implication, an
+  unfamiliar concept, an accessibility name, or necessary grouping all count. If
+  the answer is "nothing", delete it.
+- **B — Representation delta.** Is that fact already carried adequately by a
+  nearby representation — the name, the type, the component structure, the
+  semantic element, the visible control text, an icon, a test? If so,
+  consolidate; do not repeat.
+- **C — Channel preservation.** Would deleting it weaken visual comprehension,
+  semantic accessibility, or both? Never optimise one channel by breaking the
+  other.
+- **D — Persistence.** Will it still be true after the next ordinary refactor?
+  Text describing the current implementation rather than the durable constraint
+  is noise with a delay fuse.
+- **E — Actionability.** For user-facing copy: does it change what the reader
+  understands, chooses, enters, expects, or does next? If not, it is a strong
+  deletion candidate.
+
+The rule is **not** "less text". It is: if removing the text loses no
+information in any required channel, remove it — and if the information is
+required, express it once, in the strongest native form available. A visible
+form label is required information, so it stays; a placeholder repeating that
+label is an exact text echo, so it goes.
+
+## Legacy is baseline, new duplication is the finding
+
+Existing duplication does not fail an unrelated change. A review or refactor
+raises a finding when a change **introduces** high-confidence knowledge, policy,
+contract, or delivery-authority duplication — or when it touches a surface that
+already carries some. Anything else is debt with a measurement, not a blocker.
+
+## See also
+
+- [`code-clarity`](code-clarity.md) — the authoring moment; comment discipline
+  and the banned classes this test generalises.
+- [`abstraction-thresholds`](abstraction-thresholds.md) — how much repetition
+  earns an abstraction, per artifact class.

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@event4u/agent-config",
     "mcpName": "io.github.event4u-app/agent-config",
-    "version": "14.11.0",
+    "version": "14.12.0",
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) — every claim machine-checked, including \"zero runtime daemon\".",
     "license": "MIT",
     "private": false,
@@ -59,7 +59,11 @@
         "!dist/**/*.test.js",
         "!dist/**/*.test.js.map",
         "!dist/**/*.spec.js",
-        "!dist/**/*.spec.js.map"
+        "!dist/**/*.spec.js.map",
+        "!src/**/*.test.ts",
+        "!src/**/*.spec.ts",
+        "!dist/agent-src/skills/**/evals/**",
+        "!dist/**/*.map"
     ],
     "bin": {
         "agent-config": "dist/cli/agent-config.js"

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

@@ -1344,6 +1344,22 @@ hooks:
   code_graph:
     enabled: false
 
+  # Suggestion-block capture (road-to-suggestion-block-capture). Two slots:
+  # `stop` latches that the assistant turn carried a numbered-options block,
+  # `user_prompt_submit` consumes the latch and classifies the answering turn.
+  # Writes COUNTS ONLY to agents/runtime/state/audit/suggestion-capture.jsonl —
+  # the record type has no field able to hold a prompt, an option label or a
+  # command name, and a test asserts the written key set against
+  # src/config/suggestion-capture.json.
+  #
+  # `enabled: false` is the shipped default because this is an INSTRUMENT, not a
+  # feature: it exists so a capture rate can be measured on a maintainer
+  # workspace during a fixed soak window, and there is nothing in it for a
+  # consumer to gain. Turning it on costs one string match per turn and one
+  # small file write per answered block.
+  suggestion_capture:
+    enabled: false
+
 # --- Decision engine ---
 #
 # Controllable gates layered over the observability surface. Absent

package/src/config/budgets.yml

@@ -4,6 +4,25 @@
 # instead of hard-coding them (measure_augment_budget, and any future
 # per-tool budget meter).
 
+# ── Ownership ─────────────────────────────────────────────────────────────────
+# Added 2026-08-24, road-to-standing-payload-truth `b-budgets-yml-outside-ownership`.
+# This file was outside `lint_budget_ownership`'s corpus for its whole life,
+# because that gate filtered on `.json`. A budget without an owner is a budget
+# nobody has to defend, and this is the one that gates `standing_rule_delivery` —
+# the larger of the two red payload numbers. It is now governed by an explicit
+# single-file row in that gate's `GOVERNED_NON_JSON`, not by a widened glob.
+#
+# `review_by` IS DERIVED, AND NO CADENCE RULE IS DOCUMENTED — said plainly rather
+# than presented as policy. `lint_budget_ownership` requires the field and defines
+# no interval for it. Two conventions are observable in the sibling budgets:
+# four files use 2026-11-10 (the preamble milestone) and seven use a ~1-year
+# horizon, including this file's subject-nearest sibling
+# `preamble-payload-budget.json`. Registered 2026-08-24 on that convention →
+# 2027-08-24. If a cadence is ever written down and disagrees, this date is wrong
+# and should move to the rule rather than the rule to the date.
+owner: maintainer
+review_by: '2027-08-24'
+
 augment_workspace_guidelines:
   # Verified platform maximum: 99,024 chars (re-measured 2026-07; the old
   # 49,512 ceiling from the 2026-05-08 baseline is obsolete). We deliberately

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

@@ -109,6 +109,21 @@ ci_only:
   # self-test is the half that IS worth running locally, and it is reachable —
   # `classify_change_risk --self-test` — but the workflow invokes it as a step of
   # its own rather than through the aggregate, which is what this checker sees.
+  # road-to-npm-payload-reduction Phase 3.1. `report_pack_delta` measures the
+  # BRANCH-vs-BASE packed payload, which has no meaning without a pull request:
+  # locally `--base origin/main --head HEAD` on main reads +0.0 KB every time, and
+  # the step's own contract is to write nothing when the delta is zero. It also
+  # checks out BOTH refs into throwaway worktrees and packs each (~1 minute), so
+  # putting it in `task ci` would add a minute to every local run for a number
+  # that is structurally absent locally. It is a REPORT and cannot red the build
+  # (`continue-on-error: true`, and the script exits 0 whatever the number), so
+  # there is no failure a contributor could discover only after pushing — which is
+  # the exact harm this checker exists to prevent.
+  #
+  # Reachable on demand: `task report-pack-delta -- --base <ref> --head <ref>`.
+  - id: report_pack_delta
+    class: artifact
+    reason: "a pull-request-only delta report with no local meaning (base==head reads +0.0 KB and the step writes nothing); it packs two refs in throwaway worktrees at ~1 min, cannot red the build, and is reachable on demand via `task report-pack-delta`"
   - id: classify_change_risk
     class: benchmark
     reason: "invoked as the nightly drift workflow's self-test step; the classifier itself gates nothing and its `--self-test` is runnable locally on demand (`./scripts-run src/scripts/classify_change_risk --self-test`)"

package/src/config/discovery/prompt-patterns.yml

@@ -0,0 +1,56 @@
+# Controlled prompt-pattern vocabulary for command `## Examples` Why lines.
+#
+# Read by `src/scripts/check_command_examples.ts` (sub-check c). A Why line on
+# an example must cite exactly ONE id from `approved_patterns`.
+#
+# WHY A CONTROLLED VOCABULARY AND NOT FREE PROSE. A worked example teaches two
+# things: what to type, and why that phrasing works. The second half is the part
+# that transfers to a command the reader has not seen. Free prose lets every
+# author invent their own account of it, and six accounts of the same pattern
+# teach the pattern less well than one. The ids are deliberately few and
+# deliberately about the SHAPE of the invocation, never about the command.
+#
+# FORWARD-ONLY, on the `command-verbs.yml` precedent (ADR-041): only commands
+# added, or promoted into `visible` / `advanced`, since the frozen grandfather
+# set in `check_command_examples.ts` are required to carry Why lines. The
+# existing surface is grandfathered and melts down voluntarily.
+#
+# Adding an id here is a governance change: land it in its own PR with the
+# reason the six below could not carry the case. Do NOT add an id to make one
+# awkward example pass — rewrite the example to an existing pattern, or leave
+# the Why line off and accept the gate's finding.
+
+approved_patterns:
+  # Name the end state, not the sequence of steps to reach it. The agent picks
+  # the steps; a step list from the operator overconstrains it and goes stale.
+  - outcome-not-steps
+
+  # Build the verification into the ask, so the agent can tell green from done
+  # without a second turn.
+  - self-check-loop
+
+  # Point at a file, a ticket, a URL, a line range — a resolvable location
+  # beats a description of the thing.
+  - measurable-target
+
+  # Hand over the artifact itself rather than describing it: paste the log, the
+  # diff, the failing output.
+  - give-the-artifact
+
+  # Cite an existing convention, doc, or sibling implementation as the standard
+  # to match, instead of restating it inline.
+  - point-at-reference
+
+  # State the shape the answer must arrive in — a table, JSON, one sentence, a
+  # file path — when the shape is what makes it usable.
+  - say-the-format
+
+# The two literals a Why line may use. Adopted verbatim from
+# `lint_examples.ts` (`### Why it works` / `**Why it works:**`), the strings
+# the demo linter already detects for the SAME purpose on a different
+# population. Reusing the strings rather than the code keeps the two
+# conventions textually aligned without coupling the gates — the demo linter's
+# scope and observable behaviour are compatibility-pinned and stay untouched.
+why_line_literals:
+  - '**Why it works:**'
+  - '### Why it works'

package/src/config/estate-count-budget.json

@@ -6,18 +6,23 @@
   "owner": "maintainer",
   "review_by": "2027-08-18",
   "metric": {
-    "basis": "src/scripts/check_estate_count.ts. The live side uses collect() from update_roadmap_progress \u2014 the same parser the dashboard is generated from, imported rather than re-implemented. The floor side runs the SAME functions over a scratch copy of the base ref's agents/roadmaps/, materialised by _lib/base_tree.ts (git ls-tree + git cat-file --batch; `git archive` cannot be used here because .gitattributes carries `/agents export-ignore` and would yield an empty, silently-zero tree).",
+    "basis": "src/scripts/check_estate_count.ts. The live side uses collect() from update_roadmap_progress \u2014 the same parser the dashboard is generated from, imported rather than re-implemented. The floor side runs the SAME functions over a scratch copy of the base ref's agents/roadmaps/, materialised by _lib/base_tree.ts (git ls-tree + git cat-file --batch; `git archive` cannot be used here because .gitattributes carries `/agents export-ignore` and would yield an empty, silently-zero tree). SKILL METRICS (added 2026-08-24): _lib/skill_estate.ts walks src/skills/*/SKILL.md under the SAME root, so the floor side measures the base ref's own skill tree with the same function. That needs a SECOND materialised subtree \u2014 materialiseSubtree takes one prefix \u2014 and the two are independent on purpose: a base ref with no src/skills (an old tag, a shallow clone) drops the skill metrics and leaves the roadmap metrics ratcheting.",
     "active_roadmaps": "non-draft roadmap candidates at the top level of agents/roadmaps/, as collect() counts them. This is exactly the number the dashboard header prints as 'N open roadmaps'.",
     "later_roadmaps": "roadmap-shaped *.md files under agents/roadmaps/later/ \u2014 the same is_roadmap_candidate name filter the active side uses, so later/README.md is not counted. Counted from the filesystem because parked roadmaps sit outside collect()'s corpus by design; they are estate all the same, and a drawdown that moved everything into later/ and called the number down would be the burial T1's quality anchor exists to prevent.",
     "open_blockers": "blockers whose Status does not start with `resolved`, summed over the active and later corpora.",
-    "floor": "the same three metrics measured at the base ref (origin/main, else the merge commit's first parent). No base ref resolves -> no floor -> the gate FAILS rather than skipping: a shrink-only gate with no floor passes every possible tree. `--base <ref>` is the explicit escape."
+    "floor": "the same three metrics measured at the base ref (origin/main, else the merge commit's first parent). No base ref resolves -> no floor -> the gate FAILS rather than skipping: a shrink-only gate with no floor passes every possible tree. `--base <ref>` is the explicit escape.",
+    "skill_count": "Maintained src/skills/*/SKILL.md files; `lifecycle: deprecated` EXCLUDED. The exclusion is load-bearing rather than tidy: with deprecated skills counted, deprecating one would create no headroom and the retirement mechanism would be unusable against its own gate. 0 skills carry it today, so the exclusion is a no-op now and a correctness property once a tranche lands. Measured 2026-08-24: 299. Reproduce with `find src/skills -name SKILL.md | wc -l` (299 including any deprecated) or `npx tsx -e \"import {measureSkillEstate} from './src/scripts/_lib/skill_estate.ts'; console.log(measureSkillEstate(process.cwd()))\"` for the split.",
+    "skill_description_tokens": "Exact-BPE tokens (js-tiktoken, cl100k_base, via _lib/token_count.ts gpt_tokens) across those skills' `description:` frontmatter fields ONLY \u2014 not bodies. Measured 2026-08-24: 11,461 over 299 skills (52,983 chars). A SECOND DIMENSION, not a companion figure: a count ratchet alone is gameable by merging four large skills into one file, which lowers the count while the description payload a host must carry stays put. AI council 2/2 (2026-08-24) asked for both in one gate over the roadmap's own recommendation of count-plus-informational-figure. UNRESOLVED rather than approximated: when the tokeniser does not resolve on either side the metric is dropped from the compare with a printed reason, because an exact reading against a proxy one differs by more than the growth this gate is trying to catch.",
+    "skill_metric_rejected_candidates": "Measured before choosing, not argued. (b) catalogue bytes via _lib/skill_catalogue.ts read 0 on a real checkout: readProjectedCatalogue walks .claude/skills, empty in any tree where `task generate-tools` cannot complete (it fails under projection.mode=scoped without the config package) \u2014 a ratchet whose reading depends on whether a generator ran reds for the environment. (d) host-listing slots are the host's decision, not the repository's: a measured install published its own budget event stating it had stripped every description and dropped 402 entries. Neither is reproducible from the repo, so neither can carry a floor."
   },
   "growth_allowances": {
     "_comment": "An exact floor leaves no incidental headroom, so every legitimate increase needs a named path. Two are automatic because existing policy already sanctions the act; the third is the general authorisation.",
     "active_roadmaps": "+1 per addition carrying `estate_offset_exempt: <reason>` in its own frontmatter (unchanged T3 key). Without this the sanctioned un-offsettable addition would fail the count half with no green path.",
     "later_roadmaps": "+1 per roadmap moved from the active top level into later/ in the same change. Parking relocates estate rather than creating it. It does NOT cover a later/ file that appears from nowhere, and it is keyed on parking rather than on any offset so that an archive move cannot buy a new later/ file.",
     "open_blockers": "none. Nothing in the policy sanctions a new blocker, so it takes the claim path or nothing.",
-    "claim": "`estate_growth_exempt: <reason>` added, in this change, to the frontmatter of any roadmap under agents/roadmaps/. Authorises growth in any metric, with the reason printed. Diff-scoped, so a claim left in a file authorises nothing later \u2014 the banking failure a stored baseline had. Deliberately unbounded, which a stored baseline could not afford: there the surplus of an over-raise was inherited by the next change, where nobody could act on it; here the next change's floor IS this change's measurement, so there is no surplus to inherit."
+    "claim": "`estate_growth_exempt: <reason>` added, in this change, to the frontmatter of any roadmap under agents/roadmaps/. Authorises growth in any metric, with the reason printed. Diff-scoped, so a claim left in a file authorises nothing later \u2014 the banking failure a stored baseline had. Deliberately unbounded, which a stored baseline could not afford: there the surplus of an over-raise was inherited by the next change, where nobody could act on it; here the next change's floor IS this change's measurement, so there is no surplus to inherit.",
+    "skill_count": "0 \u2014 no allowance, deliberately. The defect this metric addresses is a corpus that grew +8 in one release (290 at 14.0.0, 291 at 14.9.0 and 14.10.0, 299 at 14.11.0) with nothing objecting. An addition takes the estate_growth_exempt claim path \u2014 a recorded reason read from the diff \u2014 or it fails.",
+    "skill_description_tokens": "0 \u2014 same reasoning. An addition that grows the description payload without adding a file is the gaming path this dimension exists to close, and an allowance would reopen it."
   },
   "target": {
     "_comment": "T1's proposed ceilings, kept as the destination. PROPOSALS, NOT REGISTERED: the roadmap says in as many words that both numbers and the window belong to the maintainer, and no date is pinned in this file. Nothing reads these values \u2014 `one_in_one_out.applies_above_active` is the only threshold the gate evaluates.",