plumbbob 0.13.4 → 0.13.6

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "plumbbob",
   "displayName": "PlumbBob",
-  "version": "0.13.4",
+  "version": "0.13.6",
   "description": "Attention-first build process — driver skills + a CLI that keep you the decider: guidance on the work, a latch on the record.",
   "author": { "name": "Rob McLarty", "email": "hello@robmclarty.com", "url": "https://robmclarty.com" },
   "homepage": "https://github.com/robmclarty/plumbbob#readme",

package/README.md

@@ -150,12 +150,7 @@ In Claude Code, inside any git repo with a clean tree:
    diff, the model supplies only the judgment, and nothing is written around it.
 
    ````markdown
-   **Now**: Step 1 of 3 - feat(limiter): add a token-bucket limiter
-
-   **Summary**: A per-IP token bucket now refuses the 6th attempt inside a minute. (details: [detail.md](.plumbbob/detail.md))
-
-   1. The bucket lives in memory, keyed by IP, refilling on read: five tokens a minute.
-   2. The clock is injected, so the test advances time instead of sleeping on it.
+   **Summary**: A per-IP token bucket now refuses the 6th attempt inside a minute.
 
    **Readout**:
 
@@ -166,22 +161,27 @@ In Claude Code, inside any git repo with a clean tree:
    constraints  1 of 1 honored
    seam         held: 2 of 2 declared, no strays
    diff         +61 -3 across 2 files
+                - src/limiter.ts +38 -3
+                - test/limiter.test.ts +23 -0
    spent        22 min · 2 turns · 41s gate · green first run
    ```
 
-   **Verdict**: ● Plumb
-
-   **Next Up**: Step 2 of 3 - feat(login): wire the limiter into POST /login (model: **Sonnet**, details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28))
-     · range 1 of 2 lands with step 1
-
    **Your Call**:
 
    - `looks good` → I checkpoint Step 1; back to the boundary
    - `expand`, or any question → I show more of what is there; nothing changes, and `show the pause` brings all of this back
-   - anything that reads as direction → I take it as what to change; nothing lands until you approve
+   - anything that reads as direction → I make the change and say what moved; nothing lands until you approve
    - `revert` → I wind the work back to the last checkpoint
 
+   | **Verdict** | ● Plumb |
+   | --- | --- |
+   | Now | Step 1 of 3 - feat(limiter): add a token-bucket limiter |
+   | Next Up | Step 2 of 3 - feat(login): wire the limiter into POST /login (model: **Sonnet**, details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28)) |
+   | Range | 1 of 2 lands with step 1 |
+
    **Recommendation**: Approve it, refilling on read. The gate is green and the seam held, and a bucket that refills when it is read needs no timer for the route to clean up.
+
+   [more details](.plumbbob/detail.md)
    ````
 
    ![The pause, drawn: a mechanical hand has set its stone on the line and hovers open and still, while a plumb bob in front comes to rest](site/media/pause.svg)
@@ -192,30 +192,30 @@ In Claude Code, inside any git repo with a clean tree:
    `.plumbbob/settings.json`, for example `"check": "npm test"`; in a repo where
    checkride finds no tools at all, `start` says so up front and names that key.)
 3. **Reply.** Say `looks good` and it commits the step as a checkpoint, marks it done,
-   and returns to the boundary, where the line beneath Next Up names the run to type
+   and returns to the boundary, where the Range row beneath Next Up names the run to type
    next and the steps it will land:
 
    ```text
    **Checkpoint**: Step 1 complete (a1b2c3d4e, details: [build-log.md:70](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/build-log.md#L70))
 
-   **Verdict**: ● Plumb
-
-   **Next Up**: Step 2 of 3 - feat(login): wire the limiter into POST /login (model: **Sonnet**, details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28))
-     · range 2 of 2: /plumbbob:run (steps 2-3)
+   | **Verdict** | ● Plumb |
+   | --- | --- |
+   | Next Up | Step 2 of 3 - feat(login): wire the limiter into POST /login (model: **Sonnet**, details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28)) |
+   | Range | 2 of 2: /plumbbob:run (steps 2-3) |
    ```
 
    ![The boundary, drawn: a bench mark freshly cut into the newest course of a stone wall, older marks below, and the red line raised one course over stones not yet laid](site/media/checkpoint-boundary.svg)
 
    Ask instead (`expand 2`, or any question) and it shows more of what is there and
-   changes nothing. The answer closes on one line pointing back at the step, not on the
-   whole block again, since you have already read it; say `show the pause` to see the
-   block again. Direct it and it takes that as the fix, and nothing lands until you say
-   `looks good`.
+   changes nothing. Direct it and it makes the change and tells you what moved. Either
+   way the reply is its own, and it closes on one line pointing back at the step, not on
+   the whole block again, since you have already read it; say `show the pause` to see
+   the block again. Nothing lands until you say `looks good`.
 4. **Run again.** Fire `/plumbbob:run` again; re-firing it *is* the clock tick. Range 2
    lands steps 2 and 3, each on a green check with no pause between them, and ends on the
    **stop card**: the range's review (a summary of both steps, a readout measured across
-   them, the Verdict), with every idea parked along the way listed under `Harvested` and
-   a lean proposed for each. One reply settles it: `looks good` records the review and
+   them, the Verdict), with every idea parked along the way in a table under `Harvested`:
+   each park, why it matters, and the lean proposed for it. One reply settles it: `looks good` records the review and
    every lean, and `make P1 a blocker` changes one first. `/plumbbob:build` stays the
    granular move whenever you want it, one step to its pause. Whenever you lose the
    thread, `/plumbbob:status` shows where you are and names the next move.

package/dist/cli-core.js

@@ -87,17 +87,18 @@ const VERBS = [
     },
     {
         name: 'handoff',
-        description: 'print the footer card that ends a turn (pause, boundary, plan, driver, or stop), or a reminder for a pause or a stop already shown',
-        synopsis: ['handoff [<n>] [--full] [--plan] [--driver] [--stop] [--build <slug>]'],
+        description: 'print the footer card that ends a turn (pause, boundary, plan, driver, stop, or harvest), or the one line for a card already shown',
+        synopsis: ['handoff [<n>] [--full] [--plan] [--driver] [--stop] [--harvest] [--build <slug>]'],
         args: [{ name: '<n>', gloss: 'step to report on (default: the in-flight step, else the last checkpointed one)' }],
         flags: [
-            { name: '--full', gloss: 'print the whole pause card, or with --stop the whole stop card, even when it was already shown' },
+            { name: '--full', gloss: 'print the whole pause card or boundary, or with --stop the whole stop card, even when it was already shown' },
             { name: '--plan', gloss: 'render the plan-pause card instead of a step tier' },
             { name: '--driver', gloss: "render a driver turn's pointer back at the open step" },
             { name: '--stop', gloss: "render the stop card for the range the last landing completed, from the range's detail file" },
+            { name: '--harvest', gloss: "render a boundary harvest's lean table and its moves, from a `# Detail · Harvest` detail file" },
             BUILD_FLAG,
         ],
-        notes: "Writes only the detail file (a blank line around each heading), the PAUSE stamp, and with --stop the STOP stamp; refuses (exit 1) with no session, with two of --plan, --driver, and --stop together, and with --stop when a step is in flight, no range that lands its steps just landed, or the detail file is not that range's.",
+        notes: "Writes only the detail file (a blank line around each heading), the PAUSE stamp naming the card shown, and with --stop the STOP stamp; refuses (exit 1) with no session, with two of --plan, --driver, --stop, and --harvest together, with --stop when a step is in flight, no range that lands its steps just landed, or the detail file is not that range's, and with --harvest when the detail file is not a harvest's or no park is open.",
     },
     {
         name: 'check',
@@ -167,7 +168,7 @@ const VERBS = [
         name: 'harvest',
         description: "record a harvest from the detail file, and at a run's stop the range's review",
         synopsis: ['harvest'],
-        notes: "Reads the detail file's `## Harvest` proposals (`- park 6 → tangent: <reason>`), flips each settled park in build-log.md, appends the dated Harvest lines, and, when the detail is a range's, writes the range's review beneath a dated Log line; then clears the detail file and the STOP stamp, and commits nothing. Refuses (exit 1) with no session, a detail file that is no range's or harvest's, a range's detail in the turn its stop card printed, one no stop card showed, one whose range is open again, or one whose range a step joined after it landed, and a proposal naming a park the list lacks or a class other than blocker, tangent, or pivot.",
+        notes: "Reads the detail file's `## Harvest` proposals (`- P6 → tangent: <reason>`, with `- title:` and `- why:` lines beneath), flips each settled park in build-log.md, appends the dated Harvest lines, and, when the detail is a range's, writes the range's review beneath a dated Log line; then clears the detail file and the STOP stamp, and commits nothing. Refuses (exit 1) with no session, a detail file that is no range's or harvest's, a range's detail in the turn its stop card printed, a range no stop card showed, one whose range is open again, or one whose range a step joined after it landed, and a proposal naming a park the list lacks or a class other than blocker, tangent, or pivot.",
     },
     {
         name: 'spike',

package/dist/lib/notice.js

@@ -11,9 +11,11 @@
 // the edge, and an optional indented arrow line carrying what to do next. One
 // shape, so moving it is one edit rather than a sweep. The pointer at the next
 // step is not a line's job: `handoff` renders one, and the verb prints it as
-// the ending's last part. The formatters are pure string assembly, no fs, no
-// gate; `printEnding` is the one function here that writes, and every ending
-// a verb prints goes through it so the relay check knows what was said.
+// the ending's last part, either as the state table that closes a card or an
+// orientation ending (D111 (state-table)) or as the one labeled line a driver
+// turn ends on. The formatters are pure string assembly, no fs, no gate;
+// `printEnding` is the one function here that writes, and every ending a verb
+// prints goes through it so the relay check knows what was said.
 import { writeRelay } from "./sidecar.js";
 /** The column budget a notice line aims to fit, matching the readout fence. */
 const WIDTH = 80;
@@ -66,15 +68,48 @@ export function advisory(a) {
     return line(`${capitalize(trimFact(a.fact))} ⚠`, a);
 }
 /**
- * Assemble a transition's whole ending: the labeled lead line, the Verdict
- * where one was measured, the advisories, the Stop part where a range landed,
- * and the pointer.
+ * Assemble a transition's whole ending: the labeled lead line, the
+ * advisories, then the state table or the driver's pointer.
  *
  * The order is the type's field order, so a verb composes parts and never a
  * sequence. A part with nothing in it vanishes rather than leaving a gap.
  */
 export function ending(e) {
-    return blocks([e.lead, e.verdict ?? null, ...(e.advisories ?? []), e.stop ?? null, e.pointer ?? null]);
+    return blocks([e.lead, ...(e.advisories ?? []), stateTable(e.state ?? []), e.pointer ?? null]);
+}
+/**
+ * Render the state table: two columns, one row per fact, the first row the
+ * header. '' with no rows, so a caller can pass a table it may not have.
+ *
+ * The header is the fact the human reads first, the Verdict wherever one was
+ * measured, and its label rides bold so it reads as the headline even where a
+ * renderer does not bolden a header row. The rows beneath keep plain labels.
+ * A table rather than labeled lines because these are the facts the human
+ * scans for, and a table is the shape that sets them apart from the prose
+ * around them (D111 (state-table)).
+ *
+ * ```text
+ * | **Verdict** | ● Plumb |
+ * | --- | --- |
+ * | Now | Step 2 of 3 - feat(login): wire the limiter into POST /login |
+ * ```
+ */
+export function stateTable(rows) {
+    const [head, ...body] = rows;
+    if (head === undefined)
+        return '';
+    return [
+        `| **${cell(head.label)}** | ${cell(head.value)} |`,
+        '| --- | --- |',
+        ...body.map((r) => `| ${cell(r.label)} | ${cell(r.value)} |`),
+    ].join('\n');
+}
+/**
+ * A table cell's text: on one line, with every pipe escaped, so a step title
+ * or a park holding one cannot split its row.
+ */
+export function cell(text) {
+    return text.replace(/\s*\n\s*/g, ' ').replace(/\|/g, '\\|').trim();
 }
 /**
  * Stack a turn's parts: one blank line between each, one beneath the last.

package/dist/lib/orient.js

@@ -167,14 +167,14 @@ export function remainingOrder(steps, order, exclude) {
     return byOrder.some((n, i) => n !== byDocument[i]) ? byOrder : [];
 }
 /**
- * The build order as the note's labeled field: `order:`, then the next `cap`
- * step numbers in sequence, the rest folded to a count (`and 2 more`), the way
- * a long detail degrades on every one-liner; '' for an empty order. With no
- * cap, the whole sequence.
+ * The build order as the state table's Order row says it: the next `cap` step
+ * numbers in sequence, the rest folded to a count (`and 2 more`), the way a
+ * long detail degrades on every one-liner; '' for an empty order. With no cap,
+ * the whole sequence.
  *
- * A label, where the phrase once read `build order 7, 8, 5`, because the
- * note's other segments read as labeled fields and a label is how the eye
- * finds one in a line of three (D108 (order-label)).
+ * The label is the row's, `Order`, which is where the note's `order:` field
+ * went when the note became rows (D111 (state-table), revising
+ * D108 (order-label)).
  */
 export function buildOrderPhrase(order, cap) {
     if (order.length === 0) {
@@ -182,7 +182,7 @@ export function buildOrderPhrase(order, cap) {
     }
     const shown = cap === undefined ? order : order.slice(0, cap);
     const rest = order.length - shown.length;
-    return `order: ${shown.join(', ')}${rest > 0 ? ` (and ${rest} more)` : ''}`;
+    return `${shown.join(', ')}${rest > 0 ? ` (and ${rest} more)` : ''}`;
 }
 /**
  * Write `order` as the one numeric line under `## Build order`: in place of
@@ -1602,6 +1602,33 @@ export function countDiff(entries) {
         files: entries.length,
     };
 }
+// How many lines the changed files take beneath the diff row before the rest
+// folds to a count: seven named and `and 5 more`, so the list never runs past
+// eight lines.
+const DIFF_FILES_CAP = 8;
+/**
+ * The changed files beneath the diff row, one `<path> +<added> -<removed>`
+ * item per file, in git's path order. A file several commits touched is
+ * counted once, its lines summed. Past eight files the tail folds to a count
+ * (`and 5 more`), never a silent cut, and a path is never shortened: it is the
+ * name the human opens, and a cut one is wrong where a wrapped one is legible
+ * (D113 (short-card)).
+ */
+export function diffFileItems(entries) {
+    const byPath = new Map();
+    for (const e of entries) {
+        const prior = byPath.get(e.path) ?? { added: 0, removed: 0 };
+        byPath.set(e.path, { added: prior.added + e.added, removed: prior.removed + e.removed });
+    }
+    const items = [...byPath.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([path, c]) => `${path} +${c.added} -${c.removed}`);
+    if (items.length <= DIFF_FILES_CAP) {
+        return items;
+    }
+    const shown = items.slice(0, DIFF_FILES_CAP - 1);
+    return [...shown, `and ${items.length - shown.length} more`];
+}
 /**
  * The diff row's value: `+<added> -<removed> across <N> files`, plus the
  * `inline below` pointer when the patch rides the turn. Null when nothing
@@ -1737,6 +1764,9 @@ export function recapLines(rows, extras) {
     }
     if (extras.diff !== null) {
         body.push(`${'diff'.padEnd(13)}${extras.diff}`);
+        for (const item of extras.files ?? []) {
+            body.push(`${RECAP_INDENT}- ${item}`);
+        }
     }
     if (extras.spent !== null) {
         body.push(`${'spent'.padEnd(13)}${extras.spent}`);
@@ -1780,6 +1810,7 @@ export function measureRange(input) {
         steps: stepsRow(held, shas),
         rows,
         diff: rangeDiffValue(landed.flatMap((l) => l.files)),
+        files: diffFileItems(landed.flatMap((l) => l.files).filter((f) => !isArtifactPath(f.path))),
         spent: rangeSpentValue(stats),
         stats: {
             driftWarnings: sum('driftWarnings'),
@@ -1998,13 +2029,64 @@ function sectionProse(detail, heading) {
     if (text.length === 0) {
         return null;
     }
-    return text
-        .split(/\n{2,}/)
-        .map((paragraph) => paragraph
-        .split('\n')
-        .map((l) => l.trim())
-        .join(' '))
-        .join('\n\n');
+    return proseBlocks(text).join('\n\n');
+}
+/**
+ * Prose's blocks, in order: each paragraph unwrapped onto one line, and each
+ * fenced block kept line for line with its fences trimmed flush.
+ *
+ * A command the human is meant to copy rides a fence of its own
+ * (D114 (command-fences)), and joining its lines would run two commands into
+ * one. A fence opened straight under a sentence still ends that paragraph, so
+ * it always stands between blank lines and renders as a block, never as
+ * backticks inside the sentence. A fence left unclosed keeps everything after
+ * it and is closed here, so it cannot swallow the `more details` link the
+ * card prints beneath it.
+ */
+function proseBlocks(text) {
+    const blocks = [];
+    let paragraph = [];
+    let fence = null;
+    let fenced = [];
+    for (const line of text.split('\n')) {
+        if (fence !== null) {
+            const closed = closesFence(line, fence);
+            fenced.push(closed ? line.trim() : line.trimEnd());
+            if (closed) {
+                blocks.push(fenced.join('\n'));
+                fence = null;
+            }
+            continue;
+        }
+        const opened = fenceOpening(line);
+        if (opened !== null || line.trim() === '') {
+            if (paragraph.length > 0)
+                blocks.push(paragraph.join(' '));
+            paragraph = [];
+        }
+        if (opened !== null) {
+            fence = opened;
+            fenced = [line.trim()];
+        }
+        else if (line.trim() !== '') {
+            paragraph.push(line.trim());
+        }
+    }
+    if (fence !== null)
+        blocks.push([...fenced, fence.char.repeat(fence.length)].join('\n'));
+    if (paragraph.length > 0)
+        blocks.push(paragraph.join(' '));
+    return blocks;
+}
+/** The fence a line opens: three or more backticks or tildes, indented three spaces at most. Null when it opens none. */
+function fenceOpening(line) {
+    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+    return marker === undefined ? null : { char: marker.charAt(0), length: marker.length };
+}
+/** Whether a line closes an open fence: the same character, at least as many of it, and nothing after. */
+function closesFence(line, fence) {
+    const marker = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(line)?.[1];
+    return marker !== undefined && marker.startsWith(fence.char) && marker.length >= fence.length;
 }
 /**
  * The `## Summary` section of `.plumbbob/detail.md` and the numbered detail
@@ -2048,8 +2130,7 @@ export function normalizeDetailHeadings(detail) {
     let afterHeading = false;
     for (const line of detail.split('\n')) {
         if (fence !== null) {
-            const close = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(line)?.[1];
-            if (close !== undefined && close.startsWith(fence.char) && close.length >= fence.length) {
+            if (closesFence(line, fence)) {
                 fence = null;
             }
             out.push(line);
@@ -2060,10 +2141,7 @@ export function normalizeDetailHeadings(detail) {
         if ((heading || afterHeading) && line.trim() !== '' && prior !== undefined && prior.trim() !== '') {
             out.push('');
         }
-        const open = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1];
-        if (open !== undefined) {
-            fence = { char: open.charAt(0), length: open.length };
-        }
+        fence = fenceOpening(line);
         out.push(line);
         afterHeading = heading;
     }
@@ -2101,8 +2179,9 @@ export function parseSections(detail) {
 }
 /**
  * The `## Recommendation` section of `.plumbbob/detail.md`: the one or two
- * plain sentences a decision turn ends on, or null when the model wrote none.
- * `handoff` emits it after the card, unfenced; the eye lands on the last text,
+ * plain sentences a decision turn ends on, each shell command they name in a
+ * `sh` fence of its own, or null when the model wrote none. `handoff` emits it
+ * after the card, the prose itself unfenced; the eye lands on the last text,
  * and the last text should say which move the model would take.
  */
 export function parseRecommendation(detail) {

package/dist/lib/sidecar.js

@@ -18,7 +18,6 @@
 // human-owned (check/auto): the tool only ever reads it, never rewrites it. The
 // phase the dashboard shows (DESIGN/BUILD/SPIKE) is derived, not stored: BUILD ⇔
 // a STEP is in flight, SPIKE ⇔ the SPIKE marker is present, otherwise DESIGN.
-import { createHash } from 'node:crypto';
 import { existsSync, readdirSync, readFileSync, writeFileSync, appendFileSync, rmSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { gitPath } from "./git.js";
@@ -215,56 +214,85 @@ export function clearStep(root, slug) {
     rmSync(stepPath(root, slug), { force: true });
 }
 /**
- * PAUSE: the stamp of the step pause `handoff` last rendered whole, the step
- * number and a hash of what the card showed. While a later render matches it,
- * handoff prints the one-line reminder instead of the card.
+ * PAUSE: which card the human has already read, so a later `handoff` prints
+ * the one line that points back at it instead of the card. It holds a step
+ * number once that step's pause card has shown (`2`), or `landed 2` once the
+ * boundary step 2 landed on has shown.
+ *
+ * It records that a card showed, never what the card said: a later turn that
+ * changes the work is the model's reply, and the card comes back only on
+ * request (D110 (reply-after-the-card)).
  */
 export function pausePath(root, slug) {
     return join(artifactDir(root, slug), 'PAUSE');
 }
 /**
- * Remove the PAUSE stamp: a checkpoint, a revert, or an abandon ends the pause
- * it recorded, so the next pause renders whole. Absent is a no-op.
+ * The card PAUSE says has shown, or null when the file is absent or does not
+ * parse. A stamp written before D110 (reply-after-the-card) holds a step
+ * number and a hash, and reads as that step's pause.
+ */
+export function readPause(root, slug) {
+    try {
+        const m = /^(landed )?(\d+)(?:\s|$)/.exec(readFileSync(pausePath(root, slug), 'utf8').trim());
+        return m === null ? null : { kind: m[1] === undefined ? 'pause' : 'landed', step: Number(m[2]) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Record that a card has shown. Best-effort: a failed write costs one more
+ * full card on a later turn, never this turn's output or its exit code.
+ */
+export function writePause(root, slug, stamp) {
+    try {
+        writeFileSync(pausePath(root, slug), `${stamp.kind === 'landed' ? 'landed ' : ''}${stamp.step}\n`);
+    }
+    catch {
+        // A read-only tree or a vanished build folder: the card still renders.
+    }
+}
+/**
+ * Remove the PAUSE stamp: a revert or an abandon ends the pause it recorded,
+ * so the next pause renders whole. Absent is a no-op.
  */
 export function clearPause(root, slug) {
     rmSync(pausePath(root, slug), { force: true });
 }
 /**
  * STOP: the stamp of the stop card `handoff --stop` last rendered whole, the
- * range it reviews, the TURN it printed in, a hash of what the card showed,
- * and a digest of the detail file it printed from. While a later render
- * matches the range and the hash, handoff prints the one-line reminder;
- * `plumbbob harvest` records the stop only from the detail the card showed,
- * and only once a human turn has read it.
+ * range it reviews and the TURN it printed in. While a later render names the
+ * same range, handoff prints the one-line reminder, whatever changed since;
+ * `plumbbob harvest` records the stop only once a card for the range has shown
+ * and a human turn has read it.
  */
 export function stopPath(root, slug) {
     return join(artifactDir(root, slug), 'STOP');
 }
 /**
  * The stamp of the stop card last rendered, or null when STOP is absent or
- * does not parse.
+ * does not parse. A stamp written before D110 (reply-after-the-card) carries
+ * a hash and a digest after the turn, and both are ignored.
  */
 export function readStop(root, slug) {
     try {
-        const m = /^(\d+) (\d+|-) (\S+)(?: (\S+))?$/.exec(readFileSync(stopPath(root, slug), 'utf8').trim());
+        const m = /^(\d+) (\d+|-)(?:\s|$)/.exec(readFileSync(stopPath(root, slug), 'utf8').trim());
         if (m === null)
             return null;
-        return { range: Number(m[1]), turn: m[2] === '-' ? null : Number(m[2]), hash: m[3] ?? '', detail: m[4] ?? null };
+        return { range: Number(m[1]), turn: m[2] === '-' ? null : Number(m[2]) };
     }
     catch {
         return null;
     }
 }
 /**
- * Record the stamp of the stop card just printed, with the digest of the
- * detail file as it stands, which is the file the card was rendered from.
- * Best-effort: a failed write costs one more full card on a later turn, never
- * this turn's output or its exit code.
+ * Record the stamp of the stop card just printed. Best-effort: a failed write
+ * costs one more full card on a later turn, never this turn's output or its
+ * exit code.
  */
 export function writeStop(root, slug, stamp) {
     try {
-        const detail = detailDigest(readFileSync(detailPath(root), 'utf8'));
-        writeFileSync(stopPath(root, slug), `${stamp.range} ${stamp.turn ?? '-'} ${stamp.hash} ${detail}\n`);
+        writeFileSync(stopPath(root, slug), `${stamp.range} ${stamp.turn ?? '-'}\n`);
     }
     catch {
         // A read-only tree or a vanished build folder: the card still renders.
@@ -277,13 +305,6 @@ export function writeStop(root, slug, stamp) {
 export function clearStop(root, slug) {
     rmSync(stopPath(root, slug), { force: true });
 }
-/**
- * The digest a STOP stamp keeps of a detail file, so the record can tell the
- * detail a card showed from one written after it.
- */
-export function detailDigest(detail) {
-    return createHash('sha256').update(detail).digest('hex');
-}
 /**
  * The build's `checkpoints` ledger: the recorded SHAs of landed plan and step
  * commits, one line each.
@@ -689,7 +710,7 @@ export function readTurn(root) {
 // ending: a decision ending closes the turn, an orientation ending appears in
 // it, and a driver ending is recorded only so that the last ending wins.
 const RELAY_TIERS = ['decision', 'orientation', 'driver'];
-// Which ending printed: handoff's eight forms first, then one per transition.
+// Which ending printed: handoff's nine forms first, then one per transition.
 // It is what the check's reason names when the ending went missing.
 const RELAY_RENDERS = [
     'card',
@@ -700,6 +721,7 @@ const RELAY_RENDERS = [
     'boundary',
     'pointer',
     'driver',
+    'harvest-card',
     'checkpoint',
     'plan-commit',
     'park',
@@ -911,10 +933,10 @@ export function excludeControl(root) {
         // The entry stamp is in-flight control like STEP/SEAM: checkpoint's
         // stageAll must never sweep it into a step commit.
         `${DIRNAME}/builds/*/TICK`,
-        // The pause stamp is in-flight control too: what handoff last showed, so
-        // a repeat prints the reminder. It must never ride a step commit.
+        // The pause stamp is in-flight control too: which card has shown, so a
+        // later handoff prints its one line. It must never ride a step commit.
         `${DIRNAME}/builds/*/PAUSE`,
-        // The stop stamp likewise: what the stop card last showed, and the turn it
+        // The stop stamp likewise: the range whose card has shown, and the turn it
         // printed in, for the reminder and the record's latch.
         `${DIRNAME}/builds/*/STOP`,
         // The agent-run handoff ledger is step-scoped in-flight state, not a

package/dist/verbs/checkpoint.js

@@ -12,7 +12,7 @@
 import { appendFileSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { relative } from 'node:path';
 import { commit, findRepoRoot, headSha, isDirty, stageAll, stagePath, stagedPaths, stagedStat } from "../lib/git.js";
-import { activeBuild, buildFolder, buildLogPath, buildScope, bumpStepStat, checkpointsPath, clearDetail, clearHandoff, clearPause, clearTick, detailPath, hasSession, intentPath, readRun, readStats, refreshExcludes, seamPath, stampStepStat, stepPath, } from "../lib/sidecar.js";
+import { activeBuild, buildFolder, buildLogPath, buildScope, bumpStepStat, checkpointsPath, clearDetail, clearHandoff, clearTick, detailPath, hasSession, intentPath, readRun, readStats, refreshExcludes, seamPath, stampStepStat, stepPath, writePause, } from "../lib/sidecar.js";
 import { runCheck } from "../lib/check.js";
 import { readCommitBody } from "../lib/commitbody.js";
 import { checkLatch } from "../lib/latch.js";
@@ -22,8 +22,7 @@ import { conventionalSubject, subjectFromTitle, withMarker } from "../lib/commit
 import { appendToSection, checkpointLogLine, logEntry, planLogLine } from "../lib/buildlog.js";
 import { AT_BOUNDARY, syncBuildLogState } from "../lib/buildlogsync.js";
 import { advisory, ending, notice, printEnding, transition } from "../lib/notice.js";
-import { boundaryEnding, detailsLink, parseDetailRange, planRecord, stepRecord } from "./handoff.js";
-import { isHarvestDetail } from "./harvest.js";
+import { boundaryEnding, detailsLink, isHarvestDetail, parseDetailRange, planRecord, stepRecord } from "./handoff.js";
 /**
  * Land a step: latch, check gate, commit, record, return to the boundary.
  *
@@ -122,11 +121,14 @@ export async function checkpoint(cwd, args) {
     rmSync(stepPath(root), { force: true });
     clearHandoff(root); // the agent-run handoff ledger is step-scoped; clear it with the markers.
     clearTick(root); // the step's entry stamp is spent; the next `build <n>` re-stamps.
-    clearPause(root); // the pause it stamped is over; the next step's pause renders whole.
-    // The whole ending, one block: the lead line, the Verdict folded over what
-    // just landed, the advisories this checkpoint alone can state, and the
-    // pointer. Read after the flip and the ledger append, so the fold and the
-    // pointer both see the boundary the human is standing at.
+    // The pause it stamped is over, and the boundary this ending prints is the
+    // card the stamp now names, so a later handoff here ends on its pointer
+    // (D110 (reply-after-the-card)); the next step's pause renders whole.
+    writePause(root, undefined, { kind: 'landed', step });
+    // The whole ending, one block: the lead line, the advisories this checkpoint
+    // alone can state, and the state table headed by the Verdict folded over
+    // what just landed. Read after the flip and the ledger append, so the fold
+    // and the pointer both see the boundary the human is standing at.
     const landed = boundaryEnding(root, activeBuild(root), step);
     // A landing that completes the range a typed run marked owes the stop card:
     // the record says so, and the relay check holds a turn that ends here.
@@ -137,10 +139,8 @@ export async function checkpoint(cwd, args) {
         ...(owes === null ? {} : { owes }),
         text: ending({
             lead: transition({ label: 'Checkpoint', fact: `Step ${step} complete`, detail: leadDetail(sha, pointer) }),
-            verdict: landed.verdict,
             advisories: [drift, flipNotice],
-            stop: landed.stop,
-            pointer: landed.pointer,
+            state: landed.state,
         }),
     });
     return 0;
@@ -202,7 +202,7 @@ function checkpointPlan(root, args) {
                         remedy: 'unignore .plumbbob/builds/ to keep the record in the tree',
                     }),
                 ],
-            pointer: boundaryEnding(root, activeBuild(root), null).pointer,
+            state: boundaryEnding(root, activeBuild(root), null).state,
         }),
     });
     return 0;