plumbbob 0.13.6 → 0.13.7

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "plumbbob",
   "displayName": "PlumbBob",
-  "version": "0.13.6",
+  "version": "0.13.7",
   "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

@@ -175,9 +175,9 @@ In Claude Code, inside any git repo with a clean tree:
 
    | **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 |
+   | Now | **Step 1** on Opus - feat(limiter): add a token-bucket limiter |
+   | Next Up | **Step 2** on Sonnet - feat(login): wire the limiter into POST /login (details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28)) |
+   | Range | **1** 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.
 
@@ -200,8 +200,8 @@ In Claude Code, inside any git repo with a clean tree:
 
    | **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) |
+   | Next Up | **Step 2** on Sonnet - feat(login): wire the limiter into POST /login (details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28)) |
+   | Range | **2** on Sonnet: /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)

package/dist/cli-core.js

@@ -61,7 +61,7 @@ const VERBS = [
     {
         name: 'status',
         description: 'print the orientation dashboard, or NO ACTIVE SESSION',
-        synopsis: ['status [--build <slug>] [--invoked "<args>"] [--run "<args>"]'],
+        synopsis: ['status [--build <slug>] [--invoked "<args>"] [--run "<args>"] [--questions]'],
         flags: [
             BUILD_FLAG,
             {
@@ -74,6 +74,7 @@ const VERBS = [
                 value: '"<args>"',
                 gloss: 'the raw /plumbbob:run invocation; prints the run it names above the dashboard, or the refusal as its pointer',
             },
+            { name: '--questions', gloss: "print the plan's open questions as one table (question, why it matters, lean), the deferred ones on a line beneath, in place of the dashboard" },
         ],
         notes: 'Read-only; always exits 0. With no cursor it lists the available builds.',
     },

package/dist/lib/links.js

@@ -0,0 +1,97 @@
+// Relative links written for one directory, re-aimed for another. A section of
+// `.plumbbob/detail.md` cites `builds/<slug>/intent.md#d5` relative to
+// `.plumbbob/`; copied verbatim into `builds/<slug>/build-log.md` the same
+// target now points one directory too deep and the link breaks. Only the copy
+// step knows both directories, so this is the one place the target moves:
+// every inline link and image in prose gets its target resolved against the
+// directory the text was written for and re-expressed from the directory it is
+// bound for. Code is never touched: a fenced block is tracked across lines and
+// an inline code span across one, because a link inside a sample is part of
+// the sample. Pure string work; no fs, no process, `node:path` only.
+import { relative, resolve, sep } from 'node:path';
+import { closesFence, fenceOpening } from "./orient.js";
+/** One inline code span on a line: a run of backticks up to the next run of the same length. */
+const CODE_SPAN = /(`+).*?\1/g;
+/**
+ * One inline link or image in prose, in three parts: everything up to and
+ * including the opening parenthesis, the target, and the rest (an optional
+ * quoted title, then the closing parenthesis). An angle-bracketed target does
+ * not match, so it rides through untouched.
+ */
+const LINK = /(!?\[[^\]]*\]\()([^\s()<>]*)((?:\s+(?:"[^"]*"|'[^']*'|\([^()]*\)))?\))/g;
+/** A target that names its own scheme (`https:`, `mailto:`), which no directory move can change. */
+const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/**
+ * Re-aim every relative link in `text` so it resolves the same from `toDir`
+ * as it did from `fromDir`.
+ *
+ * A link aimed at `builds/x/intent.md#d5`, written for `.plumbbob/`, aims at
+ * `intent.md#d5` once it is bound for `.plumbbob/builds/x/`; `../README.md` becomes
+ * `../../../README.md`. A fragment rides along unchanged. The text comes
+ * back byte for byte when the two directories are one, when no link is
+ * relative, or when every link sits inside a fence or a code span.
+ */
+export function rerootLinks(text, fromDir, toDir) {
+    const from = resolve(fromDir);
+    const to = resolve(toDir);
+    if (from === to)
+        return text;
+    let fence = null;
+    const lines = [];
+    for (const line of text.split('\n')) {
+        if (fence !== null) {
+            if (closesFence(line, fence))
+                fence = null;
+            lines.push(line);
+            continue;
+        }
+        const opened = fenceOpening(line);
+        if (opened !== null) {
+            fence = opened;
+            lines.push(line);
+            continue;
+        }
+        lines.push(rerootLine(line, from, to));
+    }
+    return lines.join('\n');
+}
+/**
+ * One unfenced line with its prose segments rewritten and its code spans
+ * passed through.
+ *
+ * The line splits at every code span; the span is copied as it stands and the
+ * text between spans is where links move. A lone backtick with no closer is
+ * prose, as it is to a markdown renderer.
+ */
+function rerootLine(line, from, to) {
+    let out = '';
+    let last = 0;
+    for (const span of line.matchAll(CODE_SPAN)) {
+        out += rerootProse(line.slice(last, span.index), from, to) + span[0];
+        last = span.index + span[0].length;
+    }
+    return out + rerootProse(line.slice(last), from, to);
+}
+/** A prose segment with the target of every inline link and image re-aimed. */
+function rerootProse(prose, from, to) {
+    return prose.replace(LINK, (_, open, target, close) => `${open}${rerootTarget(target, from, to)}${close}`);
+}
+/**
+ * One link target, moved from `from` to `to` when it is relative and returned
+ * as written otherwise.
+ *
+ * Untouched: an empty target, a bare `#anchor`, a root-relative `/docs/a.md`,
+ * and anything with a scheme. A relative target resolves against `from`, is
+ * re-expressed from `to` with posix separators, and keeps its `#fragment`.
+ * A target that lands on `to` itself comes back as `.` rather than as
+ * nothing.
+ */
+function rerootTarget(target, from, to) {
+    if (target === '' || target.startsWith('#') || target.startsWith('/') || SCHEME.test(target))
+        return target;
+    const hash = target.indexOf('#');
+    const file = hash === -1 ? target : target.slice(0, hash);
+    const fragment = hash === -1 ? '' : target.slice(hash);
+    const moved = relative(to, resolve(from, file)).split(sep).join('/');
+    return `${moved === '' ? '.' : moved}${fragment}`;
+}

package/dist/lib/notice.js

@@ -91,7 +91,7 @@ export function ending(e) {
  * ```text
  * | **Verdict** | ● Plumb |
  * | --- | --- |
- * | Now | Step 2 of 3 - feat(login): wire the limiter into POST /login |
+ * | Now | **Step 2** on Sonnet - feat(login): wire the limiter into POST /login |
  * ```
  */
 export function stateTable(rows) {

package/dist/lib/orient.js

@@ -70,8 +70,10 @@ export function parseSteps(intent) {
         const block = lines.slice(s.idx, blockEnd).join('\n');
         const dw = /\*\*done when:\*\*\s*(.+)/i.exec(block);
         const doneWhen = dw ? (dw[1] ?? '').trim() : null;
+        // A model line still opening on the template's `<...>` fill-in recommends
+        // nothing, so it reads as no line at all rather than as a model named `<smallest`.
         const md = /^\s*-\s*model:\s*(.+)$/im.exec(block);
-        const model = md ? (md[1] ?? '').trim() : null;
+        const model = md && !/^<[^<>]+>/.test((md[1] ?? '').trim()) ? (md[1] ?? '').trim() : null;
         return { n: s.n, done: s.done, title: s.title, planned: /done when/i.test(block), doneWhen, model, line: offset + s.idx + 1 };
     });
 }
@@ -1127,14 +1129,115 @@ export function markStepDone(intent, n) {
  * substring read that as resolved and dropped a live hole off the dashboard. And an
  * opener whose body has not been filled in yet, still opening on its `<...>`
  * fill-in, is scaffold rather than a question, which is what makes a fresh build
- * report zero rather than one.
+ * report zero rather than one. A question deferred to the work still counts:
+ * nothing has been decided (D120 (deferred-questions)).
  */
 export function parseOpenQuestions(intent) {
-    const opener = /^-\s+(?:<a id="[^"]*"><\/a>\s*)?\*{0,2}Q\d+(?: \([^)]+\))?\*{0,2}:\s*(.*)$/;
-    return sectionLines(intent, '## Open questions').lines.filter((l) => {
-        const body = opener.exec(l.trim())?.[1];
-        return body !== undefined && !/\bresolved\b/i.test(l) && !/^<[^>]*>/.test(body);
-    }).length;
+    return parseOpenQuestionRows(intent).length;
+}
+// An open question's opener: the handle, an optional anchor and slug, then
+// the body after the colon (D76 (resolved-on-opener)).
+const QUESTION_OPENER = /^-\s+(?:<a id="[^"]*"><\/a>\s*)?\*{0,2}(Q\d+)(?: \(([^)]+)\))?\*{0,2}:\s*(.*)$/;
+// A sub-line beneath an opener: `- *plain:* …` or `- *lean:* …`.
+const QUESTION_FIELD = /^-\s+\*(plain|lean):\*\s*(.*)$/;
+/**
+ * The open questions, each with what the table shows, in the order the plan
+ * lists them. The rules `parseOpenQuestions` counts by decide which openers
+ * are open: a `resolved` marker on the opener line closes it, and a body still
+ * opening on its `<...>` fill-in is scaffold. The `*plain:*` sub-line is why
+ * the question matters, the `*lean:*` sub-line the proposed answer, each with
+ * any lines it wraps onto (D118 (questions-table)).
+ *
+ * A `*deferred:*` marker on the opener keeps the question open and records what
+ * will settle it. Its until-clause is the human's own words, so a "resolved"
+ * inside it does not close the question; only the literal `*resolved:*` marker
+ * does, wherever it sits on the line (D120 (deferred-questions)).
+ */
+export function parseOpenQuestionRows(intent) {
+    const { offset, lines } = sectionLines(intent, '## Open questions');
+    const rows = [];
+    let current = null;
+    let field = null;
+    lines.forEach((raw, i) => {
+        const text = raw.trim();
+        const opener = QUESTION_OPENER.exec(text);
+        if (opener !== null) {
+            const body = opener[3] ?? '';
+            const open = !resolvedOpener(raw) && !/^<[^>]*>/.test(body);
+            current = open
+                ? { id: opener[1] ?? '', slug: opener[2] ?? null, line: offset + i + 1, question: questionText(body), why: null, lean: null, deferred: deferredText(body) }
+                : null;
+            if (current !== null)
+                rows.push(current);
+            field = null;
+            return;
+        }
+        const sub = QUESTION_FIELD.exec(text);
+        if (current !== null && sub !== null) {
+            field = sub[1] === 'plain' ? 'why' : 'lean';
+            current[field] = (sub[2] ?? '').trim();
+            return;
+        }
+        if (current !== null && field !== null && text.length > 0 && /^\s/.test(raw) && !text.startsWith('-')) {
+            current[field] = `${current[field] ?? ''} ${text}`.trim();
+            return;
+        }
+        field = null;
+    });
+    return rows;
+}
+// The marker a question deferred to the work carries on its opener line.
+const DEFERRED_MARKER = /\*deferred:\*/i;
+/**
+ * Whether an opener line closes its question: "resolved" as a whole word
+ * anywhere before a `*deferred:*` marker (D76 (resolved-on-opener)), or the
+ * literal `*resolved:*` marker anywhere on the line. The until-clause after a
+ * deferral is free text, so a bare "resolved" there leaves the question open.
+ */
+function resolvedOpener(raw) {
+    const deferredAt = raw.search(DEFERRED_MARKER);
+    const head = deferredAt === -1 ? raw : raw.slice(0, deferredAt);
+    return /\bresolved\b/i.test(head) || /\*resolved:\*/i.test(raw);
+}
+/** An opener's question: its body without the trailing `*resolve by:*` or `*deferred:*` tag. */
+function questionText(body) {
+    return body.replace(/,?\s*\*(?:resolve by|deferred):\*.*$/i, '').trim();
+}
+/**
+ * What a deferred opener says will settle it: the text after its `*deferred:*`
+ * marker, without the leading date or a `*resolve by:*` tag left beside it,
+ * and empty for a bare marker. Null when the opener carries no marker.
+ */
+function deferredText(body) {
+    const at = body.search(DEFERRED_MARKER);
+    if (at === -1) {
+        return null;
+    }
+    return body
+        .slice(at)
+        .replace(DEFERRED_MARKER, '')
+        .replace(/,?\s*\*resolve by:\*.*$/i, '')
+        .trim()
+        .replace(/^\d{4}-\d{2}-\d{2},?\s*/, '')
+        .trim();
+}
+/** Split open question rows by who acts on them (D120 (deferred-questions)). */
+export function questionTotals(rows) {
+    const deferred = rows.filter((q) => q.deferred !== null).length;
+    return { toAnswer: rows.length - deferred, deferred };
+}
+/**
+ * The dashboard's question count, split the way the card's Questions row
+ * splits it: `open questions 1 to answer, 2 deferred`, either half alone when
+ * the other is zero, and `open questions 0` with none open. A comma joins the
+ * halves because ` · ` already separates the line's fields.
+ */
+export function questionsPhrase(totals) {
+    const halves = [
+        ...(totals.toAnswer > 0 ? [`${totals.toAnswer} to answer`] : []),
+        ...(totals.deferred > 0 ? [`${totals.deferred} deferred`] : []),
+    ];
+    return `open questions ${halves.length === 0 ? '0' : halves.join(', ')}`;
 }
 /**
  * Count the park list: the `- [ ]` lines still open, and every checklist line
@@ -1338,7 +1441,7 @@ export function orient(input) {
         lastCheckpoint: parseLastCheckpoint(input.checkpoints),
         parked: parks.open,
         parkedTotal: parks.total,
-        openQuestions: parseOpenQuestions(input.intent),
+        questions: questionTotals(parseOpenQuestionRows(input.intent)),
         next: (idle ? ranges.waitingMove : null) ??
             (atBoundary ? ranges.move : null) ??
             nextMove(input.spiking, ordered, input.inFlight, parks.open, requested),
@@ -2079,12 +2182,12 @@ function proseBlocks(text) {
     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) {
+export 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) {
+export 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;
 }
@@ -2254,7 +2357,7 @@ export function formatOrientation(o) {
         cpLine,
         ...receipts,
         ...orderRow,
-        `${parkedPhrase({ open: o.parked, total: o.parkedTotal })} · open questions ${o.openQuestions}`,
+        `${parkedPhrase({ open: o.parked, total: o.parkedTotal })} · ${questionsPhrase(o.questions)}`,
         '',
         `next → ${o.next}`,
     ].join('\n');

package/dist/lib/sidecar.js

@@ -20,7 +20,7 @@
 // a STEP is in flight, SPIKE ⇔ the SPIKE marker is present, otherwise DESIGN.
 import { existsSync, readdirSync, readFileSync, writeFileSync, appendFileSync, rmSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { gitPath } from "./git.js";
+import { gitPath, isIgnored } from "./git.js";
 const DIRNAME = '.plumbbob'; // the sidecar folder name at the repo root
 /**
  * The sidecar root: `<root>/.plumbbob`.
@@ -175,6 +175,37 @@ function artifactDir(root, slug) {
 export function buildFolder(root, slug) {
     return artifactDir(root, slug);
 }
+/**
+ * Whether git ignores the build folder here, by the repo's own `.gitignore` or
+ * by a `.plumbbob/` line in info/exclude (`--local`): the probe `checkpoint
+ * --plan` acts on, since an ignored folder lands its plan commit record-only.
+ *
+ * Best-effort: a probe that throws (a fatal `git check-ignore`) reads as not
+ * ignored, so a caller only warning about it stays quiet rather than crashing.
+ */
+export function buildFolderIgnored(root, slug) {
+    try {
+        return isIgnored(root, buildFolder(root, slug));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether the build's plan has landed: a `plan <sha>` line in its checkpoints
+ * ledger, which only `checkpoint --plan` writes. A missing ledger reads as not
+ * landed.
+ */
+export function planCommitted(root, slug) {
+    try {
+        return readFileSync(checkpointsPath(root, slug), 'utf8')
+            .split('\n')
+            .some((line) => line.startsWith('plan '));
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * The SPIKE marker: a single-purpose presence flag, like SEAM/STEP.
  *
@@ -217,7 +248,8 @@ export function clearStep(root, slug) {
  * 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.
+ * boundary step 2 landed on has shown, `landed 2 answered` when that landing
+ * answered step 2's pause card.
  *
  * 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
@@ -233,8 +265,12 @@ export function pausePath(root, slug) {
  */
 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]) };
+        const m = /^(landed )?(\d+)(?:\s+(\S+))?/.exec(readFileSync(pausePath(root, slug), 'utf8').trim());
+        if (m === null) {
+            return null;
+        }
+        const stamp = { kind: m[1] === undefined ? 'pause' : 'landed', step: Number(m[2]) };
+        return stamp.kind === 'landed' && m[3] === 'answered' ? { ...stamp, answered: true } : stamp;
     }
     catch {
         return null;
@@ -246,7 +282,8 @@ export function readPause(root, slug) {
  */
 export function writePause(root, slug, stamp) {
     try {
-        writeFileSync(pausePath(root, slug), `${stamp.kind === 'landed' ? 'landed ' : ''}${stamp.step}\n`);
+        const answered = stamp.kind === 'landed' && stamp.answered === true ? ' answered' : '';
+        writeFileSync(pausePath(root, slug), `${stamp.kind === 'landed' ? 'landed ' : ''}${stamp.step}${answered}\n`);
     }
     catch {
         // A read-only tree or a vanished build folder: the card still renders.

package/dist/verbs/build.js

@@ -200,13 +200,15 @@ function reservedCallNotice(intent, steps, step) {
  * That step lands like every step before it, and then the turn ends on its
  * checkpoint: a clean halt. Saying so as the step is entered puts the fact in
  * front of the model before it chooses between landing the step and holding it
- * at a pause, which is the choice a clean halt kept getting wrong. A range
- * reaches its top, or the last undone step under its top when the plan ends
- * first, or when the build order puts a number past the top ahead of the rest
- * (a range names plan numbers, and the skill halts before one past its top);
- * `--auto` reaches the plan's last undone step. A range that lists its steps
- * walks them in build order, so its top is the last undone step it names, and
- * it reaches no further than a step it does not name.
+ * at a pause, which is the choice a clean halt kept getting wrong. The next
+ * step is the first undone step in build order other than this one, wherever
+ * it sits, because a range names plan numbers and the skill halts before any
+ * step the range does not name: a range typed above an earlier undone step
+ * halts after its first step, and the detail names the step it halts before.
+ * A range reaches its top, or the last undone step it names when the plan ends
+ * first or the next step in build order is one it does not name; `--auto`
+ * reaches the plan's last undone step. A range that lists its steps walks them
+ * in build order, so its top is the last undone step it names.
  */
 function lastGrantedNotice(grant, steps, step) {
     if (grant === null) {
@@ -216,24 +218,30 @@ function lastGrantedNotice(grant, steps, step) {
     if (grant.kind === 'steps') {
         if (!hasStep(grant.steps, step))
             return '';
-        const rest = steps.slice(steps.findIndex((s) => s.n === step) + 1).filter((s) => !s.done && s.n !== step);
+        const rest = steps.filter((s) => !s.done && s.n !== step);
         const after = rest[0];
         if (after !== undefined && hasStep(grant.steps, after.n))
             return '';
+        const detail = after === undefined ? [] : [unnamedNext(after.n)];
         return rest.some((s) => hasStep(grant.steps, s.n))
-            ? notice({ fact: `step ${step} is the last undone step in the range you granted`, remedy })
-            : notice({ fact: `step ${step} is the top of the range you granted`, remedy });
+            ? notice({ fact: `step ${step} is the last undone step in the range you granted`, detail, remedy })
+            : notice({ fact: `step ${step} is the top of the range you granted`, detail, remedy });
     }
     if (grant.kind === 'range') {
         if (step === grant.ceiling) {
             return notice({ fact: `step ${step} is the top of the range you granted`, remedy });
         }
-        const after = steps.slice(steps.findIndex((s) => s.n === step) + 1).find((s) => !s.done);
+        const after = steps.find((s) => !s.done && s.n !== step);
         const more = after !== undefined && after.n <= grant.ceiling;
+        const detail = after === undefined ? [] : [unnamedNext(after.n)];
         return step < grant.ceiling && !more
-            ? notice({ fact: `step ${step} is the last undone step in the range you granted`, remedy })
+            ? notice({ fact: `step ${step} is the last undone step in the range you granted`, detail, remedy })
             : '';
     }
     const more = steps.some((s) => !s.done && s.n !== step);
     return more ? '' : notice({ fact: `step ${step} is the last undone step in the plan`, remedy });
 }
+/** The detail naming the step a range halts before: the next undone one in build order, which the range does not name. */
+function unnamedNext(n) {
+    return `step ${n} is next in the build order, and the range does not name it`;
+}

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, clearTick, detailPath, hasSession, intentPath, readRun, readStats, refreshExcludes, seamPath, stampStepStat, stepPath, writePause, } from "../lib/sidecar.js";
+import { activeBuild, buildFolder, buildLogPath, buildScope, bumpStepStat, checkpointsPath, clearDetail, clearHandoff, clearTick, detailPath, hasSession, intentPath, readPause, 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";
@@ -123,8 +123,12 @@ export async function checkpoint(cwd, args) {
     clearTick(root); // the step's entry stamp is spent; the next `build <n>` re-stamps.
     // 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 });
+    // (D110 (reply-after-the-card)); the next step's pause renders whole. A
+    // landing that answers this step's own pause card, already shown, says so,
+    // and the stop card it may owe prints short (D119 (short-stop-after-a-halt)).
+    const shown = readPause(root);
+    const answered = shown?.kind === 'pause' && shown.step === step;
+    writePause(root, undefined, { kind: 'landed', step, ...(answered ? { answered: true } : {}) });
     // 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
@@ -181,7 +185,7 @@ function checkpointPlan(root, args) {
     appendFileSync(checkpointsPath(root), `plan ${sha}\n`);
     // The cold read that approved the plan is the Log's first entry, beneath a
     // dated plan line; the detail file is then spent, the same as at a step.
-    const pointer = logPlan(root, sha, planRecord(readDetail(root, null) ?? ''));
+    const pointer = logPlan(root, sha, planRecord(root, activeBuild(root), readDetail(root, null) ?? ''));
     clearDetail(root);
     // Landing the plan consumes `start`'s entry stamp: a later hand-built diff
     // (no `build <n>`) must find no stale TICK and stay guidance-governed.