plumbbob 0.12.1 → 0.13.1

package/dist/verbs/order.js

@@ -14,16 +14,18 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { findRepoRoot } from "../lib/git.js";
 import { activeBuild, hasSession, intentPath } from "../lib/sidecar.js";
 import { clearBuildOrder, orderSteps, parseSteps, setBuildOrder } from "../lib/orient.js";
-import { ending, notice, transition } from "../lib/notice.js";
+import { expandStepList, parseStepList } from "../lib/steplist.js";
+import { ending, notice, printEnding, transition } from "../lib/notice.js";
 import { driverPointer } from "./handoff.js";
 /**
- * Set the build order to the given step numbers, the rest of the undone steps
- * following in document order, or clear it with `--reset`.
+ * Set the build order to the given step numbers and spans, the rest of the
+ * undone steps following in document order, or clear it with `--reset`.
  *
- * The line written is the whole remaining sequence, so a cold reader of
- * intent.md sees every undone step and not only the ones re-sequenced.
- * Refuses (exit 1) with no session, no numbers, a token that is not a number,
- * a number the plan lacks, a repeated number, or a step already checkpointed.
+ * The line written is the whole remaining sequence, each span spelled out, so a
+ * cold reader of intent.md sees every undone step and not only the ones
+ * re-sequenced. Refuses (exit 1) with no session, no numbers, a token that is
+ * neither a number nor a span, a number the plan lacks, a repeated number, or a
+ * step already checkpointed.
  */
 export function order(cwd, args) {
     const root = findRepoRoot(cwd);
@@ -35,14 +37,19 @@ export function order(cwd, args) {
     const intent = readFileSync(path, 'utf8');
     if (args.includes('--reset')) {
         writeFileSync(path, clearBuildOrder(intent));
-        process.stdout.write(ending({
-            lead: transition({ label: 'Build order', fact: 'document order' }),
-            pointer: driverPointer(root, activeBuild(root)),
-        }));
+        printEnding(root, {
+            tier: 'driver',
+            render: 'order',
+            text: ending({
+                lead: transition({ label: 'Build order', fact: 'document order' }),
+                pointer: driverPointer(root, activeBuild(root)),
+            }),
+        });
         return 0;
     }
-    // Numbers arrive space- or comma-separated: `order 7 8 5` and `order 7,8,5`
-    // read the same, since the line they write is the comma form.
+    // Numbers and spans arrive space- or comma-separated, with or without a space
+    // after a comma: `order 7 8 5`, `order 7,8,5`, and `order 1, 6, 2-4, 7, 5`
+    // all read, and a span names its steps in place, since the line is a sequence.
     const tokens = args
         .filter((a) => !a.startsWith('--'))
         .flatMap((a) => a.split(','))
@@ -56,14 +63,15 @@ export function order(cwd, args) {
         }));
         return 1;
     }
-    const stray = tokens.find((t) => !/^\d+$/.test(t));
+    const lists = tokens.map(parseStepList);
+    const stray = tokens.find((_, i) => lists[i] === null);
     if (stray !== undefined) {
-        process.stderr.write(notice({ fact: `\`${stray}\` is not a step number`, remedy: 'plumbbob order 7 8 5' }));
+        process.stderr.write(notice({ fact: `\`${stray}\` is not a step number or span`, remedy: 'plumbbob order 1, 6, 2-4, 7, 5' }));
         return 1;
     }
-    const given = tokens.map(Number);
     const steps = parseSteps(intent);
     const planned = steps.map((s) => s.n);
+    const given = expandStepList(lists.flatMap((list) => list ?? []), (n) => planned.includes(n));
     const unknown = given.find((n) => !planned.includes(n));
     if (unknown !== undefined) {
         process.stderr.write(notice({
@@ -94,9 +102,13 @@ export function order(cwd, args) {
     // The pointer reads the plan back from disk, so it already follows the
     // order just written: back at the step in flight, or forward from the
     // boundary to the first step in the new sequence.
-    process.stdout.write(ending({
-        lead: transition({ label: 'Build order', fact: full.join(', ') }),
-        pointer: driverPointer(root, activeBuild(root)),
-    }));
+    printEnding(root, {
+        tier: 'driver',
+        render: 'order',
+        text: ending({
+            lead: transition({ label: 'Build order', fact: full.join(', ') }),
+            pointer: driverPointer(root, activeBuild(root)),
+        }),
+    });
     return 0;
 }

package/dist/verbs/park.js

@@ -11,7 +11,7 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { findRepoRoot } from "../lib/git.js";
 import { activeBuild, hasSession, buildLogPath } from "../lib/sidecar.js";
 import { appendToSection } from "../lib/buildlog.js";
-import { ending, notice, transition } from "../lib/notice.js";
+import { ending, notice, printEnding, transition } from "../lib/notice.js";
 import { driverPointer } from "./handoff.js";
 /**
  * Append the given text as one unchecked `- [ ]` line to the build-log's Park list.
@@ -43,6 +43,10 @@ export function park(cwd, args) {
     writeFileSync(path, updated);
     // A park interrupts a step without ending it, so the ending is the capture
     // and the pointer back at what was interrupted.
-    process.stdout.write(ending({ lead: transition({ label: 'Parked', fact: text }), pointer: driverPointer(root, activeBuild(root)) }));
+    printEnding(root, {
+        tier: 'driver',
+        render: 'park',
+        text: ending({ lead: transition({ label: 'Parked', fact: text }), pointer: driverPointer(root, activeBuild(root)) }),
+    });
     return 0;
 }

package/dist/verbs/recover.js

@@ -18,7 +18,7 @@
 // deleting them is a gamble the human should take by hand.
 import { existsSync, readFileSync } from 'node:fs';
 import { findRepoRoot } from "../lib/git.js";
-import { parseBuildOrder, parseSteps } from "../lib/orient.js";
+import { parseBuildOrder, parseBuildRanges, parseOrderedSteps, parseSteps, rangeStanding } from "../lib/orient.js";
 import { activeBuild, checkpointsPath, clearHandoff, clearTick, grantPath, handoffPath, hasSession, intentPath, inSpike, listBuilds, readTurn, setActiveBuild, setGrant, stepPath, tickPath, } from "../lib/sidecar.js";
 import { spikeBranches, spikeWorktrees } from "./spike.js";
 /**
@@ -94,6 +94,7 @@ function sessionFindings(root) {
     const stepInFlight = existsSync(stepPath(root, slug));
     findings.push(...phaseFindings(root, slug, stepInFlight));
     findings.push(...orderFindings(root, slug));
+    findings.push(...rangeFindings(root, slug));
     findings.push(...leftoverFindings(root, slug, stepInFlight));
     return findings;
 }
@@ -126,6 +127,35 @@ function orderFindings(root, slug) {
         },
     ];
 }
+/**
+ * A build range naming a step the plan does not hold.
+ *
+ * The section under `## Build ranges` is hand-editable, and a refine can drop
+ * a step a range names; the card then suggests no command for that range, and
+ * the dashboard says why. Reported beside the build order's own finding, never
+ * repaired: where the stop belongs now is the human's call. Silent while the
+ * plan declares no ranges.
+ */
+function rangeFindings(root, slug) {
+    const intent = readOr(intentPath(root, slug));
+    const plan = parseBuildRanges(intent);
+    if (plan.ranges.length === 0) {
+        return [];
+    }
+    const missing = rangeStanding(plan, parseOrderedSteps(intent), null).drift.filter((d) => d.kind === 'missing');
+    if (missing.length === 0) {
+        const count = `${plan.ranges.length} range${plan.ranges.length === 1 ? '' : 's'}`;
+        return [{ name: 'build ranges', ok: true, detail: `every step they name is planned (${count})` }];
+    }
+    return [
+        {
+            name: 'build ranges',
+            ok: false,
+            detail: missing.map((d) => `range ${d.item} names a step the plan lacks: ${d.words}`).join('; '),
+            hint: 're-cut the range under ## Build ranges by hand, or with /plumbbob:refine',
+        },
+    ];
+}
 /**
  * The cursor names a build that is not there.
  *

package/dist/verbs/relay.js

@@ -0,0 +1,306 @@
+// `plumbbob relay`: the relay check. Wired to the harness's Stop event, it runs
+// as the model ends a turn and asks one question: did the turn carry the ending
+// plumbbob printed in it? Every ending a verb prints is recorded in `RELAY`
+// with its tier and the `TURN` it printed in, and the tier picks the match. A
+// decision ending (a pause card, its reminder, the plan card) has to close the
+// turn, with an answer allowed above it; an orientation ending (a checkpoint's
+// boundary, the plan commit, finish) has to appear somewhere in the turn, since
+// an approving message can carry a question the model answers after it; a
+// driver ending is never checked. A `RELAY` from an earlier turn is not this
+// turn's to carry, so the check runs only while its turn is the current one.
+//
+// It reads a relay by its parts, not line for line: the labeled parts the
+// printed block has, in its order, with no paragraph inside a part that the
+// block does not have there (for a decision ending, after the last part too).
+// Only the measured facts are compared exactly, the Readout
+// table and the Verdict line, because those are what a laundered relay would
+// change; a reworded Summary or Recommendation is the model's own prose, and a
+// reordered Your Call move still offers every move.
+//
+// On a miss it holds the turn open once, through `additionalContext`, with a
+// one-line reason the model acts on and the human reads under `Stop hook
+// feedback`: a decision ending is reprinted by the command `RELAY` recorded,
+// because the stored card goes stale once the model keeps working, and an
+// orientation ending is pasted as it printed, since it reports a commit that
+// has already landed. The once is counted in `RELAY` by the turn it held,
+// never by `stop_hook_active`, which checkride's gate sets on every red Stop
+// and which names no hook. It never sends `continue: false`, which would cancel
+// a sibling's block in the same round.
+//
+// The final message comes from the payload's `last_assistant_message`, never
+// from the transcript, which does not yet hold that message when Stop fires;
+// the transcript supplies only the turn's earlier messages, which an
+// orientation ending can sit in. It ALWAYS exits 0, and anything it cannot read
+// (a payload without the field, a transcript it cannot scope) degrades to no
+// output: a broken check must never wedge a turn's end.
+import { readFileSync } from 'node:fs';
+import { findSessionRoot, holdRelay, readRelay, readTurn } from "../lib/sidecar.js";
+/**
+ * The hook entry point: read the Stop payload, and hold the turn open once when
+ * it did not carry its ending.
+ *
+ * Always returns 0: any failure is swallowed and degrades to no output.
+ */
+export function relay(cwd, _args) {
+    try {
+        const output = relayCheck(cwd, readStdin());
+        if (output !== null)
+            process.stdout.write(output);
+    }
+    catch {
+        // A broken check must never wedge a turn's end: swallow and exit 0.
+    }
+    return 0;
+}
+/**
+ * The hook's stdout for one Stop payload: the `additionalContext` that holds
+ * the turn open, or null when the turn carried its ending or there is nothing
+ * this check can judge.
+ *
+ * Exported because an in-process test cannot feed the hook's real stdin.
+ */
+export function relayCheck(cwd, raw) {
+    const payload = parsePayload(raw);
+    // A host too old to send the final message has nothing to check against.
+    if (payload === null || typeof payload.last_assistant_message !== 'string')
+        return null;
+    const root = findSessionRoot(typeof payload.cwd === 'string' ? payload.cwd : cwd);
+    if (root === null)
+        return null;
+    const record = readRelay(root);
+    const turn = readTurn(root);
+    if (record === null || turn === null || record.turn !== turn || record.held === turn)
+        return null;
+    const carried = carriedEnding(record, payload.last_assistant_message, payload);
+    // Whole, or not this check's to judge: let the turn end.
+    if (carried !== false)
+        return null;
+    // A hold that cannot be counted could repeat, so it is no hold at all.
+    if (!holdRelay(root, record))
+        return null;
+    return `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'Stop', additionalContext: reason(record) } })}\n`;
+}
+/**
+ * Whether the turn carried the recorded ending: true when it did, false when
+ * it did not, and null when the tier is not checked or the turn's earlier text
+ * cannot be read to tell.
+ */
+function carriedEnding(record, last, payload) {
+    const printed = partsOf(record.text);
+    // A block with no labeled part is nothing this reader can match against.
+    if (printed.length === 0 || record.tier === 'driver')
+        return null;
+    if (record.tier === 'decision')
+        return closesOn(partsOf(last), printed);
+    if (appearsIn(partsOf(last), printed))
+        return true;
+    const earlier = turnText(payload);
+    return earlier === null ? null : appearsIn(partsOf(earlier), printed);
+}
+/**
+ * Whether a final message closes on the printed block: read from the last
+ * place it opens the block's first part, it has the same parts in the same
+ * order, the same measured facts, and no paragraph in any part, the last one
+ * included, that the block does not have there.
+ */
+function closesOn(relayed, printed) {
+    const first = printed[0]?.label;
+    const start = relayed.findLastIndex((p) => p.label === first);
+    return start !== -1 && sameParts(relayed.slice(start), printed, printed.length);
+}
+/**
+ * Whether the printed block appears anywhere in a stretch of text: some place
+ * that opens its first part runs on through the same parts in the same order,
+ * with the same measured facts and nothing written inside them. Text after the
+ * last part is the turn's to say, so that part's paragraphs are not counted.
+ */
+function appearsIn(relayed, printed) {
+    return relayed.some((p, i) => p.label === printed[0]?.label && sameParts(relayed.slice(i, i + printed.length), printed, printed.length - 1));
+}
+/**
+ * Whether two runs of parts carry the same labels in order and the same
+ * measured facts, with no more paragraphs than the printed block has in each
+ * of the first `counted` parts.
+ */
+function sameParts(relayed, printed, counted) {
+    if (relayed.length !== printed.length || relayed.some((p, i) => p.label !== printed[i]?.label))
+        return false;
+    const crowded = relayed.slice(0, counted).some((p, i) => blockCount(p) > blockCount(printed[i]));
+    return !crowded && factsOf(relayed) === factsOf(printed);
+}
+/**
+ * The facts the CLI measured, as one comparable string: the Readout table,
+ * whitespace aside, and the Verdict line. Every other line of a block may be
+ * reworded or reordered without the relay counting as missed.
+ */
+function factsOf(parts) {
+    const readout = parts.find((p) => p.label === 'Readout');
+    const verdict = parts.find((p) => p.label === 'Verdict');
+    return `${flat(readout === undefined ? '' : tableOf(readout))}\n${flat(verdict?.lines[0] ?? '')}`;
+}
+/** The `text` fence inside the Readout part, rails included, or '' when it has none. */
+function tableOf(part) {
+    const open = part.lines.findIndex((l) => /^`{3,}text\s*$/.test(l));
+    if (open === -1)
+        return '';
+    const rail = /^`+/.exec(part.lines[open] ?? '')?.[0] ?? '```';
+    const close = part.lines.findIndex((l, i) => i > open && l.trim() === rail);
+    return part.lines.slice(open, close === -1 ? undefined : close + 1).join('\n');
+}
+/**
+ * How many blocks a part holds: runs of lines between blank lines, a fence
+ * counted whole, and the items of one list counted once even when a relay
+ * spaced them apart. A paragraph after a part's last block is the model
+ * talking past the ending.
+ */
+function blockCount(part) {
+    let count = 0;
+    let open = false;
+    let listing = false;
+    let inFence = false;
+    for (const line of part.lines) {
+        if (/^\s*`{3,}/.test(line))
+            inFence = !inFence;
+        if (line.trim().length === 0 && !inFence) {
+            open = false;
+            continue;
+        }
+        const item = /^\s*(?:[-*]|\d+\.)\s/.test(line);
+        if (!open && !(item && listing))
+            count += 1;
+        open = true;
+        listing = item;
+    }
+    return count;
+}
+/**
+ * An ending's labeled parts, in order: each opens on a line that starts with a
+ * bold label and a colon, outside a fence, and runs to the next. Text before
+ * the first label is not part of any.
+ */
+function partsOf(text) {
+    const parts = [];
+    let rail = null;
+    for (const line of text.split('\n')) {
+        const fence = /^\s*(`{3,})/.exec(line)?.[1];
+        if (rail === null && fence !== undefined) {
+            rail = fence;
+        }
+        else if (rail !== null && fence !== undefined && fence.length >= rail.length && line.trim() === fence) {
+            rail = null;
+            parts.at(-1)?.lines.push(line);
+            continue;
+        }
+        const label = rail === null ? /^\*\*([^*\n]+)\*\*:(?:\s|$)/.exec(line)?.[1] : undefined;
+        if (label !== undefined) {
+            parts.push({ label, lines: [line] });
+        }
+        else {
+            parts.at(-1)?.lines.push(line);
+        }
+    }
+    return parts;
+}
+/**
+ * The one-line reason the model acts on and the human reads in full: what the
+ * turn missed, and the command or block that puts it back.
+ */
+function reason(record) {
+    if (record.tier === 'decision') {
+        const command = record.command ?? 'plumbbob handoff --full';
+        return (`plumbbob: the turn did not close on the ${DECISION_NAMES[record.render] ?? 'pause'} it printed. ` +
+            `Run \`${command}\` and end the turn on its output, whole, with nothing after it.`);
+    }
+    const verb = ORIENTATION_VERBS[record.render] ?? 'plumbbob handoff';
+    return (`plumbbob: the turn did not relay the block \`${verb}\` printed. ` +
+        'Paste that block whole, exactly as it printed (it is stored below the header in `.plumbbob/RELAY`).');
+}
+// What a decision ending is called in the reason, by its render.
+const DECISION_NAMES = {
+    card: 'pause card',
+    reminder: 'pause reminder',
+    plan: 'plan card',
+};
+// The command that printed an orientation ending, by its render, so the reason
+// names the block the model already has in front of it.
+const ORIENTATION_VERBS = {
+    checkpoint: 'plumbbob checkpoint',
+    'plan-commit': 'plumbbob checkpoint --plan',
+    finish: 'plumbbob finish',
+};
+/**
+ * The text of the turn's messages already on disk: every assistant text part
+ * after the human prompt the payload's `prompt_id` names.
+ *
+ * Null when the transcript cannot be read or that prompt is not in it: a turn
+ * the check cannot scope is a turn it does not judge. A line that does not
+ * parse is skipped, since the one being written as Stop fires is the final
+ * message, which the payload carries already.
+ */
+function turnText(payload) {
+    if (typeof payload.transcript_path !== 'string' || typeof payload.prompt_id !== 'string')
+        return null;
+    let lines;
+    try {
+        lines = readFileSync(payload.transcript_path, 'utf8').split('\n');
+    }
+    catch {
+        return null;
+    }
+    const entries = lines.map(parseEntry).filter((e) => e !== null);
+    const start = entries.findIndex((e) => e.type === 'user' && e.promptId === payload.prompt_id && e.isMeta !== true);
+    if (start === -1)
+        return null;
+    return entries
+        .slice(start + 1)
+        .filter((e) => e.type === 'assistant')
+        .flatMap((e) => {
+        const content = e.message?.content;
+        return Array.isArray(content) ? content : [];
+    })
+        .flatMap((part) => (part?.type === 'text' && typeof part.text === 'string' ? [part.text] : []))
+        .join('\n');
+}
+/** One transcript line as an entry, or null when it is blank or does not parse. */
+function parseEntry(line) {
+    if (line.trim().length === 0)
+        return null;
+    try {
+        const entry = JSON.parse(line);
+        return typeof entry === 'object' && entry !== null ? entry : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The Stop payload, or null when stdin is not a JSON object. */
+function parsePayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Text with every run of whitespace collapsed to one space and the ends
+ * trimmed, so a measured fact still matches when a relay rewrapped it.
+ */
+function flat(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+/**
+ * The hook payload from stdin, or '' on a TTY or any read failure: a check
+ * that cannot read its payload judges nothing.
+ */
+function readStdin() {
+    if (process.stdin.isTTY === true)
+        return '';
+    try {
+        return readFileSync(0, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}

package/dist/verbs/revert.js

@@ -20,10 +20,10 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { findRepoRoot, resetHard, untrackedPaths } from "../lib/git.js";
-import { bumpStepStat, checkpointsPath, hasSession, resolveBuild, seamPath, sidecarDir, stepPath } from "../lib/sidecar.js";
+import { bumpStepStat, checkpointsPath, clearPause, hasSession, resolveBuild, seamPath, sidecarDir, stepPath } from "../lib/sidecar.js";
 import { isArtifactPath, matchesSeam } from "../lib/intent.js";
 import { AT_BOUNDARY, syncBuildLogState } from "../lib/buildlogsync.js";
-import { ending, notice, transition } from "../lib/notice.js";
+import { ending, notice, printEnding, transition } from "../lib/notice.js";
 import { driverPointer } from "./handoff.js";
 /**
  * Rewind to a recorded checkpoint and return the build to the boundary.
@@ -31,8 +31,9 @@ import { driverPointer } from "./handoff.js";
  * Requires an active session (the `.plumbbob/STATE` sentinel). Resolves the
  * target SHA from the checkpoints ledger (latest step, `--to n`, or the
  * baseline), resets hard while preserving plumbbob-owned paths, removes
- * untracked files inside the seam, clears the in-flight STEP/SEAM markers, and
- * re-renders the build-log. Exit 1 with a hint on any refusal.
+ * untracked files inside the seam, clears the in-flight STEP/SEAM markers and
+ * the PAUSE stamp, and re-renders the build-log. Exit 1 with a hint on any
+ * refusal.
  */
 export function revert(cwd, args) {
     const root = findRepoRoot(cwd);
@@ -77,6 +78,7 @@ export function revert(cwd, args) {
     }
     rmSync(seamPath(root, slug), { force: true });
     rmSync(stepPath(root, slug), { force: true });
+    clearPause(root, slug); // the pause it stamped is gone with the work
     if (inFlight !== null) {
         bumpStepStat(root, slug, inFlight, 'reverts');
     }
@@ -87,14 +89,18 @@ export function revert(cwd, args) {
     syncBuildLogState(root, slug, AT_BOUNDARY);
     // A step exit: nothing landed, so no Verdict rides above the pointer, and with
     // the markers cleared it aims forward from the boundary.
-    process.stdout.write(ending({
-        lead: transition({
-            label: 'Reverted',
-            fact: `to ${sha.slice(0, 9)}`,
-            detail: ['park lines and intent edits preserved'],
+    printEnding(root, {
+        tier: 'driver',
+        render: 'revert',
+        text: ending({
+            lead: transition({
+                label: 'Reverted',
+                fact: `to ${sha.slice(0, 9)}`,
+                detail: ['park lines and intent edits preserved'],
+            }),
+            pointer: driverPointer(root, slug),
         }),
-        pointer: driverPointer(root, slug),
-    }));
+    });
     return 0;
 }
 /**

package/dist/verbs/spike.js

@@ -21,7 +21,7 @@ import { basename, dirname, join, relative } from 'node:path';
 import { findRepoRoot } from "../lib/git.js";
 import { buildFolder, clearSpike, hasSession, inSpike, listSpikeReports, markSpike, nextSpikeReportPath, resolveBuild, stepPath, } from "../lib/sidecar.js";
 import { readTemplate, stampTemplate } from "../lib/templates.js";
-import { advisory, blocks, ending, notice, transition } from "../lib/notice.js";
+import { advisory, blocks, ending, notice, printEnding, transition } from "../lib/notice.js";
 import { driverPointer } from "./handoff.js";
 // Worktree/branch names when the caller lists none: a fork defaults to two arms.
 const DEFAULT_OPTIONS = ['a', 'b'];
@@ -69,15 +69,19 @@ function spikeReport(root, buildSlug, positionals) {
     const inFlight = readInFlightStep(root, buildSlug);
     const via = inFlight !== null ? `step ${inFlight}` : '/plumbbob:spike';
     const path = scaffoldSpikeReport(root, buildSlug, slug, via);
-    process.stdout.write(ending({
-        lead: transition({
-            label: 'Spike report',
-            fact: 'scaffolded',
-            detail: [relative(root, path)],
-            remedy: 'record Findings and the Verdict there, which is what closes a spike step',
+    printEnding(root, {
+        tier: 'driver',
+        render: 'spike-report',
+        text: ending({
+            lead: transition({
+                label: 'Spike report',
+                fact: 'scaffolded',
+                detail: [relative(root, path)],
+                remedy: 'record Findings and the Verdict there, which is what closes a spike step',
+            }),
+            pointer: driverPointer(root, buildSlug),
         }),
-        pointer: driverPointer(root, buildSlug),
-    }));
+    });
     return 0;
 }
 /**
@@ -158,22 +162,26 @@ function spikeStart(root, buildSlug, positionals) {
     // The lead states the fact; the throwaway worktrees are a list, so they ride
     // as a readout beneath it rather than crowding the line, and the report the
     // spike scaffolded is a second landing under the same lead.
-    process.stdout.write(ending({
-        lead: blocks([
-            transition({
-                label: 'Spike',
-                fact: 'opened',
-                detail: ['the main tree stays put', `${created.length} throwaway worktree${created.length === 1 ? '' : 's'}`],
-            }) + created.map((path) => `  ${path}`).join('\n'),
-            transition({
-                label: 'Spike report',
-                fact: 'scaffolded',
-                detail: [relative(root, report)],
-                remedy: 'record findings and the Verdict there, then run plumbbob spike done',
-            }),
-        ]),
-        pointer: driverPointer(root, buildSlug),
-    }));
+    printEnding(root, {
+        tier: 'driver',
+        render: 'spike-open',
+        text: ending({
+            lead: blocks([
+                transition({
+                    label: 'Spike',
+                    fact: 'opened',
+                    detail: ['the main tree stays put', `${created.length} throwaway worktree${created.length === 1 ? '' : 's'}`],
+                }) + created.map((path) => `  ${path}`).join('\n'),
+                transition({
+                    label: 'Spike report',
+                    fact: 'scaffolded',
+                    detail: [relative(root, report)],
+                    remedy: 'record findings and the Verdict there, then run plumbbob spike done',
+                }),
+            ]),
+            pointer: driverPointer(root, buildSlug),
+        }),
+    });
     return 0;
 }
 /**
@@ -203,19 +211,23 @@ function spikeDone(root, buildSlug) {
     // closes. It follows the line it qualifies, and names the reports so the
     // human knows where to write the call. The pointer, read once the marker is
     // cleared, aims back at the step the spike interrupted, or forward.
-    process.stdout.write(ending({
-        lead: transition({ label: 'Spike', fact: 'closed', detail: ['worktrees and branches removed'] }),
-        advisories: unfilled.length === 0
-            ? []
-            : [
-                advisory({
-                    fact: 'no verdict recorded',
-                    detail: unfilled,
-                    remedy: 'record which option won, and why, now the worktrees are gone',
-                }),
-            ],
-        pointer: driverPointer(root, buildSlug),
-    }));
+    printEnding(root, {
+        tier: 'driver',
+        render: 'spike-done',
+        text: ending({
+            lead: transition({ label: 'Spike', fact: 'closed', detail: ['worktrees and branches removed'] }),
+            advisories: unfilled.length === 0
+                ? []
+                : [
+                    advisory({
+                        fact: 'no verdict recorded',
+                        detail: unfilled,
+                        remedy: 'record which option won, and why, now the worktrees are gone',
+                    }),
+                ],
+            pointer: driverPointer(root, buildSlug),
+        }),
+    });
     return 0;
 }
 /**