plumbbob 0.13.3 → 0.13.5

package/dist/verbs/harvest.js

@@ -10,8 +10,10 @@
 // A stop's record is latched (D103 (stop-latched)). It refuses in the turn
 // the stop card printed, since a run's long turn ends on proposals and that is
 // where a model would carry straight on into recording its own; it refuses a
-// range's detail no stop card showed, read off the digest the card's STOP
-// stamp keeps; and it refuses a range that no longer reads as landed, telling
+// range no stop card showed, read off the range the card's STOP stamp names,
+// though not a detail file rewritten since, which is a lean the human changed
+// in a reply (D110 (reply-after-the-card)); and it refuses a range that no
+// longer reads as landed, telling
 // a step landed and reopened from one that joined the range after it landed,
 // which moves to a range still to come. A harvest outside a stop (`# Detail · Harvest`) needs no stamp. A proposal
 // naming a handle the list lacks (`P9` with eight parked), or a class outside
@@ -24,9 +26,9 @@ import { ending, notice, printEnding, transition } from "../lib/notice.js";
 import { appendHarvest, appendToSection, flipParks, harvestLines, logEntry, stopLogLine } from "../lib/buildlog.js";
 import { checkStopLatch } from "../lib/latch.js";
 import { parseBuildRanges, parseDetailStep, parseLastCheckpoint, parseOrderedSteps, stepShas } from "../lib/orient.js";
-import { activeBuild, buildLogPath, checkpointsPath, clearDetail, clearStop, detailDigest, detailPath, hasSession, intentPath, readStop, } from "../lib/sidecar.js";
+import { activeBuild, buildLogPath, checkpointsPath, clearDetail, clearStop, detailPath, hasSession, intentPath, readStop, } from "../lib/sidecar.js";
 import { hasStep } from "../lib/steplist.js";
-import { boundaryEnding, harvestProposals, parkList, parseDetailRange, stopRecord } from "./handoff.js";
+import { boundaryEnding, harvestProposals, isHarvestDetail, parkList, parseDetailRange, stopRecord, } from "./handoff.js";
 // The three classes a park settles as, in the order the ending counts them.
 const CLASSES = ['blocker', 'tangent', 'pivot'];
 // Where a refusal about the proposals sends the model: the file it wrote them in.
@@ -57,7 +59,7 @@ export function harvest(cwd, _args) {
     const parks = parkList(buildLog);
     let stop = null;
     if (item !== null) {
-        const found = stopRange(root, slug, intent, detail, item);
+        const found = stopRange(root, slug, intent, item);
         if (typeof found === 'string') {
             process.stderr.write(found);
             return 1;
@@ -101,26 +103,31 @@ export function harvest(cwd, _args) {
     printEnding(root, {
         tier: 'orientation',
         render: 'harvest',
-        text: ending({ lead, pointer: boundaryEnding(root, slug, null).pointer }),
+        text: ending({ lead, state: boundaryEnding(root, slug, null).state }),
     });
     return 0;
 }
 /**
  * The range a range's detail reviews, once the record may land: the plan
- * holds the range, a stop card showed this detail, a human turn has read it,
+ * holds the range, a stop card for it has shown, a human turn has read it,
  * and every step of the range has landed. Otherwise the refusal, with the move
  * that unblocks it.
  *
+ * The card need not have shown this detail file byte for byte: a reply that
+ * changed a lean rewrote the file without printing the card again, and the
+ * change is the human's own (D110 (reply-after-the-card)).
+ *
  * An undone step in the range reads two ways, told apart by the ledger. One
  * with a `step N <sha>` line landed and was reopened, so it lands again and
- * the card re-renders. One with none joined the range after the card, a
+ * the card prints again on `--stop --full`, since the range it reviews has
+ * changed under it. One with none joined the range after the card, a
  * blocker folded into the range that just landed, and `handoff --stop` would
  * refuse too, since the last landing no longer completes the range; so the
  * remedy moves the step to a range still to come and runs the record again,
  * which holds in the same reply while the detail file stays as the card
  * showed it.
  */
-function stopRange(root, slug, intent, detail, item) {
+function stopRange(root, slug, intent, item) {
     const plan = parseBuildRanges(intent);
     const count = plan.ranges.length + plan.malformed.length;
     const range = plan.ranges.find((r) => r.item === item);
@@ -129,22 +136,22 @@ function stopRange(root, slug, intent, detail, item) {
         return refuse(`the plan has no range ${item}`, `write the range's number in the header of .plumbbob/detail.md`);
     }
     const stamp = readStop(root, slug);
-    if (stamp === null || stamp.range !== item || stamp.detail !== detailDigest(detail)) {
-        return refuse('no stop card showed its detail', 'plumbbob handoff --stop, then end the turn on the card');
+    if (stamp === null || stamp.range !== item) {
+        return refuse('no stop card showed it', 'plumbbob handoff --stop, then end the turn on the card');
     }
     if (!checkStopLatch(root, stamp.turn)) {
         return refuse("its card printed this turn, and no human turn has read it", "end the turn on the card; the human's reply is what records it");
     }
     const held = parseOrderedSteps(intent).filter((s) => hasStep(range.steps, s.n));
     if (held.length === 0) {
-        return refuse('the plan holds none of its steps', 'land it, then plumbbob handoff --stop');
+        return refuse('the plan holds none of its steps', 'land it, then plumbbob handoff --stop --full');
     }
     const open = held.find((s) => !s.done);
     if (open !== undefined) {
         // A step the ledger landed was reopened since, and lands again; one it never
         // landed was folded into the range after the card, and moves out instead.
         return stepShas(readOr(checkpointsPath(root, slug))).has(open.n)
-            ? refuse(`step ${open.n} is open again`, 'land it, then plumbbob handoff --stop')
+            ? refuse(`step ${open.n} is open again`, 'land it, then plumbbob handoff --stop --full')
             : refuse(`step ${open.n} joined it after it landed`, `move step ${open.n} to a range still to come, then plumbbob harvest`);
     }
     return { item, count, stop: range.stop };
@@ -183,14 +190,6 @@ function boundaryWords(root, slug) {
     const last = parseLastCheckpoint(readOr(checkpointsPath(root, slug)));
     return last === null ? 'before the first step landed' : `at the step ${last.n} boundary`;
 }
-/**
- * Whether a detail file is a boundary harvest's wire, read off its
- * `# Detail · Harvest` header.
- */
-export function isHarvestDetail(detail) {
-    const first = detail.trimStart().split('\n', 1)[0] ?? '';
-    return /^#\s+Detail\s*·\s*Harvest\s*$/.test(first);
-}
 /**
  * The refusal for a detail file that is no range's and no harvest's: a step's
  * is checkpoint's to record, and an empty one, or one with no header, records nothing.

package/dist/verbs/order.js

@@ -7,15 +7,18 @@
 // `checkpoint`, `handoff`), so the dashboard's `← next`, a bare
 // `plumbbob build`, and the card's Next Up agree. The verb validates what a
 // hand edit cannot: every number names an undone step, none twice. `--reset`
-// drops the line, and the plan reads in document order again. It runs in any
-// state, since re-sequencing what comes after the step in flight is the
-// mid-step use, and the sidecar sits outside every seam.
+// drops the line, and the plan reads in document order again. Either way the
+// build ranges are re-cut to follow the order written, wherever the order
+// settles which range a step is in, so a step placed next runs in the range
+// it now builds with. It runs in any state, since re-sequencing what comes
+// after the step in flight is the mid-step use, and the sidecar sits outside
+// every seam.
 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 { expandStepList, parseStepList } from "../lib/steplist.js";
-import { ending, notice, printEnding, transition } from "../lib/notice.js";
+import { clearBuildOrder, orderSteps, parseBuildRanges, parseOrderedSteps, parseSteps, rangeStanding, recutPlan, setBuildOrder, } from "../lib/orient.js";
+import { expandStepList, formatStepList, parseStepList } from "../lib/steplist.js";
+import { advisory, blocks, ending, notice, printEnding, transition } from "../lib/notice.js";
 import { driverPointer } from "./handoff.js";
 /**
  * Set the build order to the given step numbers and spans, the rest of the
@@ -36,15 +39,7 @@ export function order(cwd, args) {
     const path = intentPath(root);
     const intent = readFileSync(path, 'utf8');
     if (args.includes('--reset')) {
-        writeFileSync(path, clearBuildOrder(intent));
-        printEnding(root, {
-            tier: 'driver',
-            render: 'order',
-            text: ending({
-                lead: transition({ label: 'Build order', fact: 'document order' }),
-                pointer: driverPointer(root, activeBuild(root)),
-            }),
-        });
+        writeOrder(root, path, clearBuildOrder(intent), 'document order');
         return 0;
     }
     // Numbers and spans arrive space- or comma-separated, with or without a space
@@ -98,17 +93,66 @@ export function order(cwd, args) {
     const full = orderSteps(steps, given)
         .filter((s) => !s.done)
         .map((s) => s.n);
-    writeFileSync(path, setBuildOrder(intent, full));
-    // 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.
+    writeOrder(root, path, setBuildOrder(intent, full), full.join(', '));
+    return 0;
+}
+/**
+ * Write the plan under its new build order, its ranges re-cut to follow it,
+ * and print the ending: the order, the ranges the re-cut changed, any range it
+ * left for the human to re-cut, and the pointer.
+ *
+ * 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.
+ */
+function writeOrder(root, path, ordered, sequence) {
+    const { intent, recut } = recutPlan(ordered);
+    writeFileSync(path, intent);
+    const standing = rangeStanding(parseBuildRanges(intent), parseOrderedSteps(intent), null);
     printEnding(root, {
         tier: 'driver',
         render: 'order',
         text: ending({
-            lead: transition({ label: 'Build order', fact: full.join(', ') }),
+            lead: blocks([transition({ label: 'Build order', fact: sequence }), recutLead(recut, standing.count)]),
+            advisories: rangeAdvisories(standing),
             pointer: driverPointer(root, activeBuild(root)),
         }),
     });
-    return 0;
+}
+/**
+ * The lead naming each range the re-cut changed and the steps it names now,
+ * `range 2 of 3 re-cut (steps 10,4-6)`; null when it changed none.
+ */
+function recutLead(recut, count) {
+    const [only] = recut;
+    if (only === undefined) {
+        return null;
+    }
+    const steps = (cut) => `${cut.steps.length === 1 ? 'step' : 'steps'} ${formatStepList(cut.steps)}`;
+    const items = recut.map((cut) => cut.item).join(', ');
+    return transition({
+        label: 'Build ranges',
+        fact: `${recut.length === 1 ? 'range' : 'ranges'} ${items} of ${count} re-cut`,
+        detail: recut.length === 1 ? [steps(only)] : recut.map((cut) => `range ${cut.item}: ${steps(cut)}`),
+    });
+}
+/**
+ * Every range still flagged once the re-cut is written, in the words the
+ * dashboard flags it with, and beneath the last the move that re-cuts it by
+ * hand: the ties the order did not settle, a step no range can take, and the
+ * plan's other drift. Empty when every undone step sits in one stretch of one
+ * range.
+ */
+function rangeAdvisories(standing) {
+    const { count, drift } = standing;
+    const own = drift.filter((d) => d.item !== null && d.kind !== 'malformed');
+    const flagged = [...new Set(own.map((d) => d.item))].map((item) => ({
+        fact: `range ${item} of ${count} needs a re-cut`,
+        detail: own.filter((d) => d.item === item).map((d) => d.words),
+    }));
+    const lines = [...flagged, ...drift.filter((d) => d.item === null || d.kind === 'malformed').map((d) => ({ fact: d.words }))];
+    if (lines.length === 0) {
+        return [];
+    }
+    return [lines.map((l, i) => advisory(i === lines.length - 1 ? { ...l, remedy: '/plumbbob:refine ranges' } : l)).join('')];
 }

package/dist/verbs/relay.js

@@ -66,7 +66,9 @@ export function relayCheck(cwd, 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);
+    // The session the payload names, else the one the process stands in: the
+    // rule the turn hook ticks by, so the two always read the same session.
+    const root = (typeof payload.cwd === 'string' ? findSessionRoot(payload.cwd) : null) ?? findSessionRoot(cwd);
     if (root === null)
         return null;
     const record = readRelay(root);
@@ -135,13 +137,24 @@ function sameParts(relayed, printed, counted) {
 }
 /**
  * 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
+ * whitespace aside, and the Verdict's fact. 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] ?? '')}`;
+    return `${flat(readout === undefined ? '' : tableOf(readout))}\n${flat(verdict === undefined ? '' : verdictOf(verdict))}`;
+}
+/**
+ * The Verdict's fact: the second cell of the state table's header row, where
+ * a card carries it (D111 (state-table)), or the text after the label on the
+ * line an older ending printed. Read as the fact, not the line, so a relay
+ * that changed the spacing around the table's pipes still carries the Verdict
+ * it printed.
+ */
+function verdictOf(part) {
+    const first = part.lines[0] ?? '';
+    return stateRowOf(first)?.value ?? first.replace(/^\*\*Verdict\*\*:\s*/, '');
 }
 /** The `text` fence inside the Readout part, rails included, or '' when it has none. */
 function tableOf(part) {
@@ -180,8 +193,8 @@ function blockCount(part) {
 }
 /**
  * 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.
+ * bold label and a colon, or on a row of the state table, outside a fence, and
+ * runs to the next. Text before the first label is not part of any.
  */
 function partsOf(text) {
     const parts = [];
@@ -196,7 +209,7 @@ function partsOf(text) {
             parts.at(-1)?.lines.push(line);
             continue;
         }
-        const label = rail === null ? /^\*\*([^*\n]+)\*\*:(?:\s|$)/.exec(line)?.[1] : undefined;
+        const label = rail === null ? labelOf(line) : undefined;
         if (label !== undefined) {
             parts.push({ label, lines: [line] });
         }
@@ -206,6 +219,35 @@ function partsOf(text) {
     }
     return parts;
 }
+/**
+ * The label a line opens a part on, or undefined when it opens none: a bold
+ * label and a colon at the line's start, or a state-table row, whose first
+ * cell is its label. Each row of the table is a part of its own, so the
+ * table's rows are read in order as the labeled lines were.
+ */
+function labelOf(line) {
+    return /^\*\*([^*\n]+)\*\*:(?:\s|$)/.exec(line)?.[1] ?? stateRowOf(line)?.label;
+}
+/**
+ * A state-table row's label and fact, or null for any other line: a table row
+ * of two cells, its label with the bold stripped. The delimiter row and the
+ * lean table's four-cell rows are no state row, so they stay inside the part
+ * above them.
+ */
+function stateRowOf(line) {
+    const cells = tableCells(line);
+    const [label, value] = cells ?? [];
+    if (cells === null || cells.length !== 2 || label === undefined || value === undefined || /^:?-{3,}:?$/.test(label))
+        return null;
+    return { label: label.replace(/^\*\*(.*)\*\*$/, '$1').trim(), value };
+}
+/** The cells of a markdown table row, split on unescaped pipes, or null when the line is not one. */
+function tableCells(line) {
+    const text = line.trim();
+    if (text.length < 2 || !text.startsWith('|') || !text.endsWith('|'))
+        return null;
+    return text.slice(1, -1).split(/(?<!\\)\|/).map((c) => c.trim());
+}
 /**
  * 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.

package/dist/verbs/turn.js

@@ -13,28 +13,37 @@
 // range the run is landing. The harness also sends a background job's
 // completion notice through this event, as a prompt the human never typed, so
 // a notice ticks nothing, keeps the grant and the mark, and clears only the
-// ending `RELAY` holds from an earlier turn. When a step is in flight a typed
-// prompt 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, 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.
+// ending `RELAY` holds from an earlier turn. A typed prompt also emits ONE
+// `UserPromptSubmit` additionalContext line when there is a beat to keep, so a
+// fresh session (post-compaction, or a scripted `-p` turn where no skill prose
+// is in context) still knows it: mid-step, a tangent is parked, not chased;
+// at a pause or a stop whose card has shown, the message is the human's reply,
+// answered in the model's own words and closed on the one line `handoff`
+// prints, never on the card again (D110 (reply-after-the-card)). 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';
 import { parseBuildRanges, readRunArgs, resolveRun } from "../lib/orient.js";
-import { clearRelay, findSessionRoot, inSpike, intentPath, notePrompt, readPrompt, readRun, setGrant, setRun, stepPath, turnPath, } from "../lib/sidecar.js";
+import { activeBuild, clearRelay, findSessionRoot, inSpike, intentPath, notePrompt, readPause, readPrompt, readRun, setGrant, setRun, stepPath, turnPath, } from "../lib/sidecar.js";
 import { hasStep, normalizeStepList, readBuildArgs } from "../lib/steplist.js";
+import { waitingCard } from "./handoff.js";
 /**
- * The hook entry point: apply the prompt, then emit the in-flight-step nudge
- * when it counted as a human turn.
+ * The hook entry point: apply the prompt, then emit the nudge when it counted
+ * as a human turn.
  *
+ * The session is the one the payload's `cwd` names when it names one, else
+ * the one the process stands in, the rule the `Stop` check follows too, so the
+ * turn that ticks and the turn that is judged are always the same session's.
  * Always returns 0: a broken turn must never wedge a prompt, so any failure is
  * swallowed and degrades to no output.
  */
 export function turn(cwd, _args) {
     try {
-        if (applyTurn(cwd, readStdin())) {
-            const context = stepInFlightContext(cwd);
+        const raw = readStdin();
+        const { cwd: named, prompt } = readPayload(raw);
+        const where = named !== null && findSessionRoot(named) !== null ? named : cwd;
+        if (applyTurn(where, raw)) {
+            const context = turnContext(where, prompt);
             if (context !== null)
                 process.stdout.write(context);
         }
@@ -45,32 +54,102 @@ export function turn(cwd, _args) {
     return 0;
 }
 /**
- * The `UserPromptSubmit` additionalContext payload when a step is in flight, or null.
+ * The `UserPromptSubmit` additionalContext payload for the beat the session is
+ * on, or null when there is none to keep.
  *
- * 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), 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.
+ * Three beats, read off the control files. A step whose pause card has shown
+ * (STEP, and PAUSE naming that step's pause) is waiting for the human's call,
+ * so the message is the reply to it: answered or acted on in the model's own
+ * words, and closed on the one line `handoff` prints rather than the card
+ * again (D110 (reply-after-the-card)). A step in flight with no card yet is
+ * mid-build, where a tangent is a park and not an edit. A stop card waiting
+ * for its reply is the pause's beat at a stop. At a pause or a stop, a
+ * `prompt` asking to see the card (`show the pause`, the phrase the card's
+ * `expand` move teaches) gets the one instruction that matters for it: paste
+ * the `--full` output exactly as it printed, as the whole turn. Guidance only,
+ * since none of the build, run, or 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) {
+export function turnContext(cwd, prompt = '') {
     const root = findSessionRoot(cwd);
     if (root === null)
         return null;
+    const text = nudgeText(root, SHOW_REQUEST.test(prompt));
+    return text === null ? null : `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: text } })}\n`;
+}
+// A message asking to see the card again: `show the pause` and `show the stop`,
+// the phrases the card's `expand` move teaches, and `show me the card` beside
+// them. In a fresh session the model ran `--full` on that request and then
+// retyped the card behind a line of its own, three runs in five of the
+// 2026-10-27 eval, because nothing in its context said how to relay it.
+const SHOW_REQUEST = /\bshow\s+(?:me\s+)?the\s+(?:pause|stop|card)\b/i;
+/**
+ * The nudge's words for the beat the session is on, or null when it is on
+ * none: no step in flight and no stop card waiting. `showing` is a message
+ * that asks to see the card, which at a pause or a stop takes the show nudge.
+ */
+function nudgeText(root, showing) {
     const step = inFlightStep(root);
-    if (step === null)
+    if (step !== null) {
+        const shown = readPause(root);
+        if (shown?.kind !== 'pause' || shown.step !== step)
+            return parkNudge(step);
+        return showing ? showNudge(`step ${step}'s card`, 'plumbbob handoff --full') : pauseNudge(step);
+    }
+    const slug = activeBuild(root);
+    let intent = '';
+    try {
+        intent = readFileSync(intentPath(root, slug), 'utf8');
+    }
+    catch {
         return null;
-    const text = `plumbbob: step ${step} is in flight — a new idea or tangent is a park, not an edit: ` +
+    }
+    const card = waitingCard(root, slug, intent);
+    if (card === null)
+        return null;
+    return showing
+        ? showNudge(`range ${card.range} of ${card.count}'s stop card`, 'plumbbob handoff --stop --full')
+        : stopNudge(card.range, card.count);
+}
+/**
+ * The nudge when the human asks to see a card again: the one command and how
+ * to relay what it prints, since the card is the whole turn and a retyped one
+ * is the miss the relay check holds.
+ */
+function showNudge(card, command) {
+    return (`plumbbob: the human asked to see ${card} again. ` +
+        `Run \`${command}\` and paste its output exactly as it printed, as the whole turn: ` +
+        `no line before it, nothing after it, and nothing in it retyped, reworded, or cut.`);
+}
+/** The mid-build nudge: a tangent is a park, not an edit, and the step lands on approval. */
+function parkNudge(step) {
+    return (`plumbbob: step ${step} is in flight — a new idea or tangent is a park, not an edit: ` +
         `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`;
+        `The step stays open and lands when you run \`plumbbob checkpoint ${step}\` after approval.`);
+}
+/** The nudge at a pause whose card has shown: the message is the reply, and the card is not printed again. */
+function pauseNudge(step) {
+    return (`plumbbob: step ${step}'s card has shown, and this message is the human's reply to it. ` +
+        `An approval lands the step: run \`plumbbob checkpoint ${step}\` and relay its ending. ` +
+        `Anything else is answered in your own words: answer the question, or make the change it asks for, ` +
+        `and when a change moves what the card said, write \`.plumbbob/detail.md\` again so the record matches what lands. ` +
+        `Print no card for it: run \`plumbbob handoff\` and end the turn on the one line it prints, with nothing after it. ` +
+        `Only when the human asks to see the card again, run \`plumbbob handoff --full\` and paste its output exactly as it printed, as the whole turn. ` +
+        `A tangent the human hands you is still a park: \`plumbbob park "<one line>"\`.`);
+}
+/** The nudge at a stop card waiting for its reply: the stop's version of the pause's. */
+function stopNudge(range, count) {
+    return (`plumbbob: range ${range} of ${count}'s stop card has shown, and this message is the human's reply to it. ` +
+        `An approval records the stop: fold each confirmed blocker into the plan, then run \`plumbbob harvest\` and relay its ending. ` +
+        `Anything else is answered in your own words: answer the question, or make the change it asks for ` +
+        `(a lean is its line under the detail file's \`## Harvest\`). ` +
+        `Print no card for it: run \`plumbbob handoff --stop\` and end the turn on the one line it prints, with nothing after it. ` +
+        `Only when the human asks to see the card again, run \`plumbbob handoff --stop --full\` and paste its output exactly as it printed, as the whole turn.`);
 }
 /**
  * The in-flight step number, or null when no STEP marker is present.
@@ -251,13 +330,13 @@ function readBuild(root) {
     }
 }
 /**
- * The `prompt` and `prompt_id` fields of the UserPromptSubmit JSON, as '' and
- * null when either is absent.
+ * The `prompt`, `prompt_id`, and `cwd` fields of the UserPromptSubmit JSON, as
+ * '' and null when any is absent.
  *
  * Absent, unparseable, or non-string input contributes nothing rather than
  * wedging the tool: the tick still lands (a human turn did occur), the empty
- * prompt clears any GRANT, and a missing id records none; the verb never
- * throws over bad stdin.
+ * prompt clears any GRANT, a missing id records none, and a missing `cwd`
+ * leaves the process's; the verb never throws over bad stdin.
  */
 function readPayload(raw) {
     try {
@@ -265,10 +344,11 @@ function readPayload(raw) {
         return {
             prompt: typeof parsed.prompt === 'string' ? parsed.prompt : '',
             promptId: typeof parsed.prompt_id === 'string' && parsed.prompt_id !== '' ? parsed.prompt_id : null,
+            cwd: typeof parsed.cwd === 'string' && parsed.cwd !== '' ? parsed.cwd : null,
         };
     }
     catch {
-        return { prompt: '', promptId: null };
+        return { prompt: '', promptId: null, cwd: null };
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plumbbob",
-  "version": "0.13.3",
+  "version": "0.13.5",
   "description": "Attention-first build process: 15 skills + a CLI that keep you the decider — guidance on the work, a latch on the record.",
   "keywords": [
     "claude-code",