@event4u/agent-config 14.1.0 → 14.4.0

package/dist/shared/settingsConsent.js

@@ -33,12 +33,19 @@
  * @see docs/contracts/settings-classes.md
  */
 import { isConservativeDefault } from './settingsClasses.js';
+/** Keys `org-pack` provenance may grant. ADR-233 § D2. */
+const ORG_PACK_KEY_PREFIX = 'telemetry.remote.';
 /**
  * The sources that can carry a human decision.
  *
  * `jit-answer` is a question the user answered. `gui` is a human at the settings
  * editor. `manual` is a hand-edit or an explicit CLI write on the user's
  * instruction. `auto-detected` is excluded on purpose — see the module header.
+ *
+ * `org-pack` is NOT in this list, and its absence is not an oversight: it
+ * grants, but only for one namespace, so it is handled by its own branch in
+ * `consentVerdict` rather than by membership here. Putting it in this list
+ * would make it grant everywhere, which is the erosion ADR-233 § D2 refuses.
  */
 const HUMAN_SOURCES = ['jit-answer', 'gui', 'manual'];
 /**
@@ -55,6 +62,21 @@ export function consentVerdict(query) {
     if (isConservativeDefault(query.value)) {
         return 'withheld-default';
     }
+    // The org-pack branch runs BEFORE the hand-edit branch, and the order is
+    // the fix rather than a style choice. `handEdited` is true for a
+    // project-local `.agent-settings.yml` — which is precisely the file an org
+    // pack ships — so with hand-edit first, a recorded `org-pack` provenance
+    // on an out-of-scope key would be granted by the wrong branch and ADR-233
+    // § D2's namespace scope would hold for no real deployment. A recorded
+    // source is the more specific fact and decides first.
+    if (query.source === 'org-pack') {
+        // A human decided, but not the human this value binds — so the grant
+        // is real and narrow. An absent key cannot be shown to be in scope,
+        // and unproven is withheld here as everywhere else in this function.
+        return query.key !== undefined && query.key.startsWith(ORG_PACK_KEY_PREFIX)
+            ? 'granted'
+            : 'withheld-org-pack-out-of-scope';
+    }
     if (query.handEdited === true) {
         return 'granted';
     }
@@ -86,6 +108,9 @@ export function withheldReason(verdict, key) {
             return `${key} permits this, but nothing records who decided it. Ask, or set it via the GUI.`;
         case 'withheld-machine-inferred':
             return `${key} was auto-detected, not decided. A machine inference is not a consent.`;
+        case 'withheld-org-pack-out-of-scope':
+            return `${key} carries an org-pack consent, which grants only under `
+                + `${ORG_PACK_KEY_PREFIX}* (ADR-233). Ask this user directly.`;
         case 'not-a-consent-key':
             return `${key} is not a class-B consent key — this gate does not apply to it.`;
     }

package/dist/shared/settingsConsent.js.map

@@ -1 +1 @@
-{"version":3,"file":"settingsConsent.js","sourceRoot":"","sources":["../../src/shared/settingsConsent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,qBAAqB,EAAsB,MAAM,sBAAsB,CAAC;AAKjF;;;;;;GAMG;AACH,MAAM,aAAa,GAA6B,CAAC,YAAY,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;AAsChF;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,KAAmB;IAC9C,IAAI,KAAK,CAAC,GAAG,KAAK,GAAG,EAAE,CAAC;QACpB,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IACD,IAAI,qBAAqB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,OAAO,kBAAkB,CAAC;IAC9B,CAAC;IACD,IAAI,KAAK,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;QAC5B,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,qBAAqB,CAAC;IACjC,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QACxC,OAAO,2BAA2B,CAAC;IACvC,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,cAAc,CAAC,KAAmB;IAC9C,OAAO,cAAc,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC;AAC/C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,OAAuB,EAAE,GAAW;IAC/D,QAAQ,OAAO,EAAE,CAAC;QACd,KAAK,SAAS;YACV,OAAO,IAAI,CAAC;QAChB,KAAK,kBAAkB;YACnB,OAAO,GAAG,GAAG,sEAAsE,CAAC;QACxF,KAAK,qBAAqB;YACtB,OAAO,GAAG,GAAG,gFAAgF,CAAC;QAClG,KAAK,2BAA2B;YAC5B,OAAO,GAAG,GAAG,wEAAwE,CAAC;QAC1F,KAAK,mBAAmB;YACpB,OAAO,GAAG,GAAG,iEAAiE,CAAC;IACvF,CAAC;AACL,CAAC"}
+{"version":3,"file":"settingsConsent.js","sourceRoot":"","sources":["../../src/shared/settingsConsent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,qBAAqB,EAAsB,MAAM,sBAAsB,CAAC;AAejF,0DAA0D;AAC1D,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,aAAa,GAA6B,CAAC,YAAY,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;AAiDhF;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,KAAmB;IAC9C,IAAI,KAAK,CAAC,GAAG,KAAK,GAAG,EAAE,CAAC;QACpB,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IACD,IAAI,qBAAqB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,OAAO,kBAAkB,CAAC;IAC9B,CAAC;IACD,yEAAyE;IACzE,iEAAiE;IACjE,2EAA2E;IAC3E,yEAAyE;IACzE,0EAA0E;IAC1E,uEAAuE;IACvE,sDAAsD;IACtD,IAAI,KAAK,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QAC9B,qEAAqE;QACrE,oEAAoE;QACpE,qEAAqE;QACrE,OAAO,KAAK,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,mBAAmB,CAAC;YACvE,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,gCAAgC,CAAC;IAC3C,CAAC;IACD,IAAI,KAAK,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;QAC5B,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,qBAAqB,CAAC;IACjC,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QACxC,OAAO,2BAA2B,CAAC;IACvC,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,cAAc,CAAC,KAAmB;IAC9C,OAAO,cAAc,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC;AAC/C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,OAAuB,EAAE,GAAW;IAC/D,QAAQ,OAAO,EAAE,CAAC;QACd,KAAK,SAAS;YACV,OAAO,IAAI,CAAC;QAChB,KAAK,kBAAkB;YACnB,OAAO,GAAG,GAAG,sEAAsE,CAAC;QACxF,KAAK,qBAAqB;YACtB,OAAO,GAAG,GAAG,gFAAgF,CAAC;QAClG,KAAK,2BAA2B;YAC5B,OAAO,GAAG,GAAG,wEAAwE,CAAC;QAC1F,KAAK,gCAAgC;YACjC,OAAO,GAAG,GAAG,wDAAwD;kBAC/D,GAAG,mBAAmB,sCAAsC,CAAC;QACvE,KAAK,mBAAmB;YACpB,OAAO,GAAG,GAAG,iEAAiE,CAAC;IACvF,CAAC;AACL,CAAC"}

package/docs/contracts/settings-classes.md

@@ -34,6 +34,17 @@ who consented and when. `expires_at` / `revoked_at` / contract-version fields
 stay deliberately unbuilt until a reader needs them — a field nothing reads is
 surface without a consumer.
 
+**A fifth source exists on the READ side only: `org-pack`** (ADR-233). It
+records that a human org administrator decided, which is a consent — but one
+given by someone other than the person it binds, so it grants **only** for
+keys under `telemetry.remote.*` and withholds everywhere else. It is
+deliberately absent from `settings:set`'s own `ProvenanceSource`, so
+`--source org-pack` is rejected like a typo and no agent-reachable path can
+write it; the org-pack install route writes the sidecar entry directly. That
+asymmetry between the reader's vocabulary and the writer's is the safety
+property rather than an inconsistency — `auto-detected` remains never-consent
+verbatim, and this class must not become the precedent that erodes it.
+
 ## What the fence covers — and what it does not
 
 **It governs writes, not reads.** Every class is readable by everything. A C

package/docs/guidelines/agent-infra/roadmap-progress-mechanics.md

@@ -233,7 +233,8 @@ When the closure check fires (`count_open == 0` and `count_deferred > 0`), the a
    3. **Keep in this archive** — confirm the deferred items stay searchable in the archived file; no follow-up roadmap. Choosing this records an explicit decision-to-drop in the same reply.
    4. **Restore selected items to `[ ]`** — finish them in this roadmap before archive.
    5. **Convert selected items to `[-]` cancelled** — drop them with rationale recorded inline.
-3. Only after the user resolves the deferrals does the `git mv` to `archive/` run. The dashboard regen happens after the resolution, not before.
+3. Route by the **preservation test** — full table, recording contract and residual limit in [`roadmap-progress-sync § Who resolves it`](../../../src/rules/roadmap-progress-sync.md). In one line: options 1, 2, 4 keep the item alive → council; 3 and 5 drop or weaken it → user, always; in doubt, user.
+4. Only after the deferrals are resolved does the `git mv` to `archive/` run. The dashboard regen happens after the resolution, not before.
 
 The migration mechanics (file naming, frontmatter pattern, body shape, parent-back-link) live in `roadmap-management § Spawn follow-up from deferred items`. The rule owns the obligation; the skill owns the procedure.
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@event4u/agent-config",
     "mcpName": "io.github.event4u-app/agent-config",
-    "version": "14.1.0",
+    "version": "14.4.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,

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

@@ -16,14 +16,19 @@
  *
  * ## What it can and cannot decide, stated plainly
  *
- * A resume condition is prose. Two shapes are machine-decidable and the rest
- * are not, so the verdict set has three values rather than two:
+ * A resume condition is prose. TWO shapes are machine-decidable — a roadmap
+ * reference, and a single repo-relative file path under an existence predicate
+ * — and the rest are not, so the verdict set has three values rather than two:
  *
  *   - `fired`       — every roadmap the condition names has archived, or the
- *                     named step in a still-active roadmap is ticked.
+ *                     named step in a still-active roadmap is ticked; or the
+ *                     single path it names under `exists` is there.
  *   - `unmet`       — at least one named roadmap is still active with the
- *                     named step (or the whole file) still open.
- *   - `undecidable` — the condition names no roadmap this tree can resolve.
+ *                     named step (or the whole file) still open; or the single
+ *                     path it names under `exists` is absent.
+ *   - `undecidable` — the condition names neither, names both (a conjunction
+ *                     this probe can only half-weigh), names two of either, or
+ *                     states a predicate other than existence over its path.
  *
  * `undecidable` is reported as its own count and never folded into "nothing
  * fired". A probe that reads 44 files, understands 12 of them and announces
@@ -84,6 +89,31 @@ const COMPOUND_RE = /\bboth\b|\band\b|\([1-9]\)|\([a-e]\)|`[ \t]*\+|\+[ \t]*`/i;
 const FIELD_LABEL_RE = /\*\*[^*]+:\*\*/;
 /** A roadmap slug as written in prose, with or without the `.md` suffix. */
 const ROADMAP_REF_RE = /\broad-to-[a-z0-9][a-z0-9-]*\b/g;
+
+/**
+ * A repo-relative path named inside backticks — the second decidable form.
+ *
+ * `PARK-PROBEABLE` (`road-to-estate-drawdown` Phase 2) means the resume
+ * condition can be tested by a script, and until this existed the probe could
+ * decide exactly one phrasing: a roadmap slug. Measured 2026-08-19 on the live
+ * estate, 42 of 44 park notes were `undecidable`, and the batch-1 sweep could
+ * only add six more — a verdict whose name promised a probe that did not read
+ * the conditions it was producing.
+ *
+ * Deliberately narrow in three ways, because a false FIRED un-parks live work:
+ * the path must be **inside backticks** (prose that merely contains a slash is
+ * not a condition), it must start at a **known top-level repo directory** and
+ * end in a **file extension**, and the clause must name **exactly one** — two
+ * paths are a conjunction this function cannot weigh, and `COMPOUND_RE` does
+ * not catch a comma.
+ *
+ * The extension requirement is what keeps a *directory* out. `agents/evidence/`
+ * exists in every checkout, so "recorded under `agents/evidence/`" is not a
+ * condition a probe can decide — and since `_exists` tests `isFile()`, matching
+ * it would have reported "does not exist" about a directory that does. A
+ * directory-shaped condition stays `undecidable`, which is the honest verdict.
+ */
+const REPO_PATH_RE = /`((?:agents|docs|src|tests|internal|scripts|evals|\.github)\/[A-Za-z0-9._\-/]*[A-Za-z0-9_\-]\.[A-Za-z0-9]{2,5})`/g;
 /**
  * A step reference: `P2.1`, `Phase 2.1`, or a bare `2.1`.
  *
@@ -231,6 +261,37 @@ function _blankFencedCode(text: string): string {
     );
 }
 
+/**
+ * The head of `s` up to its first sentence terminator OUTSIDE backticks.
+ *
+ * A naive character-class scan that stops at any dot cuts inside `foo.md` or
+ * inside a step id like `3.3`, which truncates the clause mid-span and hides
+ * the very path or step the condition names. Measured 2026-08-19: three of the six park notes written by
+ * `road-to-estate-drawdown` Phase 2 batch 1 lost their backticked path this
+ * way, and the probe then reported "names no roadmap this tree can resolve"
+ * about a condition that named a file.
+ */
+function _sentenceHead(s: string): string {
+    // An ODD backtick count means the span never closes, and toggling on it
+    // would leave `inCode` stuck true for the whole remainder — the commentary
+    // paragraph then becomes the clause, and a path mentioned only in that
+    // commentary could decide the verdict. Fall back to the plain scan, which
+    // cuts at the first terminator and is the conservative direction.
+    const balanced = (s.match(/`/g) ?? []).length % 2 === 0;
+    let inCode = false;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i] as string;
+        if (ch === '`' && balanced) {
+            inCode = !inCode;
+            continue;
+        }
+        if (!inCode && (ch === '.' || ch === '—' || ch === '–')) {
+            return s.slice(0, i);
+        }
+    }
+    return s;
+}
+
 /**
  * The condition CLAUSE inside the condition text.
  *
@@ -260,13 +321,63 @@ function conditionClause(condition: string): string {
             // (`**Resume when** that pruning lands`), so take the span plus the
             // remainder of its sentence — up to an em dash or a full stop.
             const after = condition.slice(m.index + m[0].length);
-            const tail = /^[^—–.]*/.exec(after)?.[0] ?? '';
-            return `${span}${tail}`;
+            return `${span}${_sentenceHead(after)}`;
         }
     }
     return condition;
 }
 
+/**
+ * The clause's predicate is EXISTENCE, not some property of the file's content.
+ *
+ * Without this the path branch would answer a question the condition did not
+ * ask. Measured 2026-08-19 while writing it: `road-to-catalogue-host-fit` waits
+ * until `agents/evidence/metrics/skill-catalogue.jsonl` *holds at least 20
+ * observations*; the file exists today with 7 lines, so an existence test would
+ * have reported FIRED and un-parked a roadmap whose bar is 13 observations away.
+ * A content bar is decidable — by `capture_skill_catalogue --cadence` — but not
+ * by this probe, and `undecidable` is the honest verdict for it.
+ *
+ * The predicate is bound POSITIONALLY to the path rather than tested as a word
+ * anywhere in the clause, because word-presence is not a predicate: `\`x.md\` no
+ * longer exists` would have reported FIRED while the file was still there, and
+ * `blocked until a workaround exists, see \`docs/x.md\`` would have paired the
+ * word with a path it does not govern. Both shapes are regression tests.
+ *
+ * KNOWN LIMIT, stated rather than papered over: this probe reads the condition
+ * AFTER `_truncateAtNextField`, so a content bar an author moves into a sibling
+ * bolded field is invisible to it and the note decides as bare existence. That
+ * is an authoring bypass no check here can see — the guard is that a resume
+ * condition states its whole bar inside the condition, and it is model-carried.
+ */
+const EXISTENCE_PREDICATE_RE = /`(?:agents|docs|src|tests|internal|scripts|evals|\.github)\/[A-Za-z0-9._\-/]+`[ \t]*(?:currently[ \t]+)?exists\b/i;
+
+/**
+ * The single repo-relative path a condition names, or `null`.
+ *
+ * `null` for zero paths (nothing to test) and for two or more (a conjunction
+ * this probe cannot weigh — reporting FIRED on the first would be the
+ * partial-match resume the compound guard already refuses).
+ */
+function referencedPath(condition: string): string | null {
+    if (!EXISTENCE_PREDICATE_RE.test(condition)) {
+        return null;
+    }
+    const paths = _pathsIn(condition);
+    return paths.length === 1 ? (paths[0] as string) : null;
+}
+
+/** Every distinct repo-relative file path a clause names, predicate or not. */
+function _pathsIn(condition: string): string[] {
+    REPO_PATH_RE.lastIndex = 0;
+    const found = new Set<string>();
+    let m: RegExpExecArray | null;
+    while ((m = REPO_PATH_RE.exec(condition)) !== null) {
+        found.add(m[1] as string);
+    }
+    return [...found].sort();
+}
+
 /** Roadmap slugs named by the condition, minus the parked file's own slug. */
 function referencedRoadmaps(condition: string, ownSlug: string): string[] {
     const out = new Set<string>();
@@ -310,7 +421,10 @@ function stepIsDone(text: string, stepId: string): boolean | null {
  * tree rather than the live estate — a probe whose only test is the live tree
  * stops testing anything the day the live tree changes.
  */
-function probeLater(roadmapRoot: string): ResumeFinding[] {
+function probeLater(roadmapRoot: string, repoRootArg?: string): ResumeFinding[] {
+    // Defaults to the repo that owns `agents/roadmaps/`. Passed explicitly by
+    // the tests, whose fixture tree IS the roadmap root and has no repo above it.
+    const repoRoot = repoRootArg ?? path.resolve(roadmapRoot, '..', '..');
     const laterDir = path.join(roadmapRoot, 'later');
     let entries: string[];
     try {
@@ -353,13 +467,43 @@ function probeLater(roadmapRoot: string): ResumeFinding[] {
             continue;
         }
         const refs = referencedRoadmaps(clause, ownSlug);
+        // A clause naming a roadmap AND a path is a conjunction, and deciding it
+        // on the roadmap half alone is the partial-match resume `COMPOUND_RE`
+        // already refuses for two roadmaps. `COMPOUND_RE` does not close it —
+        // a comma joins the two without an `and`, which is the same hole the
+        // two-paths rule in `referencedPath` exists for. Refused symmetrically.
+        if (refs.length > 0 && _pathsIn(clause).length > 0) {
+            findings.push({
+                file: `later/${name}`,
+                condition,
+                refs,
+                verdict: 'undecidable',
+                why: 'names a roadmap and a repo path — a conjunction the probe can only half-weigh',
+            });
+            continue;
+        }
         if (refs.length === 0) {
+            // Second decidable form: a single repo-relative path. `exists` is
+            // the whole test — the condition says the artefact will appear, so
+            // its appearance IS the firing, and no content check is implied.
+            const rel = referencedPath(clause);
+            if (rel !== null) {
+                const there = _exists(path.join(repoRoot, rel));
+                findings.push({
+                    file: `later/${name}`,
+                    condition,
+                    refs,
+                    verdict: there ? 'fired' : 'unmet',
+                    why: there ? `${rel} exists` : `${rel} does not exist`,
+                });
+                continue;
+            }
             findings.push({
                 file: `later/${name}`,
                 condition,
                 refs,
                 verdict: 'undecidable',
-                why: 'the condition names no roadmap this tree can resolve',
+                why: 'the condition names no roadmap or repo path this tree can resolve',
             });
             continue;
         }
@@ -414,6 +558,7 @@ export {
     conditionClause,
     extractCondition,
     probeLater,
+    referencedPath,
     referencedRoadmaps,
     roadmapDisposition,
     stepIsDone,

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

@@ -342,6 +342,201 @@ function render(
  * Returns '' when nothing is owned by the user, so the caller can append the
  * result unconditionally and get silence when silence is correct.
  */
+/**
+ * Whether a recorded recommendation was drafted by the agent rather than decided
+ * by the maintainer.
+ *
+ * Read from the field's own text, because that is where the claim has to live: a
+ * drafted recommendation is written INTO the roadmap so every consumer
+ * (`gates`, `--reply`, the sheet) sees the same string, and a marker held only
+ * in the sheet would be invisible to the other two. The convention is a leading
+ * `(agent-drafted …)` — matched loosely on purpose, since the parenthetical also
+ * carries a date and a sentence of provenance.
+ */
+export function isAgentDrafted(recommendation: string): boolean {
+    return /\(agent-drafted\b/i.test(recommendation);
+}
+
+/**
+ * How a row names its decision.
+ *
+ * `legacy` is the parser's PLACEHOLDER id for a `> Blocked until …` note, not an
+ * identifier anyone wrote — `renderEntry` already substitutes "blocked-until
+ * note" for exactly that reason, and the sheet printing the raw placeholder made
+ * the two views disagree about the same row.
+ */
+export function sheetLabel(b: Blocker): string {
+    return isLegacy(b) ? 'blocked-until note' : `\`${b.id}\``;
+}
+
+/** First sentence of a passage, for the one-line `Default:` column. */
+function firstSentence(text: string): string {
+    const trimmed = text.trim();
+    if (trimmed === '') {
+        return '';
+    }
+    const m = /^(.+?[.!?])(\s|$)/.exec(trimmed.replace(/\s+/g, ' '));
+    return m === null ? trimmed.replace(/\s+/g, ' ') : (m[1] as string);
+}
+
+/**
+ * The one-line question a sheet row leads with.
+ *
+ * `Question:` is an optional field and only 5 of the 21 user-owned entries carry
+ * one (measured 2026-08-18), so a sheet that printed it and nothing else would
+ * be blank for three quarters of the estate. Falling back to the first step of
+ * `What to do:` and then to `Blocks:` is deterministic and derived from the
+ * blocker's own text — which is why the row LABELS which of the three it used
+ * rather than presenting all three as the same kind of statement.
+ */
+export function sheetQuestion(b: Blocker): { text: string; source: 'question' | 'todo' | 'blocks' } {
+    if (b.question.trim() !== '') {
+        return { text: firstSentence(b.question), source: 'question' };
+    }
+    const steps = regroupTodo(b.todo);
+    if (steps.length > 0 && (steps[0] as string).trim() !== '') {
+        return { text: firstSentence(steps[0] as string), source: 'todo' };
+    }
+    return { text: firstSentence(b.blocks), source: 'blocks' };
+}
+
+/**
+ * The consolidated decision sheet — every user-owned decision in ONE artefact.
+ *
+ * `road-to-estate-drawdown` Phase 0 exists because thirteen reading assignments
+ * spread across thirteen files did not happen once. The sheet is the whole of
+ * the human's contribution to that campaign, front-loaded: one document, sorted
+ * by how much each answer unblocks, with a default per item so that
+ * accept-all-defaults is a valid answer.
+ *
+ * This differs from `--all` in the two ways that matter for that job. `--all`
+ * renders every blocker grouped by owner and is a terminal view; the sheet is
+ * user-owned ONLY, and every row carries a `Default:` plus the PROVENANCE of
+ * that default. Provenance is the load-bearing column: a sheet that presented an
+ * agent-drafted default beside a maintainer-recorded one as the same thing would
+ * invite accept-all over exactly the items nobody has examined.
+ *
+ * No population figure is quoted here on purpose. The first version cited
+ * "14 of 21 record a `Recommendation:`, 7 do not" as the justification, and the
+ * change that added this renderer then drafted six of those seven — so the
+ * docstring was contradicted by the sheet committed beside it (R2 finding).
+ * The split is rendered in the sheet's own header from the live tree, which is
+ * the only place it cannot go stale.
+ *
+ * Deterministic by construction — the generator never invents a default. Where
+ * none is recorded it says so and names what the reader must supply, so
+ * regenerating the sheet cannot silently overwrite an answer with a guess.
+ */
+function renderSheet(entries: readonly Entry[], now: Date): string {
+    const mine = entries.filter((e) => needsUser(e.blocker.owner));
+    const stamp = now.toISOString().slice(0, 10);
+    if (mine.length === 0) {
+        return (
+            `# Consolidated decision sheet — nothing owned by you (${stamp})\n\n` +
+            'No open blocker in the active roadmap tree carries `Owner: user`. Nothing to answer.\n'
+        );
+    }
+
+    const noRec = mine.filter((e) => e.blocker.recommendation.trim() === '');
+    const legacyNotes = noRec.filter((e) => isLegacy(e.blocker)).length;
+    const missing = noRec.length - legacyNotes;
+    const drafted = mine.filter((e) => isAgentDrafted(e.blocker.recommendation)).length;
+    const maintainerRecorded = mine.length - noRec.length - drafted;
+    const out: string[] = [
+        `# Consolidated decision sheet — ${String(mine.length)} decisions owned by you`,
+        '',
+        `> Generated ${stamp} by \`agent-config gates --sheet\` over \`agents/roadmaps/\`.`,
+        '> Sorted by unblock count, descending. **Accept-all-defaults is a valid answer**',
+        '> (`road-to-estate-drawdown` blocker `b-consolidated-decision-sheet`, option (a));',
+        '> answering only the two largest-unblock items and deferring the rest is option (c),',
+        '> which the roadmap itself recommends. Whichever you pick, the agent writes the answers',
+        '> back into each roadmap at its own blocker — that is not your work.',
+        '>',
+        `> **Provenance of the ${String(mine.length)} defaults: ${String(maintainerRecorded)} maintainer-recorded ·`,
+        `> ${String(drafted)} \`agent-drafted\` · ${String(missing)} with no recommendation at all ·`,
+        `> ${String(legacyNotes)} legacy \`> Blocked until …\` note(s) that have no field to carry one.**`,
+        '> The distinction is in every row on purpose: an agent-drafted default is the',
+        '> least-examined thing on this sheet, and accept-all-defaults would accept those too.',
+        '>',
+        '> This file is DERIVED — every line above and below comes from the roadmaps themselves,',
+        '> so regenerating is deterministic and an answer written into this file would be lost.',
+        '> Answers go back into each roadmap at its own blocker; the agent does that.',
+        '',
+        '| # | Decision | Roadmap | Unblocks | Default source |',
+        '|---:|---|---|---:|---|',
+    ];
+    mine.forEach((e, i) => {
+        const source =
+            e.blocker.recommendation.trim() !== ''
+                ? isAgentDrafted(e.blocker.recommendation)
+                    ? '`agent-drafted`'
+                    : 'maintainer-recorded'
+                : isLegacy(e.blocker)
+                  ? 'none — legacy note'
+                  : 'none recorded';
+        out.push(
+            `| ${String(i + 1)} | ${sheetLabel(e.blocker)} | ${e.roadmapRel} | ` +
+                `${String(e.openSteps)} | ${source} |`,
+        );
+    });
+
+    mine.forEach((e, i) => {
+        const q = sheetQuestion(e.blocker);
+        const qLabel =
+            q.source === 'question'
+                ? 'recorded `Question:`'
+                : q.source === 'todo'
+                  ? 'derived from the first `What to do:` step'
+                  : 'derived from `Blocks:`';
+        const recorded = e.blocker.recommendation.trim();
+        out.push(
+            '',
+            `## ${String(i + 1)} · ${sheetLabel(e.blocker)}`,
+            '',
+            `- **Roadmap:** ${e.roadmapRel}`,
+            `- **Unblocks:** ${String(e.openSteps)} open step(s) — ${e.blocker.blocks || '(not recorded)'}`,
+            `- **Question** (${qLabel})**:** ${q.text || '(the blocker records no question, no steps and no Blocks: field)'}`,
+        );
+        if (recorded === '' && isLegacy(e.blocker)) {
+            // A legacy `> Blocked until …` note is not a `### blocker:` entry and
+            // has no field to carry a recommendation. Saying "agent-drafted, to
+            // be written in" would point at a slot that does not exist, so the
+            // row names the actual next action instead.
+            out.push(
+                '- **Default:** _this is a legacy `> Blocked until …` note, not a `### blocker:` entry,' +
+                    ' so it has no `Recommendation:` field to read. Converting it into a real blocker' +
+                    ' entry is what gives it a default._',
+                '- **Default source:** none — legacy note',
+            );
+        } else if (recorded === '') {
+            out.push(
+                '- **Default:** _none recorded — needs an agent-drafted default before this row can be' +
+                    ' answered by accepting it._',
+                '- **Default source:** `agent-drafted` (to be written in below, and marked as such)',
+            );
+        } else {
+            const drafted = isAgentDrafted(recorded);
+            out.push(
+                `- **Default:** ${firstSentence(recorded)}`,
+                drafted
+                    ? '- **Default source:** `agent-drafted` — written into the roadmap’s ' +
+                      '`Recommendation:` field and marked there, NOT a maintainer decision'
+                    : '- **Default source:** maintainer-recorded `Recommendation:` in the roadmap',
+                `- **Recommendation (full):** ${recorded.replace(/\s+/g, ' ')}`,
+            );
+        }
+        if (e.blocker.ifNothing.trim() !== '') {
+            out.push(`- **If you do nothing:** ${e.blocker.ifNothing.replace(/\s+/g, ' ')}`);
+        }
+        out.push(
+            `- **Done when:** ${e.blocker.resolvedWhen.replace(/\s+/g, ' ') || '(not recorded)'}`,
+            '- **Your answer:** _(accept default · override · defer)_',
+        );
+    });
+    out.push('');
+    return out.join('\n');
+}
+
 function renderReply(entries: readonly Entry[]): string {
     const mine = entries.filter((e) => needsUser(e.blocker.owner));
     if (mine.length === 0) {
@@ -564,6 +759,7 @@ function main(argv?: readonly string[]): number {
     const json = args.includes('--json');
     const reply = args.includes('--reply');
     const pending = args.includes('--pending');
+    const sheet = args.includes('--sheet');
 
     // `--execute <id>` is answered FIRST, and it is the only mode that writes.
     // It used to sit after the `--pending` early return, so `--pending
@@ -643,13 +839,20 @@ function main(argv?: readonly string[]): number {
     // `--reply` deliberately does not carry the probe: ADR-222 fixes that form
     // at exactly ONE decision rendered in full, and a fired resume condition is
     // not a decision the reader owes anybody — it is a file that can move.
-    const resumed = reply ? [] : probeLater(roadmapRoot);
+    // `--reply` and `--sheet` deliberately do not carry the probe: ADR-222 fixes
+    // the reply form at exactly ONE decision rendered in full, and a fired resume
+    // condition is not a decision the reader owes anybody — it is a file that can
+    // move. The sheet is the same argument for the same reason: it is the set of
+    // answers the user owes, and a movable file is not one of them.
+    const resumed = reply || sheet ? [] : probeLater(roadmapRoot, repoRoot);
     process.stdout.write(
-        reply
-            ? renderReply(entries)
-            : json
-              ? renderJson(entries, all, resumed)
-              : render(entries, all, resumed),
+        sheet
+            ? renderSheet(entries, new Date())
+            : reply
+              ? renderReply(entries)
+              : json
+                ? renderJson(entries, all, resumed)
+                : render(entries, all, resumed),
     );
     return 0;
 }
@@ -687,6 +890,7 @@ export {
     renderJson,
     renderReply,
     renderResumed,
+    renderSheet,
     renderPending,
     renderPendingJson,
 };