@event4u/agent-config 13.0.0 → 14.0.0

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

@@ -0,0 +1,422 @@
+/**
+ * Resume-condition probe — a gate that opened with nobody standing in front
+ * of it is the third failure shape `road-to-gate-autonomy` § 0 names.
+ *
+ * Every roadmap parked under `agents/roadmaps/later/` records a resume
+ * condition; `lint_roadmap_later_disposition` enforces that one is **written**
+ * and never asks whether it has since come true. Measured 2026-08-17:
+ * `later/road-to-request-scoped-rule-load.md` waits on "P2.1 of
+ * `road-to-rule-delivery-integrity` closes", and that whole roadmap archived —
+ * the condition fired, the file stayed parked, and nothing in the tree could
+ * have said so.
+ *
+ * This is a **class-0 gate** by the § 2 taxonomy: deterministic, free,
+ * reversible, and its output IS the unblock signal. It decides nothing — it
+ * reports which parked roadmaps are now resumable and hands that to a human.
+ *
+ * ## 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:
+ *
+ *   - `fired`       — every roadmap the condition names has archived, or the
+ *                     named step in a still-active roadmap is ticked.
+ *   - `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.
+ *
+ * `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
+ * silence is the gate-that-scans-nothing shape this repo has already paid for
+ * once; the honest form says how much of the population it could actually read.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/**
+ * The markers this probe treats as a DEPENDENCY condition.
+ *
+ * Deliberately NARROWER than `lint_roadmap_later_disposition`'s set, which
+ * also accepts a bare `trigger`. That lint answers "is a condition recorded",
+ * where any of the five words is evidence; this probe answers "has it fired",
+ * and in this tree `Trigger:` is overwhelmingly a *provenance* idiom —
+ * "**Trigger:** Spun out of `road-to-governance-moat` (Iron Law 3 …)" names
+ * where the roadmap came from, not what it waits for. Measured on the first
+ * live run: accepting `trigger` reported that note as FIRED because the
+ * roadmap it was spun out of had since archived. A probe whose headline
+ * number is inflated by provenance mentions is worse than one that stays
+ * quiet — it proposes resuming work on evidence that says nothing.
+ */
+const RESUME_LINE_RE = /\b(blocked until|resume when|blocked-until|resume-when)\b/i;
+
+/**
+ * Structure that says the condition has parts beyond its roadmap references.
+ *
+ * `BOTH`, an `AND`, or an enumerated `(1)` / `(a)` list means the author wrote
+ * a conjunction, and this probe can only read one conjunct — the roadmap
+ * dispositions. Reporting FIRED because that conjunct came true would claim
+ * the whole condition on a third of the evidence. Measured on the first live
+ * run: `later/road-to-deferred-rule-retriever.md` waits on three archived
+ * roadmaps AND three demand signals no filesystem check can see.
+ *
+ * Case-INSENSITIVE, and it was not for one revision: every sibling regex here
+ * carries `i` and this one did not, so a lowercase "and" walked through the
+ * guard and its note would have fired on the single conjunct the probe can
+ * resolve — the exact over-report the guard exists to stop.
+ */
+const COMPOUND_RE = /\bboth\b|\band\b|\([1-9]\)|\([a-e]\)|`[ \t]*\+|\+[ \t]*`/i;
+
+/**
+ * A bolded field label that ENDS the condition.
+ *
+ * Park notes carry sibling fields in the same blockquote — `**Origin:**`,
+ * `**Owner:**`, `**Context, not prerequisites:**` — and swallowing them turns
+ * every roadmap the note credits into a claimed dependency. Measured on the
+ * first live run: `later/road-to-per-workspace-license-policy.md` waits on "a
+ * real consumer repo hits the v1 escalation" and merely *cites* the roadmap it
+ * was spun out of under `**Origin:**`; the probe read that citation, found it
+ * archived, and reported the note resumable.
+ *
+ * Same terminator discipline `_blockerField` uses in the dashboard parser, and
+ * for the same reason: a field ends where the next one begins.
+ */
+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 step reference: `P2.1`, `Phase 2.1`, or a bare `2.1`.
+ *
+ * The bare form is deliberately last and deliberately narrow — two digits
+ * around a dot. Widening it to match a version number or a percentage would
+ * make the probe claim to test something it is not reading.
+ */
+const STEP_REF_RE = /\b(?:P|Phase[ \t]+)?(\d+\.\d+)\b/;
+
+type Disposition = 'active' | 'archive' | 'later' | 'skipped' | 'missing';
+type Verdict = 'fired' | 'unmet' | 'undecidable';
+
+interface ResumeFinding {
+    /** Path relative to the roadmap root, e.g. `later/road-to-x.md`. */
+    file: string;
+    /** The resume-condition sentence, as authored. */
+    condition: string;
+    /** Roadmap slugs the condition names, excluding the parked file itself. */
+    refs: string[];
+    verdict: Verdict;
+    /** One clause naming what decided it — always populated. */
+    why: string;
+}
+
+function _read(p: string): string {
+    try {
+        return fs.readFileSync(p, 'utf-8');
+    } catch {
+        return '';
+    }
+}
+
+function _exists(p: string): boolean {
+    try {
+        return fs.statSync(p).isFile();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Where a roadmap slug currently lives.
+ *
+ * `missing` is a real answer and is NOT read as "closed": a slug that resolves
+ * nowhere is a broken reference in the park note, and reporting it as fired
+ * would resume a roadmap on the strength of a typo.
+ */
+function roadmapDisposition(roadmapRoot: string, slug: string): Disposition {
+    const name = `${slug}.md`;
+    if (_exists(path.join(roadmapRoot, name))) {
+        return 'active';
+    }
+    for (const dir of ['archive', 'later', 'skipped'] as const) {
+        if (_exists(path.join(roadmapRoot, dir, name))) {
+            return dir;
+        }
+    }
+    return 'missing';
+}
+
+/**
+ * The resume-condition sentence of a park note.
+ *
+ * Park notes are blockquotes that wrap, so the marker line alone truncates the
+ * condition mid-sentence — the same defect `_blockerTodo` and the legacy
+ * blocked-until parser both had to fix. Continue through following quoted
+ * lines until the quote block breaks.
+ */
+function extractCondition(text: string): string {
+    const lines = _blankFencedCode(text).split(/\r?\n/);
+    // The marker must be inside the park note's blockquote. Searching the whole
+    // file let ordinary body prose containing "blocked until" become "the
+    // condition", and the continuation loop then read from the wrong anchor.
+    const start = lines.findIndex(
+        (l) => _strip(l).startsWith('>') && RESUME_LINE_RE.test(l),
+    );
+    if (start === -1) {
+        return '';
+    }
+    const parts: string[] = [_strip(lines[start] as string)];
+    for (let i = start + 1; i < lines.length; i++) {
+        const l = _strip(lines[i] as string);
+        // The condition ends at the end of the quote block or a blank quoted
+        // line — a park note routinely carries several paragraphs of context
+        // after it, and swallowing those would turn every mentioned roadmap
+        // into a claimed dependency.
+        if (!l.startsWith('>')) {
+            break;
+        }
+        const body = _strip(l.replace(/^>[ \t]?/, ''));
+        if (body === '') {
+            break;
+        }
+        parts.push(body);
+    }
+    const joined = parts
+        .map((p) => _strip(p.replace(/^>[ \t]?/, '')))
+        .join(' ')
+        .trim();
+    return _truncateAtNextField(joined);
+}
+
+/**
+ * Cut the condition at the first bolded label that is not a resume marker.
+ *
+ * The resume marker itself is bolded (`**Resume when …**`), so the scan starts
+ * after it and keeps any further label only when it is another resume marker —
+ * a note that writes `**Blocked until:** … **Resume when** …` is stating one
+ * condition twice, not two fields.
+ */
+function _truncateAtNextField(condition: string): string {
+    let cut = condition.length;
+    const re = new RegExp(FIELD_LABEL_RE.source, 'g');
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(condition)) !== null) {
+        const label = m[0] as string;
+        if (RESUME_LINE_RE.test(label)) {
+            continue;
+        }
+        // A label at offset 0 would cut the condition to nothing; the marker
+        // line legitimately opens with one in notes shaped `**Blocked until:**`.
+        if (m.index === 0) {
+            continue;
+        }
+        cut = m.index;
+        break;
+    }
+    return _strip(condition.slice(0, cut));
+}
+
+function _strip(s: string): string {
+    return s.replace(/^[ \t\f\v]+|[ \t\f\v\r]+$/g, '');
+}
+
+/**
+ * Blank fenced code, preserving line count.
+ *
+ * A park note that SHOWS the resume-condition syntax in a fenced example is
+ * documenting it, not stating one — the same reason `parse_blockers` and
+ * `lint_roadmap_blockers` both strip fences before they look for blockers.
+ */
+function _blankFencedCode(text: string): string {
+    return text.replace(/^[ \t]*```[^\n]*\n[\s\S]*?^[ \t]*```[ \t]*$/gm, (m) =>
+        '\n'.repeat((m.match(/\n/g) ?? []).length),
+    );
+}
+
+/**
+ * The condition CLAUSE inside the condition text.
+ *
+ * Park notes bold the condition and then explain it in prose:
+ * `**Resume when P2.1 of \`road-to-x\` closes** — the catalogue-logging
+ * falsifier that measures whether … and the report itself declines to …`.
+ * The clause is the bolded span; everything after it is commentary.
+ *
+ * The distinction is load-bearing and was measured the hard way. Making
+ * `COMPOUND_RE` case-insensitive (correct in itself — the flag was missing)
+ * immediately produced the opposite false result: an ordinary "and" in the
+ * *explanation* read as a conjunction of conditions, and the one genuinely
+ * fired note in the tree dropped out. Analysing the clause rather than the
+ * paragraph is what makes a case-insensitive conjunction test safe.
+ *
+ * Falls back to the whole string when no bolded span carries the marker — a
+ * note that writes its condition unbolded gets the blunt reading, which is the
+ * conservative direction.
+ */
+function conditionClause(condition: string): string {
+    const re = /\*\*([^*]+)\*\*/g;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(condition)) !== null) {
+        const span = m[1] as string;
+        if (RESUME_LINE_RE.test(span)) {
+            // The bolded span sometimes stops before the payload
+            // (`**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 condition;
+}
+
+/** 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>();
+    ROADMAP_REF_RE.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = ROADMAP_REF_RE.exec(condition)) !== null) {
+        const slug = (m[0] as string).replace(/\.md$/, '');
+        if (slug !== ownSlug) {
+            out.add(slug);
+        }
+    }
+    return [...out].sort();
+}
+
+/**
+ * Is `stepId` (e.g. `2.1`) ticked in `text`? `null` when it is not found.
+ *
+ * The id must sit in the step's LABEL position — immediately after the
+ * checkbox, optionally bolded — not anywhere on the line. Matching it anywhere
+ * meant a line like `- [x] **1.4** raise the cap from 2.0 to 2.1` decided the
+ * verdict for step 2.1, and because `exec` returns the first match in the file
+ * the wrong line won whenever it came first.
+ */
+function stepIsDone(text: string, stepId: string): boolean | null {
+    const escaped = stepId.replace(/\./g, '\\.');
+    const re = new RegExp(
+        `^[ \\t]*-[ \\t]*\\[([ xX~-])\\][ \\t]*\\*{0,2}(?:P|Phase[ \\t]+)?${escaped}\\b`,
+        'm',
+    );
+    const m = re.exec(text);
+    if (!m) {
+        return null;
+    }
+    return (m[1] as string).toLowerCase() === 'x';
+}
+
+/**
+ * Probe every park note under `later/`.
+ *
+ * Pure over the filesystem it is handed, so the tests point it at a fixture
+ * 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[] {
+    const laterDir = path.join(roadmapRoot, 'later');
+    let entries: string[];
+    try {
+        entries = fs
+            .readdirSync(laterDir, { withFileTypes: true })
+            .filter((e) => e.isFile() && e.name.endsWith('.md') && e.name !== 'README.md')
+            .map((e) => e.name)
+            .sort();
+    } catch {
+        return [];
+    }
+
+    const findings: ResumeFinding[] = [];
+    for (const name of entries) {
+        const text = _read(path.join(laterDir, name));
+        const ownSlug = name.replace(/\.md$/, '');
+        const condition = extractCondition(text);
+        if (condition === '') {
+            findings.push({
+                file: `later/${name}`,
+                condition: '',
+                refs: [],
+                verdict: 'undecidable',
+                why: 'no resume-condition line — lint_roadmap_later_disposition owns that gap',
+            });
+            continue;
+        }
+        // Both tests read the CLAUSE, never the surrounding explanation: an
+        // "and" or a roadmap name in the prose after the condition is
+        // commentary, not a second conjunct and not a dependency.
+        const clause = conditionClause(condition);
+        if (COMPOUND_RE.test(clause)) {
+            findings.push({
+                file: `later/${name}`,
+                condition,
+                refs: referencedRoadmaps(clause, ownSlug),
+                verdict: 'undecidable',
+                why: 'compound condition — the probe reads the roadmap references and not the rest',
+            });
+            continue;
+        }
+        const refs = referencedRoadmaps(clause, ownSlug);
+        if (refs.length === 0) {
+            findings.push({
+                file: `later/${name}`,
+                condition,
+                refs,
+                verdict: 'undecidable',
+                why: 'the condition names no roadmap this tree can resolve',
+            });
+            continue;
+        }
+
+        const stepMatch = STEP_REF_RE.exec(clause);
+        const stepId = stepMatch ? (stepMatch[1] as string) : null;
+
+        const reasons: string[] = [];
+        let unmet = false;
+        let unresolvable = false;
+        for (const slug of refs) {
+            const where = roadmapDisposition(roadmapRoot, slug);
+            if (where === 'archive') {
+                reasons.push(`${slug} archived`);
+                continue;
+            }
+            if (where === 'missing') {
+                unresolvable = true;
+                reasons.push(`${slug} resolves nowhere`);
+                continue;
+            }
+            if (where === 'active' && stepId !== null) {
+                const done = stepIsDone(_read(path.join(roadmapRoot, `${slug}.md`)), stepId);
+                if (done === true) {
+                    reasons.push(`${slug} step ${stepId} is ticked`);
+                    continue;
+                }
+                reasons.push(done === null ? `${slug} has no step ${stepId}` : `${slug} step ${stepId} still open`);
+                unmet = true;
+                continue;
+            }
+            reasons.push(`${slug} still in ${where}`);
+            unmet = true;
+        }
+
+        // Conservative on purpose: a compound condition fires only when every
+        // roadmap it names has closed. Resuming on a partial match would put
+        // the file back into the active tree still waiting on something.
+        const verdict: Verdict = unmet ? 'unmet' : unresolvable ? 'undecidable' : 'fired';
+        findings.push({
+            file: `later/${name}`,
+            condition,
+            refs,
+            verdict,
+            why: reasons.join('; '),
+        });
+    }
+    return findings;
+}
+
+export {
+    conditionClause,
+    extractCondition,
+    probeLater,
+    referencedRoadmaps,
+    roadmapDisposition,
+    stepIsDone,
+    RESUME_LINE_RE,
+};
+export type { Disposition, ResumeFinding, Verdict };

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

@@ -47,6 +47,15 @@
  *   ./agent-config gates --json     # machine-readable
  *   ./agent-config gates --reply    # reply-close form; empty when none
  *   ./agent-config gates --pending  # staged actions awaiting confirmation
+ *   ./agent-config gates --execute <id>             # echo what would run
+ *   ./agent-config gates --execute <id> --confirm   # run it and record the evidence
+ *
+ * `--execute` is the only mode that writes anything, and it takes exactly one
+ * blocker id. **Without `--confirm` it runs nothing** — it prints the command
+ * the entry authored so the operator sees the exact string first. Everything
+ * else here reads. See `gate_execute.ts` for what it refuses to do — no sweep,
+ * no resolve on a failed command, no invented budget ledger, no Hard-Floor
+ * command even with `--confirm`, and class 3 unchanged.
  *
  * `--pending` reads a different source — the staged-confirmation store, not the
  * roadmap tree — and stays out of `--reply` on purpose. ADR-222 fixes the
@@ -63,8 +72,11 @@ import { spawnSync } from 'node:child_process';
 import {
     collect,
     blocker_needs_user as needsUser,
+    blocker_class as blockerClass,
     type Blocker,
 } from './update_roadmap_progress.js';
+import { probeLater, type ResumeFinding } from './resume_probe.js';
+import { execute } from './gate_execute.js';
 import { listPending } from '../templates/scripts/work_engine/hooks/builtin/staged_confirmation_store.js';
 import type { StagedAction } from '../templates/scripts/work_engine/hooks/builtin/staged_confirmation.js';
 
@@ -227,7 +239,54 @@ function renderEntry(e: Entry, index: number): string[] {
     return out;
 }
 
-function render(entries: readonly Entry[], all: boolean): string {
+/**
+ * The FIRED section — parked roadmaps whose resume condition has come true.
+ *
+ * Rendered after the blockers because it is a different kind of item: a
+ * blocker is a gate nobody has opened, this is a gate that opened with nobody
+ * standing in front of it. A tree with no `later/` notes at all renders
+ * nothing; a tree that has them but none fired still prints the coverage line
+ * below, deliberately — see the next paragraph.
+ *
+ * The undecidable count is printed even when zero fired, and that is the
+ * point: "no resume condition has fired" and "the probe could read 12 of 44
+ * conditions" are different statements, and only the second one is honest
+ * about its own coverage.
+ */
+function renderResumed(findings: readonly ResumeFinding[]): string[] {
+    const fired = findings.filter((f) => f.verdict === 'fired');
+    const undecidable = findings.filter((f) => f.verdict === 'undecidable').length;
+    if (findings.length === 0) {
+        return [];
+    }
+    const out: string[] = [];
+    if (fired.length > 0) {
+        out.push('');
+        const head = `FIRED · ${fired.length} parked roadmap${fired.length !== 1 ? 's' : ''} can resume`;
+        out.push(`── ${head} ${'─'.repeat(Math.max(3, WIDTH - head.length - 4))}`);
+        for (const f of fired) {
+            out.push(...field('Roadmap:', f.file));
+            out.push(...field('Condition:', f.condition));
+            out.push(...field('Fired because:', f.why));
+        }
+        out.push('');
+        out.push('Resume one with: `git mv agents/roadmaps/later/<file> agents/roadmaps/`');
+        out.push('then `agent-config roadmap:progress`.');
+    }
+    out.push('');
+    out.push(
+        `Resume-probe coverage: ${findings.length - undecidable} of ${findings.length} ` +
+            `park note${findings.length !== 1 ? 's' : ''} carry a machine-decidable condition` +
+            (undecidable > 0 ? ` · ${undecidable} undecidable` : ''),
+    );
+    return out;
+}
+
+function render(
+    entries: readonly Entry[],
+    all: boolean,
+    resumed: readonly ResumeFinding[] = [],
+): string {
     const mine = entries.filter((e) => needsUser(e.blocker.owner));
     const others = entries.filter((e) => !needsUser(e.blocker.owner));
     const shown = all ? entries : mine;
@@ -267,6 +326,7 @@ function render(entries: readonly Entry[], all: boolean): string {
         lines.push('  "guide me through <id>"   — one decision, step by step');
         lines.push('');
     }
+    lines.push(...renderResumed(resumed));
     return lines.join('\n') + '\n';
 }
 
@@ -340,18 +400,36 @@ function renderReply(entries: readonly Entry[]): string {
     return lines.join('\n') + '\n';
 }
 
-function renderJson(entries: readonly Entry[], all: boolean): string {
+function renderJson(
+    entries: readonly Entry[],
+    all: boolean,
+    resumed: readonly ResumeFinding[] = [],
+): string {
     const pick = all ? entries : entries.filter((e) => needsUser(e.blocker.owner));
     return (
         JSON.stringify(
             {
                 needsYou: entries.filter((e) => needsUser(e.blocker.owner)).length,
                 other: entries.filter((e) => !needsUser(e.blocker.owner)).length,
+                resumeFired: resumed.filter((f) => f.verdict === 'fired').length,
+                resumeUndecidable: resumed.filter((f) => f.verdict === 'undecidable').length,
+                resumed: resumed.filter((f) => f.verdict === 'fired'),
                 blockers: pick.map((e) => ({
                     id: e.blocker.id,
                     roadmap: e.roadmapRel,
                     owner: e.blocker.owner,
                     needsYou: needsUser(e.blocker.owner),
+                    // Resolved through the same absent-field default every
+                    // other consumer applies, so a synthesised `legacy` note
+                    // reads as class 3 rather than as a hole. `class` ships and
+                    // the sibling `run` does not, and the asymmetry is the
+                    // roadmap's, not a preference: `road-to-gate-autonomy` step
+                    // 1.3 names this field as its acceptance condition, while
+                    // nothing asks for the command here — `--execute` reads it
+                    // off the entry via `locate()`. Emitting `run` would also
+                    // need a call on the authored-vs-`commandOf()`-stripped
+                    // form, which no consumer exists to settle.
+                    class: blockerClass(e.blocker),
                     blocks: e.blocker.blocks,
                     unblocksSteps: e.openSteps,
                     todo: regroupTodo(e.blocker.todo),
@@ -487,6 +565,39 @@ function main(argv?: readonly string[]): number {
     const reply = args.includes('--reply');
     const pending = args.includes('--pending');
 
+    // `--execute <id>` is answered FIRST, and it is the only mode that writes.
+    // It used to sit after the `--pending` early return, so `--pending
+    // --execute <id>` silently did nothing; and it ignored `--json`, so a
+    // JSON-requesting caller got prose. Both combinations now refuse loudly.
+    const execIdx = args.indexOf('--execute');
+    if (execIdx !== -1) {
+        const id = args[execIdx + 1];
+        if (id === undefined || id.startsWith('--')) {
+            process.stderr.write(
+                'usage: gates --execute <blocker-id> [--confirm]\n' +
+                    '  Without --confirm the command is echoed and nothing runs.\n',
+            );
+            return 1;
+        }
+        if (pending) {
+            process.stderr.write('gates: --execute and --pending are different sources; pick one.\n');
+            return 1;
+        }
+        if (json) {
+            process.stderr.write('gates --execute has no JSON form; its output is a report.\n');
+            return 1;
+        }
+        const root = _resolveRepoRoot(process.cwd());
+        const dir = path.join(root, 'agents', 'roadmaps');
+        if (!_isDir(dir)) {
+            process.stderr.write('No roadmaps directory — nothing to execute.\n');
+            return 1;
+        }
+        const r = execute(dir, id, new Date(), { confirm: args.includes('--confirm') });
+        process.stdout.write(r.report);
+        return r.code;
+    }
+
     // `--pending` resolves against `agents/runtime/`, not `agents/roadmaps/`,
     // and is answered BEFORE the roadmaps-directory exit below: a staged action
     // is independent of whether this project plans in roadmaps at all, so
@@ -508,15 +619,37 @@ function main(argv?: readonly string[]): number {
             reply
                 ? ''
                 : json
-                  ? '{"needsYou":0,"other":0,"blockers":[]}\n'
+                  ? // Every key `renderJson` emits, so a consumer reading the
+                    // resume fields gets 0 rather than `undefined` on the
+                    // branch where there is no roadmap tree to probe.
+                    JSON.stringify(
+                          {
+                              needsYou: 0,
+                              other: 0,
+                              resumeFired: 0,
+                              resumeUndecidable: 0,
+                              resumed: [],
+                              blockers: [],
+                          },
+                          null,
+                          2,
+                      ) + '\n'
                   : 'No roadmaps directory — nothing to report.\n',
         );
         return 0;
     }
 
     const entries = collectEntries(roadmapRoot);
+    // `--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);
     process.stdout.write(
-        reply ? renderReply(entries) : json ? renderJson(entries, all) : render(entries, all),
+        reply
+            ? renderReply(entries)
+            : json
+              ? renderJson(entries, all, resumed)
+              : render(entries, all, resumed),
     );
     return 0;
 }
@@ -553,6 +686,7 @@ export {
     render,
     renderJson,
     renderReply,
+    renderResumed,
     renderPending,
     renderPendingJson,
 };