plumbbob 0.13.4 → 0.13.6

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/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.4",
+  "version": "0.13.6",
   "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",

package/skills/build/SKILL.md

@@ -168,19 +168,23 @@ switch with `/model` and rerun to honor it, or wave you on. Advisory, never a ga
    fence's 80 columns (13 of label, 67 of value); two or more items break onto indented
    continuation lines opening with `-`, and a red row's evidence onto an indented `→` line.
 
-   The `## Summary` lead and the `## <n>` section titles are the turn's opening block:
-   handoff prints the lead behind the `**Summary**:` label, appends the `(details: …)`
-   bracket, and renders the titles as the numbered highlights, so you type neither the path
-   nor the list. Five highlights at most, each one sentence and one move, plain English
-   first, a path in backticks only when the name itself is the news. The numbers are
-   handles: "expand 2" opens `## 2`, so every highlight has a section behind it with the
-   full story. A judgment or a flag (a stray the seam row will name, a decision you had to
-   bend, a doubt about the done-when) is one of those highlights, never a paragraph of its
-   own. The recommendation is the last section: the move you would take as its own
+   The `## Summary` lead opens the card: handoff prints it behind the `**Summary**:` label.
+   The `## <n>` sections stay in the detail file, where `expand 2` opens `## 2` and the
+   build log's record keeps them; the card prints none of them and closes instead on a
+   `[more details](…)` link to the file, which handoff writes, so you type no path. Five
+   sections at most, each titled with one sentence and one move, plain English first, a
+   path in backticks only when the name itself is the news. A judgment or a flag (a stray
+   the seam row will name, a decision you had to bend, a doubt about the done-when) is one
+   of those sections, and the card carries it where it bears on the call: a bent row's `→`
+   line points at it, and your recommendation names it when it changes the move. It is
+   never a paragraph of its own. The recommendation is the last section: the move you would take as its own
    sentence, closed by a period, then the reason as a capitalized sentence or two. The lead
    and the recommendation are flowing prose and handoff unwraps both to the renderer's
    width, so never hard-wrap them; handoff also prepends the bold `**Recommendation**:`
-   label, which you never type. `checkpoint` records this file beneath the step's dated
+   label, which you never type. A shell command you want the human to run never rides
+   inside a sentence: end the sentence on a colon and give the command a fenced `sh` block
+   of its own, one command to a line, which handoff keeps line for line. A slash command
+   or a path stays in backticks in the sentence. `checkpoint` records this file beneath the step's dated
    line in the build-log's `## Log` and then truncates it, so the detail lands in the
    tracked ledger rather than piling up on disk.
 
@@ -192,14 +196,15 @@ switch with `/model` and rerun to honor it, or wave you on. Advisory, never a ga
 
    *Paste the turn.* Run `plumbbob handoff` and paste its output whole, verbatim, at top
    level, trailing blank line included, then end the turn. Never nest it inside a fence of
-   your own; it carries fences of its own and they cannot nest. It prints the Now line
-   naming the step in flight, the Summary and its highlights, the Readout fence (its
-   measured `check`, `seam`, `diff`, and `spent` rows folded with your three), a `diff`
-   fence when the change is 20 lines or fewer, the Verdict folded worst-of from the same
-   rows, Next Up, Your Call, and your recommendation last. Run it once: a second run at an
-   unchanged pause prints the one-line reminder instead of the card, so if that line comes
-   back where the card belongs (you ran handoff earlier in this turn), run
-   `plumbbob handoff --full` and paste that. The gate verdict's one home is that `check`
+   your own; it carries fences of its own and they cannot nest. It prints the Summary, the
+   Readout fence (its measured `check`, `seam`, `diff`, and `spent` rows folded with your
+   three, the changed files listed beneath `diff`), a `diff` fence when the change is 20
+   lines or fewer, Your Call, the state table (the Verdict folded worst-of from the same
+   rows, the Now row naming the step in flight, Next Up, and the Range, Order, and Parked
+   rows when they apply), your recommendation, and the `more details` link last. Run it
+   once: a second run at the same pause prints the one-line reminder instead of the card,
+   so if that line comes back where the card belongs (you ran handoff earlier in this
+   turn), run `plumbbob handoff --full` and paste that. The gate verdict's one home is that `check`
    row: no standalone verdict line exists, and you never restate the verdict in prose. A
    narrowed run names the slots it skipped there (`· without test`), and that named
    narrowing is the whole disclosure. The notice checkride's Stop hook appends after your
@@ -208,37 +213,39 @@ switch with `/model` and rerun to honor it, or wave you on. Advisory, never a ga
    one, the write-versus-relay line of
    [D78 (em-dash-ban)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d78).
 
-   *Then read the reply as an ask or a direction.* A message that **asks** ("expand 2",
-   "what does that mean?", "why did the seam row flag that?") is an expand: answer it from
-   the detail file, from `git diff`, or from the build-log's `## Log` for an older step,
-   never from recall, then run `plumbbob handoff` and paste its output beneath your answer,
-   whole and verbatim. The turn is your answer, then that output, and nothing after it. The
-   pause renders its card once
-   ([D87 (pause-once)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d87)):
-   while nothing about it has changed, handoff prints one line,
-   `**Next Up**: Back to Step <N> of <M> - <title>`, in place of the card the human already
-   read, so your answer stays on screen. The CLI picks the form, never you: paste whichever
-   one it prints, and never retype the card or reach for `--full` to put it beneath an
-   answer.
-
-   Two moments bring the whole card back, and in both you run `plumbbob handoff --full` and
-   paste its output whole, with nothing written around it: the human asks to see the pause
-   (`show the pause`, or any wording of it), or the card is not in this conversation (a
-   fresh session, or one after `/clear`, that finds the step still at its pause). A
-   message that **directs** is needs-work: take it as what to change, and nothing lands
-   until the human says `looks good`. Once the change is made, rewrite the detail file and
-   end on `plumbbob handoff` as the first render did; the pause has changed, so it prints
-   the whole card.
+   *Then answer the reply in your own words.* The card shows once
+   ([D110 (reply-after-the-card)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d110)):
+   every later turn at this pause is your reply, closed by one line. A message that
+   **asks** ("expand 2", "what does that mean?", "why did the seam row flag that?") is an
+   expand: answer it from the detail file, from `git diff`, or from the build-log's
+   `## Log` for an older step, never from recall. A message that **directs** is needs-work:
+   make the change, run the check, and say what moved and what the check found; when the
+   change moves what the card said (a judgment row, the Summary, the recommendation), write
+   the detail file again so the record matches what lands. Nothing lands until the human
+   says `looks good`. Either way, then run `plumbbob handoff` and paste its output beneath
+   your reply, whole and verbatim: at a pause whose card has shown it prints one line,
+   `**Next Up**: Back to Step <N> of <M> - <title>`, whatever changed since, so your reply
+   stays on screen. The turn is your reply, then that line, and nothing after it. The CLI
+   picks the form, never you: paste whichever one it prints, and never retype the card.
+
+   The card comes back one way: the human asks to see it (`show the pause`, or any wording
+   of it). Then run `plumbbob handoff --full` and paste its output whole, with nothing
+   written around it. Never run `--full` to read the card for yourself, after a compaction
+   or in a fresh session; what it prints is the turn's ending, and the relay check holds a
+   turn that does not close on it. Read the detail file and `plumbbob status` instead. A
+   tangent the human hands you at the pause is still a park.
 
    **Then hand off with the next model.** `plumbbob checkpoint` prints the whole boundary
-   ending itself: `**Checkpoint**: Step N complete (<sha>)`, the Verdict the step earned,
-   any advisory (a staged path outside the seam is the common one), the Stop part when
-   this landing completes a range (`**Stop**: Range 3 of 5 landed - <its stop>`, the reason
-   the build stops here), and Next Up. Relay that block whole, the Stop part with the rest
-   (the relay check holds a boundary that dropped it), run no second command, and write
-   nothing around it. It is the
-   orientation tier (no Your Call block, no recommendation), and it points at the next
-   undone step carrying that step's `- model:` recommendation (the plan's
+   ending itself: `**Checkpoint**: Step N complete (<sha>)`, any advisory (a staged path
+   outside the seam is the common one), and the state table: the Verdict the step earned,
+   the Stop row when this landing completes a range (`| Stop | Range 3 of 5 landed - <its
+   stop> |`, the reason the build stops here), Next Up, and the rows beneath it. Relay that
+   block whole, the table with the rest (the relay check holds a boundary that dropped a
+   row), run no second command, and write nothing around it. A later turn at this boundary
+   is your reply; a `plumbbob handoff` there prints Next Up's one line, since the boundary
+   has shown. It is the
+   orientation tier (no Your Call block, no recommendation), and its Next Up points at the
+   next undone step carrying that step's `- model:` recommendation (the plan's
    smallest-model-that-fits call) so the human knows which `/model` to select before
    running `/plumbbob:build` again. It is what carries the plan's suggestion across a fresh
    context window, which inherits the session model, not the plan's. No `- model:` line
@@ -376,13 +383,13 @@ out, or the next step in build order is one the range does not name),
   the next one. A run's range ends on the stop card, which lists every open park with a
   proposed class, and the reply that settles the card records them (the run skill's
   section on the reply at a stop). A range landed here, by a typed range, ends on the plain
-  boundary instead; when the human asks what comes next there with parks open (the note's
-  `parked 2 of 7 open`), the move is `/plumbbob:harvest`, then the run the card names.
+  boundary instead; when the human asks what comes next there with parks open (the table's
+  `Parked` row, `2 of 7 open`), the move is `/plumbbob:harvest`, then the run the card names.
 - **After an early stop, settle the step, then rerun what is left.** A halt on trouble
   inside a range ends at that step's pause, and the grant ends with the turn. Once the
-  human approves and the step lands, the note beneath Next Up names the run that lands
-  what is left of the range (`· range 3 of 5: /plumbbob:run (steps 8-9)`), and that is what
-  the human types to carry on; `/plumbbob:build 8-9` lands the same steps by hand.
+  human approves and the step lands, the state table's Range row names the run that lands
+  what is left of the range (`| Range | 3 of 5: /plumbbob:run (steps 8-9) |`), and that is
+  what the human types to carry on; `/plumbbob:build 8-9` lands the same steps by hand.
 
 ## The hard contracts
 

package/skills/finish/SKILL.md

@@ -41,7 +41,13 @@ record.
    - `## Decisions and why`: the settled calls that shaped the build (the *why* behind
      the log). Copy each one's `D# (slug)` from `intent.md` (never a bare `D#`) so
      the report reads without flipping back to the intent.
-   - `## Parked & harvested`: what was captured and how each was classified.
+   - `## Parked & harvested`: what was captured and how each was classified, as the
+     table the stop card's leans use, with the settled class where the card had the lean
+     ([D112 (lean-table)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d112)):
+     `| Park | What it is | Why it matters | Settled |`, one row per park, its handle and a
+     short title, the park's text as the Park list holds it, why it matters (the why the
+     stop's record kept, or your own clause for a park harvested before the table), and
+     the class it settled as with its reason.
    - `## Final status`: done or partial, and what is left.
    - `## Deferred tangents`: the harvested items that become future work.
    Stop there. `plumbbob finish` appends `## Checkpoints` (the baseline and step SHAs) and
@@ -74,9 +80,9 @@ record.
    the `plumbbob finish` marker subject only.
 4. **Point at the next goal.** Relay `plumbbob finish`'s output verbatim, blank lines
    included: its lead line, which names the branch the tracked folder now rides into the
-   PR, any advisory beneath it, and `**Next Up**: Nothing planned - /plumbbob:plan`. That
-   is the orientation tier's close (the
-   [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)):
+   PR, any advisory beneath it, and its state table, whose one row is
+   `| **Next Up** | Nothing planned - /plumbbob:plan |`. That is the orientation tier's close
+   (the [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)):
    the lead line, then the forward pointer. `finish` renders that pointer itself rather
    than leaving it to `plumbbob handoff`, because finish has just cleared the session
    handoff would read one from. Relay the block and write nothing after it.