plumbbob 0.12.0 → 0.13.0

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;
 }
 /**

package/dist/verbs/start.js

@@ -10,7 +10,7 @@ import { readTemplate, stampTemplate } from "../lib/templates.js";
 import { findRepoRoot, hasCommit, headSha, isDirty, isIgnored } from "../lib/git.js";
 import { sidecarDir, buildDir, listBuilds, slugify, checkpointsPath, intentPath, buildLogPath, beginSession, hasSession, excludeControl, excludeSidecar, setGrant, stampTick, } from "../lib/sidecar.js";
 import { settingsPath } from "../lib/settings.js";
-import { advisory, ending, notice, transition } from "../lib/notice.js";
+import { advisory, ending, notice, printEnding, transition } from "../lib/notice.js";
 /**
  * Human-readable echo of the default check gate, stamped into the templates'
  * {{CHECK}} line.
@@ -177,15 +177,19 @@ export async function start(cwd, args) {
     // No pointer: the plan skill owns the turn that follows, and there is no step
     // yet to aim at, so the ending closes on the remedy line that says where to
     // frame the build.
-    process.stdout.write(ending({
-        lead: transition({
-            label: 'Session',
-            fact: `started "${title}"`,
-            detail: [`baseline ${sha.slice(0, 9)}`],
-            remedy: `frame and decide in ${intentLocation}, then build a step`,
+    printEnding(root, {
+        tier: 'driver',
+        render: 'start',
+        text: ending({
+            lead: transition({
+                label: 'Session',
+                fact: `started "${title}"`,
+                detail: [`baseline ${sha.slice(0, 9)}`],
+                remedy: `frame and decide in ${intentLocation}, then build a step`,
+            }),
+            advisories,
         }),
-        advisories,
-    }));
+    });
     return 0;
 }
 /**

package/dist/verbs/status.js

@@ -6,7 +6,7 @@
 // behavior, so the `NO ACTIVE SESSION` sentinel is kept exact.
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { commitsSince, findRepoRoot } from "../lib/git.js";
+import { PLAN_COMMIT_MARKER, commitsSince, findRepoRoot } from "../lib/git.js";
 import { SLOTS, readHarnessFile, resolveAgent, } from "../lib/agents.js";
 import { buildFolder, buildLogPath, checkpointsPath, hasSession, inSpike, intentPath, listBuilds, resolveBuild, stepPath, } from "../lib/sidecar.js";
 import { formatOrientation, lastLedgerSha, orient, parseRequestedStep } from "../lib/orient.js";
@@ -80,7 +80,7 @@ export function status(cwd, args = []) {
         inFlight: /^\d+$/.test(inFlightRaw) ? Number(inFlightRaw) : null,
         spiking: inSpike(root, slug),
         requested: parseRequestedStep(invoked),
-        outOfBand: anchor === null ? 0 : commitsSince(root, anchor),
+        outOfBand: anchor === null ? 0 : commitsSince(root, anchor, PLAN_COMMIT_MARKER),
     });
     const lines = [formatOrientation(orientation), ...harnessSection(root, slug)];
     process.stdout.write(`${lines.join('\n')}\n`);

package/dist/verbs/turn.js

@@ -10,7 +10,8 @@
 // could forge would be no grant). When a step is in flight it also emits ONE
 // `UserPromptSubmit` additionalContext line so a fresh session (post-compaction,
 // or a scripted `-p` turn where no skill prose is in context) still knows the
-// beat: a tangent is parked, not chased. Guidance only: it blocks nothing. It
+// beat: a tangent is parked, not chased, and a message that also asks something
+// is answered before the park's block. Guidance only: it blocks nothing. It
 // ALWAYS exits 0 and any failure degrades to no output, so neither the tick nor
 // the emit can ever wedge prompting.
 import { readFileSync, writeFileSync } from 'node:fs';
@@ -38,10 +39,12 @@ export function turn(cwd, _args) {
  *
  * A step is in flight when a STEP marker (the flat control file recording the
  * step between `build` and `checkpoint`) is present. Guidance only: it reminds a
- * fresh session that a tangent is a park (not an edit) and how the step lands,
- * since the build prose may not be in context after compaction or on a
- * scripted turn. Exported because an in-process test cannot read the hook's
- * real stdout.
+ * fresh session that a tangent is a park (not an edit), that the park's own
+ * block is the whole turn when the message is only a tangent, that a message
+ * which also asks something is answered first with the block after the answer,
+ * and how the step lands, since neither the build nor the park prose may be in
+ * context after compaction or on a scripted turn.
+ * Exported because an in-process test cannot read the hook's real stdout.
  */
 export function stepInFlightContext(cwd) {
     const root = findSessionRoot(cwd);
@@ -51,8 +54,12 @@ export function stepInFlightContext(cwd) {
     if (step === null)
         return null;
     const text = `plumbbob: step ${step} is in flight — a new idea or tangent is a park, not an edit: ` +
-        `capture it with \`plumbbob park "<one line>"\`, then stay on the step. ` +
-        `It lands when you run \`plumbbob checkpoint ${step}\` after approval.`;
+        `capture it with \`plumbbob park "<one line>"\` and relay the block it prints whole, ` +
+        `with nothing written around it, since that block is the whole turn. ` +
+        `The one exception is a message that also asks something: answer the question first, ` +
+        `then relay the park's block after the answer and write nothing after it. ` +
+        `The block's pointer back at the step closes the turn either way, so run no \`plumbbob handoff\` after it. ` +
+        `The step stays open and lands when you run \`plumbbob checkpoint ${step}\` after approval.`;
     return `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: text } })}\n`;
 }
 /**

package/dist/verbs/use.js

@@ -11,7 +11,7 @@
 import { existsSync } from 'node:fs';
 import { findRepoRoot } from "../lib/git.js";
 import { activeBuild, hasSession, intentPath, listBuilds, setActiveBuild, stepPath } from "../lib/sidecar.js";
-import { advisory, ending, notice, transition } from "../lib/notice.js";
+import { advisory, ending, notice, printEnding, transition } from "../lib/notice.js";
 import { driverPointer } from "./handoff.js";
 /**
  * Switch the active-build cursor to the named build.
@@ -43,22 +43,26 @@ export function use(cwd, args) {
     // The lead line, then the advisory it qualifies, then the pointer into the
     // build just switched to: one fixed order for every ending, so the relay never
     // has to guess which line leads.
-    process.stdout.write(ending({
-        lead: transition({
-            label: 'Active build',
-            fact: target,
-            detail: existsSync(stepPath(root, target)) ? ['a step is in flight'] : [],
+    printEnding(root, {
+        tier: 'driver',
+        render: 'use',
+        text: ending({
+            lead: transition({
+                label: 'Active build',
+                fact: target,
+                detail: existsSync(stepPath(root, target)) ? ['a step is in flight'] : [],
+            }),
+            advisories: left === null
+                ? []
+                : [
+                    advisory({
+                        fact: `build "${left}" has a step in flight`,
+                        detail: ['its in-flight state is preserved'],
+                        remedy: `plumbbob use ${left} to pick it back up`,
+                    }),
+                ],
+            pointer: driverPointer(root, target),
         }),
-        advisories: left === null
-            ? []
-            : [
-                advisory({
-                    fact: `build "${left}" has a step in flight`,
-                    detail: ['its in-flight state is preserved'],
-                    remedy: `plumbbob use ${left} to pick it back up`,
-                }),
-            ],
-        pointer: driverPointer(root, target),
-    }));
+    });
     return 0;
 }

package/hooks/hooks.json

@@ -22,6 +22,13 @@
           { "type": "command", "command": "sh \"${CLAUDE_PLUGIN_ROOT}/bin/plumbbob\" turn" }
         ]
       }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          { "type": "command", "command": "sh \"${CLAUDE_PLUGIN_ROOT}/bin/plumbbob\" relay" }
+        ]
+      }
     ]
   }
 }

package/node_modules/checkride/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "checkride",
   "displayName": "checkride",
-  "version": "0.12.2",
+  "version": "0.12.5",
   "description": "Bounded, contract-aware readers for what checkride already writes: triage a red gate and read quality signal without loading megabytes of raw artifacts.",
   "author": { "name": "Rob McLarty", "email": "hello@robmclarty.com", "url": "https://robmclarty.com" },
   "homepage": "https://robmclarty.github.io/checkride/",