plumbbob 0.13.7 → 0.13.8

package/.claude-plugin/plugin.json

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

@@ -177,7 +177,7 @@ In Claude Code, inside any git repo with a clean tree:
    | --- | --- |
    | 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 |
+   |  | **Range 2** on Sonnet: /plumbbob:run once step 1 lands |
 
    **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.
 
@@ -192,7 +192,7 @@ 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 Range row beneath Next Up names the run to type
+   and returns to the boundary, where the range line beneath Next Up names the run to type
    next and the steps it will land:
 
    ```text
@@ -201,7 +201,7 @@ In Claude Code, inside any git repo with a clean tree:
    | **Verdict** | ● Plumb |
    | --- | --- |
    | 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) |
+   |  | **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

@@ -14,6 +14,7 @@ import { fileURLToPath } from 'node:url';
 import { start } from "./verbs/start.js";
 import { status } from "./verbs/status.js";
 import { park } from "./verbs/park.js";
+import { defer } from "./verbs/defer.js";
 import { harvest } from "./verbs/harvest.js";
 import { order } from "./verbs/order.js";
 import { build } from "./verbs/build.js";
@@ -152,6 +153,16 @@ const VERBS = [
         tolerateUnknownFlags: true,
         notes: 'Refuses (exit 1) with no session, empty text, or no `## Park list` section.',
     },
+    {
+        name: 'defer',
+        description: 'leave an open question to the work, until what will settle it',
+        synopsis: ['defer <Qn> "<what settles it>"'],
+        args: [
+            { name: '<Qn>', gloss: 'the open question, by its handle (Q3)' },
+            { name: '<what settles it>', gloss: 'the work the question waits on (free text; quote it)' },
+        ],
+        notes: "Writes `*deferred:* <date>, until <what settles it>` on the question's opener in intent.md, in place of its `*resolve by:*` tag or an earlier deferral, so every count reads it apart from the questions to answer. Refuses (exit 1) with no session, no handle, no until-clause, a handle the open questions lack, or a question already resolved.",
+    },
     {
         name: 'order',
         description: 'set the build order: the undone steps in the sequence to build them',
@@ -378,6 +389,8 @@ async function dispatch(verb, cwd, rest) {
             return status(cwd, rest);
         case 'park':
             return park(cwd, rest);
+        case 'defer':
+            return defer(cwd, rest);
         case 'order':
             return order(cwd, rest);
         case 'harvest':

package/dist/lib/orient.js

@@ -1221,11 +1221,49 @@ function deferredText(body) {
         .replace(/^\d{4}-\d{2}-\d{2},?\s*/, '')
         .trim();
 }
+/**
+ * Defer an open question to the work: on its opener line, `*deferred:* <date>,
+ * until <what settles it>` takes the place of its `*resolve by:*` tag, or of
+ * an earlier `*deferred:*` marker, or joins the end of a line that has
+ * neither. The until-clause is folded onto one line, since the parser reads
+ * the opener line alone (D120 (deferred-questions)).
+ *
+ * `resolved` names an opener the plan closed, `missing` one the plan lacks or
+ * has not filled in, with the handles still open beside it.
+ */
+export function deferQuestion(intent, id, date, until) {
+    const rows = parseOpenQuestionRows(intent);
+    const row = rows.find((q) => q.id === id);
+    if (row === undefined) {
+        const closed = sectionLines(intent, '## Open questions').lines.some((raw) => {
+            const opener = QUESTION_OPENER.exec(raw.trim());
+            return opener?.[1] === id && resolvedOpener(raw);
+        });
+        return closed ? { kind: 'resolved' } : { kind: 'missing', open: rows.map((q) => q.id) };
+    }
+    const lines = intent.split('\n');
+    const raw = lines[row.line - 1] ?? '';
+    const marker = `*deferred:* ${date}, until ${until.replace(/\s*\n\s*/g, ' ').trim()}`;
+    const tag = raw.search(/\*(?:resolve by|deferred):\*/i);
+    lines[row.line - 1] = tag === -1 ? `${raw.trimEnd()}, ${marker}` : `${raw.slice(0, tag).trimEnd()} ${marker}`;
+    const updated = lines.join('\n');
+    return { kind: 'deferred', intent: updated, question: parseOpenQuestionRows(updated).find((q) => q.id === id) ?? row };
+}
 /** 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 open questions still waiting on the human that a line of text names by
+ * handle (`Q3`), in the order the plan lists them. A park or a tangent naming
+ * one has set it aside without deferring it, so the count still reads it as a
+ * call owed.
+ */
+export function questionsToAnswerNamed(text, rows) {
+    const named = new Set(text.match(/\bQ\d+\b/g) ?? []);
+    return rows.filter((q) => q.deferred === null && named.has(q.id));
+}
 /**
  * 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

package/dist/lib/sidecar.js

@@ -762,6 +762,7 @@ const RELAY_RENDERS = [
     'checkpoint',
     'plan-commit',
     'park',
+    'defer',
     'revert',
     'abandon',
     'spike-open',

package/dist/verbs/defer.js

@@ -0,0 +1,96 @@
+// `plumbbob defer <Qn> "<what settles it>"`: leave an open question to the
+// work. The marker it writes on the question's opener in intent.md,
+// `*deferred:* <date>, until <what settles it>`, is the one thing every count
+// reads to tell a question that waits on the human from one that waits on
+// the work (D120 (deferred-questions)). Until this verb the marker was a hand
+// edit made only at the plan card, so a question set aside anywhere else (parked
+// mid-step, or settled as a tangent at a harvest) kept counting as a call
+// owed. The skill decides and the CLI records (D123 (defer-records)): deferring
+// stays the human's call, and the verb only writes it, dated, in the one form
+// the parser reads. Like park it changes no state the loop runs on, so it runs
+// in any context.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { findRepoRoot } from "../lib/git.js";
+import { activeBuild, hasSession, intentPath } from "../lib/sidecar.js";
+import { deferQuestion, questionsToAnswerNamed } from "../lib/orient.js";
+import { advisory, ending, notice, printEnding, transition } from "../lib/notice.js";
+import { driverPointer } from "./handoff.js";
+// What every refusal about the arguments points at.
+const USAGE = 'plumbbob defer Q3 "<what settles it>"';
+/**
+ * Mark the named open question deferred until what the rest of the arguments
+ * say will settle it, and print the ending: the deferral and the pointer.
+ *
+ * A leading "until" in the text is dropped, since the marker writes its own.
+ * Refuses (exit 1) with no session, no question handle, no until-clause, a
+ * handle the open questions lack, or a question already resolved.
+ */
+export function defer(cwd, args) {
+    const root = findRepoRoot(cwd);
+    if (root === null || !hasSession(root)) {
+        process.stderr.write(notice({ fact: 'no active session', detail: ['no open questions to defer'], remedy: 'plumbbob start "<title>"' }));
+        return 1;
+    }
+    const [handle = '', ...rest] = args.filter((a) => !a.startsWith('--'));
+    const id = /^Q(\d+)$/i.exec(handle.trim());
+    if (id === null) {
+        process.stderr.write(notice({ fact: 'defer needs a question', detail: ['its handle first, Q3'], remedy: USAGE }));
+        return 1;
+    }
+    const question = `Q${id[1] ?? ''}`;
+    const until = rest
+        .join(' ')
+        .trim()
+        .replace(/^until\s+/i, '');
+    if (until.length === 0) {
+        process.stderr.write(notice({
+            fact: 'defer needs what settles it',
+            detail: ['the work the question waits on'],
+            remedy: `plumbbob defer ${question} "<what settles it>"`,
+        }));
+        return 1;
+    }
+    const path = intentPath(root);
+    const date = new Date().toISOString().slice(0, 10);
+    const deferral = deferQuestion(readFileSync(path, 'utf8'), question, date, until);
+    if (deferral.kind === 'resolved') {
+        process.stderr.write(notice({ fact: `${question} is already resolved`, detail: ['its opener says so'] }));
+        return 1;
+    }
+    if (deferral.kind === 'missing') {
+        process.stderr.write(notice({
+            fact: `no open ${question} in the plan`,
+            detail: [deferral.open.length === 0 ? 'no open questions' : `open: ${deferral.open.join(', ')}`],
+            remedy: 'fix the handle',
+        }));
+        return 1;
+    }
+    writeFileSync(path, deferral.intent);
+    printEnding(root, {
+        tier: 'driver',
+        render: 'defer',
+        text: ending({
+            // The parser hands back the marker's until-clause as the opener now
+            // reads it, `until` and all, so the lead says what the file says.
+            lead: transition({ label: 'Deferred', fact: `${plainHandle(deferral.question)} ${deferral.question.deferred ?? `until ${until}`}` }),
+            pointer: driverPointer(root, activeBuild(root)),
+        }),
+    });
+    return 0;
+}
+/**
+ * One advisory for each open question a park or a tangent names that still
+ * counts as a call owed, with the deferral beneath it: setting a question
+ * aside does not defer it, and the card would go on counting it as to answer.
+ * Empty when the text names none.
+ */
+export function setAsideAdvisories(text, rows) {
+    return questionsToAnswerNamed(text, rows).map((q) => advisory({
+        fact: `${plainHandle(q)} still counts as a question to answer`,
+        remedy: `plumbbob defer ${q.id} "<what settles it>", if the work will settle it`,
+    }));
+}
+/** A question's handle as a line of prose names it: the id, then its slug. */
+function plainHandle(q) {
+    return q.slug === null ? q.id : `${q.id} (${q.slug})`;
+}

package/dist/verbs/handoff.js

@@ -51,7 +51,7 @@ import { hasStep } from "../lib/steplist.js";
 import { isArtifactPath, parseStepSeam } from "../lib/intent.js";
 import { rerootLinks } from "../lib/links.js";
 import { buildFolder, buildFolderIgnored, buildLogPath, checkpointsPath, detailPath, hasSession, inSpike, intentPath, planCommitted, readPause, readStats, readStop, readTurn, resolveBuild, seamPath, sidecarDir, stepPath, tickPath, writePause, writeStop, } from "../lib/sidecar.js";
-import { buildOrderPhrase, countDiff, diffFileItems, diffRowValue, foldVerdict, lastLedgerSha, measureRange, normalizeDetailHeadings, parseBuildOrder, parseBuildRanges, parseConstraintCount, parseLastCheckpoint, parseOpenQuestionRows, parseOrderedSteps, parseParkTotals, parseRecap, parseRecommendation, parseSections, parseSteps, parseSummary, questionTotals, rangeLanded, rangeSpan, rangeStanding, recapLines, remainingOrder, resolveRun, runBracket, seamRowFromDiff, spentRowValue, stopFollowUp, summaryCheckRow, } from "../lib/orient.js";
+import { buildOrderPhrase, countDiff, diffFileItems, diffRowValue, foldVerdict, lastLedgerSha, markStepDone, measureRange, normalizeDetailHeadings, parseBuildOrder, parseBuildRanges, parseConstraintCount, parseLastCheckpoint, parseOpenQuestionRows, parseOrderedSteps, parseParkTotals, parseRecap, parseRecommendation, parseSections, parseSteps, parseSummary, questionTotals, rangeLanded, rangeSpan, rangeStanding, recapLines, remainingOrder, resolveRun, runBracket, seamRowFromDiff, spentRowValue, stopFollowUp, summaryCheckRow, } from "../lib/orient.js";
 // The inline-diff threshold (docs/presentation.md): at 20 changed lines or
 // fewer the patch rides the turn; at 21 it stays in the working tree behind
 // the counted diff row.
@@ -1281,9 +1281,11 @@ const ORDER_CAP = 5;
  * becomes the header, which is the Verdict wherever one was measured
  * (D111 (state-table)).
  *
- * The Range, Order, and Parked rows are the segments the note beneath Next Up
- * used to carry on one indented line; as rows each one has a label of its own,
- * the way the human scans for it.
+ * The Order and Parked rows are segments the note beneath Next Up used to
+ * carry on one indented line; as rows each one has a label of its own, the way
+ * the human scans for it. The range is Next Up's second line, a row with a
+ * blank label, so it reads as the next range beside the next step rather than
+ * as the range the build is in (D122 (next-range-under-next-up)).
  */
 function stateRows(input) {
     const steps = parseOrderedSteps(input.intent);
@@ -1296,7 +1298,7 @@ function stateRows(input) {
         input.now === null ? null : { label: 'Now', value: input.now },
         input.stop === null ? null : { label: 'Stop', value: input.stop },
         { label: 'Next Up', value: pointerText(input.nextUp, input.where) },
-        range.length === 0 ? null : { label: 'Range', value: range },
+        range.length === 0 ? null : { label: '', value: range },
         order.length === 0 ? null : { label: 'Order', value: order },
         parks.total === 0 ? null : { label: 'Parked', value: parkedValue(parks, input.now !== null) },
         questions.toAnswer + questions.deferred === 0 || input.questions === false ? null : { label: 'Questions', value: questionsValue(questions) },
@@ -1336,32 +1338,51 @@ function pointerLine(nextUp, where) {
     return nextUpLine(nextUp, where);
 }
 /**
- * The Range row's fact: the run `/plumbbob:run` typed now would walk,
- * `**3** on Opus: /plumbbob:run (steps 6-9)`, the range's number bold and the
+ * Next Up's range line: the range the next run walks,
+ * `**Range 3** on Opus: /plumbbob:run (steps 6-9)`, its name bold and the
  * model its `- model:` line names beside it, so the model reads as the
  * range's and not the step's (D115 (card-weights)); the re-cut words for a
  * flagged range; the words for a step no range names; or '' for a plan
- * without ranges. The row's label says `Range`, so the fact opens on the
- * range's number.
+ * without ranges. The row has no label of its own, so the fact opens on the
+ * range's name (D122 (next-range-under-next-up)).
  *
  * The bracket is the grant the hook would mint. At a step pause that is the
  * range holding the step in flight, its bracket opening on that step, since a
- * run typed there lands it first; at the pause on a range's last step, where
- * a run ends on that range's stop, the segment names no run and no model
- * (`**3** lands with step 9`).
+ * run typed there lands it first. At the pause on a range's last step, or a
+ * bare range's, a run lands only that step and ends on its range's stop, so
+ * the line names the range the step after it opens instead
+ * (`**Range 4** on Fable: /plumbbob:run once step 9 lands`).
  */
 function rangeSegment(intent, steps, exclude) {
     const paused = steps.some((s) => s.n === exclude && !s.done) ? exclude : null;
     const run = cardRun(intent, paused);
+    if (run.ok && paused !== null && run.left.length === 1) {
+        return afterLanding(intent, paused);
+    }
+    return runSegment(run, (r) => `(${runBracket(r)})`);
+}
+/**
+ * The range line at the pause that finishes a range: the run the boundary will
+ * name once the step in flight lands, read from the plan with that step
+ * ticked, and opening once it does. '' when no step is left after it.
+ */
+function afterLanding(intent, paused) {
+    const next = cardRun(markStepDone(intent, paused), null);
+    return runSegment(next, () => `once step ${paused} lands`);
+}
+/**
+ * A run as the range line names it: the range's name, its model, and the run
+ * with `when` closing it; or, where the run would refuse, the words for a step
+ * no range names or a flagged range's re-cut, and '' for any other refusal.
+ */
+function runSegment(run, when) {
     if (run.ok) {
-        const name = `**${run.range.item}**`;
-        const lands = paused !== null && run.left.length === 1;
-        return lands ? `${name} lands with step ${paused}` : `${name}${onModel(run.range.model)}: /plumbbob:run (${runBracket(run)})`;
+        return `**Range ${run.range.item}**${onModel(run.range.model)}: /plumbbob:run ${when(run)}`;
     }
     if (run.kind === 'uncovered') {
         return run.words;
     }
-    return run.kind === 'flagged' ? `**${run.item}** needs a re-cut (${run.words})` : '';
+    return run.kind === 'flagged' ? `**Range ${run.item}** needs a re-cut (${run.words})` : '';
 }
 /**
  * The run `/plumbbob:run` typed now would walk, as the card names it: the

package/dist/verbs/harvest.js

@@ -25,10 +25,11 @@ import { findRepoRoot } from "../lib/git.js";
 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 { parseBuildRanges, parseDetailStep, parseLastCheckpoint, parseOpenQuestionRows, parseOrderedSteps, stepShas } from "../lib/orient.js";
 import { activeBuild, buildLogPath, checkpointsPath, clearDetail, clearStop, detailPath, hasSession, intentPath, readStop, } from "../lib/sidecar.js";
 import { hasStep } from "../lib/steplist.js";
 import { boundaryEnding, harvestProposals, isHarvestDetail, parkList, parseDetailRange, stopRecord, } from "./handoff.js";
+import { setAsideAdvisories } from "./defer.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.
@@ -100,10 +101,21 @@ export function harvest(cwd, _args) {
     const lead = stop === null
         ? transition({ label: 'Recorded', fact: `${settled.length} parked idea${settled.length === 1 ? '' : 's'}`, detail: [counted] })
         : transition({ label: 'Stop', fact: `**Range ${stop.item}** recorded`, detail: [counted] });
+    // A tangent naming a question that still waits on the human has set it
+    // aside without deferring it, and the card would go on counting it as a
+    // call owed (D123 (defer-records)).
+    const tangents = settled
+        .filter((p) => p.kind === 'tangent')
+        .map((p) => `${p.text} ${p.reason}`)
+        .join(' ');
     printEnding(root, {
         tier: 'orientation',
         render: 'harvest',
-        text: ending({ lead, state: boundaryEnding(root, slug, null).state }),
+        text: ending({
+            lead,
+            advisories: setAsideAdvisories(tangents, parseOpenQuestionRows(intent)),
+            state: boundaryEnding(root, slug, null).state,
+        }),
     });
     return 0;
 }

package/dist/verbs/park.js

@@ -7,12 +7,14 @@
 // step it interrupted, so the relay is one command.
 // Capture is not a state transition, so it runs in any context (terminal or
 // in-session).
-import { readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { findRepoRoot } from "../lib/git.js";
-import { activeBuild, hasSession, buildLogPath } from "../lib/sidecar.js";
+import { activeBuild, hasSession, buildLogPath, intentPath } from "../lib/sidecar.js";
 import { appendToSection } from "../lib/buildlog.js";
 import { ending, notice, printEnding, transition } from "../lib/notice.js";
+import { parseOpenQuestionRows } from "../lib/orient.js";
 import { driverPointer } from "./handoff.js";
+import { setAsideAdvisories } from "./defer.js";
 /**
  * Append the given text as one unchecked `- [ ]` line to the build-log's Park list.
  *
@@ -41,12 +43,20 @@ export function park(cwd, args) {
         return 1;
     }
     writeFileSync(path, updated);
+    const intent = intentPath(root);
+    const questions = parseOpenQuestionRows(existsSync(intent) ? readFileSync(intent, 'utf8') : '');
     // A park interrupts a step without ending it, so the ending is the capture
-    // and the pointer back at what was interrupted.
+    // and the pointer back at what was interrupted. A park naming a question
+    // that still waits on the human says so, since the park list never moves
+    // the card's count (D123 (defer-records)).
     printEnding(root, {
         tier: 'driver',
         render: 'park',
-        text: ending({ lead: transition({ label: 'Parked', fact: text }), pointer: driverPointer(root, activeBuild(root)) }),
+        text: ending({
+            lead: transition({ label: 'Parked', fact: text }),
+            advisories: setAsideAdvisories(text, questions),
+            pointer: driverPointer(root, activeBuild(root)),
+        }),
     });
     return 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plumbbob",
-  "version": "0.13.7",
+  "version": "0.13.8",
   "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

@@ -3,7 +3,7 @@ name: build
 description: "The default engine: read the next planned step from intent, implement it (its done-when, seam, Decisions, Constraints), then verify it through to the approval pause. Swappable: build by hand/vibed/another harness and run /plumbbob:verify instead. `--auto` self-approves and chains to done; a step range like `1-3`, or a list like `20,5-9`, self-approves exactly the steps it names, in build order, then stops."
 argument-hint: "[step-number | step-range | step-list] [--auto]"
 disable-model-invocation: true
-allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob build:*), Bash(plumbbob handoff:*), Bash(plumbbob check:*), Bash(plumbbob checkpoint:*), Bash(plumbbob park:*), Bash(plumbbob agent:*), Bash(plumbbob spike:*), Bash(git diff:*)
+allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob build:*), Bash(plumbbob handoff:*), Bash(plumbbob check:*), Bash(plumbbob checkpoint:*), Bash(plumbbob park:*), Bash(plumbbob defer:*), Bash(plumbbob agent:*), Bash(plumbbob spike:*), Bash(git diff:*)
 ---
 
 # PlumbBob: build a step (the default engine)
@@ -66,7 +66,13 @@ switch with `/model` and rerun to honor it, or wave you on. Advisory, never a ga
    capture it by running `plumbbob park "<one tidy line>"`: **saying "let's defer
    that" writes nothing; only the park line in the build log is a capture.** When the
    *human* hands you the tangent mid-build, their message **is** the approval to park
-   it; capture it right away, say what you parked, and stay on the step. If you
+   it; capture it right away, say what you parked, and stay on the step. An open question
+   the human sets aside to wait on other work is deferred, not parked: run
+   `plumbbob defer Q3 "<what settles it>"`, because the card counts questions by the
+   marker on each opener and never by the park list
+   ([D123 (defer-records)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d123)).
+   When `plumbbob park` warns that a question it names still counts as one to answer,
+   defer it if the human said the work will settle it, and leave it to them otherwise. If you
    genuinely cannot finish without touching more than the seam, that is scope drift:
    surface it to the human rather than sprawling.
    - **Bound agents can shape the build.** If `plumbbob status` shows a
@@ -202,8 +208,8 @@ switch with `/model` and rerun to honor it, or wave you on. Advisory, never a ga
    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
+   rows, the Now row naming the step in flight, Next Up with the next range on its second
+   line, and the 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`
@@ -399,8 +405,8 @@ out, or the next step in build order is one the range does not name),
   `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 state table's Range row names the run that lands
-  what is left of the range (`| Range | **3** on Opus: /plumbbob:run (steps 8-9) |`), and that is
+  human approves and the step lands, the range line beneath Next Up names the run that lands
+  what is left of the range (`|  | **Range 3** on Opus: /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/harvest/SKILL.md

@@ -2,7 +2,7 @@
 name: harvest
 description: "Triage the park list at a step boundary: propose one class (blocker/tangent/pivot) for every open parked item at once, and once the human settles them in one reply, fold a confirmed blocker into intent and record the rest with plumbbob harvest. A run's stop card carries its own harvest."
 disable-model-invocation: true
-allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob order:*), Bash(plumbbob handoff:*), Bash(plumbbob harvest:*)
+allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob order:*), Bash(plumbbob defer:*), Bash(plumbbob handoff:*), Bash(plumbbob harvest:*)
 ---
 
 # PlumbBob: harvest the park list
@@ -107,7 +107,16 @@ the call on each one theirs. The detail file you write first is the proposal; re
   The verb's ending names each range it re-cut, and an advisory names any it left for
   you; re-cut that one in the same confirmed edit, and `plumbbob status` afterward carries
   a `⚠` row for any range still broken.
-- Fold a confirmed blocker into `intent.md` before you run `plumbbob harvest`, so the
-  record and the plan agree when it lands.
+- A confirmed **tangent** that sets an open question aside (its park names `Q3`, and the
+  question waits on work still to come) defers that question as well: run
+  `plumbbob defer Q3 "<what settles it>"`. Say so in the proposal's reason
+  (`tangent: Q3 waits on step 9's numbers`), so the human's confirmation covers the
+  deferral. The park list never moves the Questions count, so a tangent alone leaves the
+  card reading a call still owed, and the record's ending warns of any question a tangent
+  names that still counts as one to answer
+  ([D123 (defer-records)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d123)).
+- Fold a confirmed blocker into `intent.md`, and defer each question a confirmed tangent
+  sets aside, before you run `plumbbob harvest`, so the record and the plan agree when it
+  lands.
 - Never reclassify or resolve an item the human hasn't confirmed, and default every
   uncertain item to **tangent**, never to blocker.

package/skills/park/SKILL.md

@@ -4,7 +4,7 @@ description: "Compose one tidy tagged park line, get the human's OK in-turn, the
 argument-hint: "[idea]"
 disable-model-invocation: true
 model: haiku
-allowed-tools: Bash(plumbbob status:*), Bash(plumbbob park:*)
+allowed-tools: Bash(plumbbob status:*), Bash(plumbbob park:*), Bash(plumbbob defer:*)
 ---
 
 # PlumbBob: park an idea (capture, don't chase)
@@ -58,11 +58,25 @@ Then:
    writing it above the capture, or stacking a second ending under the block are the ways
    this goes wrong.
 
+## A question set aside is deferred, not parked
+
+When the idea is an open question from the plan that the human wants picked up later,
+once other work lands (`leave Q3 until the latency numbers are in`), run
+`plumbbob defer Q3 "<what settles it>"` in place of the park. The question's own opener
+is where it waits, and the card counts it apart from the questions to answer; a park line
+beside it would leave the card counting it as a call still owed
+([D123 (defer-records)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d123)).
+`plumbbob defer` prints the same kind of block, `**Deferred**: Q3 (<slug>) until <what
+settles it>` and the pointer, and you relay it the same way. When `plumbbob park` warns that
+a question it names still counts as one to answer, relay the block as printed; whether to
+defer it is the human's call.
+
 ## The one hard contract
 
 The capture itself is the **dumb CLI**, never an edit. This skill carries **no Edit and
-no Write tool** on purpose: you may not append to `build-log.md` yourself. Compose, get
-approval, then shell `plumbbob park`; that is the only write path. If approval
+no Write tool** on purpose: you may not append to `build-log.md` yourself, nor mark a
+question in `intent.md`. Compose, get approval, then shell `plumbbob park`, or
+`plumbbob defer` for a question set aside; those are the only write paths. If approval
 never comes, capture nothing. (When the human's **own message** states the idea, a
 tangent they raise mid-build, that message **is** the approval: capture it directly
 with `plumbbob park`, don't ask again. Deferring in words without the CLI line captures

package/skills/plan/SKILL.md

@@ -3,7 +3,7 @@ name: plan
 description: "Frame a fresh goal and author the whole plan (Frame, Decisions, Constraints, all Steps, and the build ranges) before any code. Three input modes: no arg interviews you; a file path (or @-mention) absorbs a spec; any other text expands your inline intent."
 argument-hint: "[spec-path | intent]"
 disable-model-invocation: true
-allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob handoff:*), Bash(plumbbob start:*), Bash(plumbbob checkpoint:*), Bash(plumbbob agent list:*)
+allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob handoff:*), Bash(plumbbob start:*), Bash(plumbbob checkpoint:*), Bash(plumbbob defer:*), Bash(plumbbob agent list:*)
 ---
 
 # PlumbBob: plan a goal (the whole-goal move)
@@ -85,13 +85,18 @@ The argument only seeds how you get there.
    in one reply: on each opener line swap `*resolve by:*` for `*resolved:* <date>, <the
    answer>`, add the Decision the answer settles, and run `plumbbob handoff --plan` again.
    A question the human would rather let the work answer is deferred, not resolved: on
-   `defer Q3 until <what settles it>`, keep the question and swap its `*resolve by:*` for
+   `defer Q3 until <what settles it>`, run `plumbbob defer Q3 "<what settles it>"`, which
+   keeps the question and swaps its `*resolve by:*` for
    `*deferred:* <date>, until <what settles it>` on the opener line, then run
    `plumbbob handoff --plan` again. It stays open, the card lists it on a `Deferred` line
    beneath the table, out of reach of `yes to all leans`, and the Questions row counts it
    apart (`**1** to answer · 2 deferred`); once the work answers it, swap the marker for
    `*resolved:*` as above
    ([D120 (deferred-questions)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d120)).
+   A question the human keeps open on purpose, as the running log of something the build
+   tunes, is deferred the same way, until the work it logs; left on `*resolve by:*`, the
+   card counts it as a call still owed
+   ([D123 (defer-records)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d123)).
    Deferring is the human's call, never yours: a lean you are unsure of is still a lean.
 4. **Author the Steps.** Write the **full build plan** under `## Steps` (each step a
    small, verifiable increment) in the exact format the parser reads:
@@ -180,7 +185,7 @@ The argument only seeds how you get there.
 
    **The card names the run, not the item.** The item's command is the range's
    definition: the form the parser reads, and the kind of stop it makes. The card names
-   `/plumbbob:run` in the Range row beneath Next Up for the range holding the next step,
+   `/plumbbob:run` on the range line beneath Next Up for the range holding the next step,
    with the steps it will land beside it, and `/plumbbob:run 3` runs range 3 by its item number
    ([D95 (run-verb)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d95)).
    A range grants nothing until the human types the run that names it, and then the turn
@@ -244,7 +249,7 @@ The argument only seeds how you get there.
      refusal.)
    - **The plan commit prints its own close.** `plumbbob checkpoint --plan` emits the
      whole boundary ending: `**Plan**: committed (<sha>)`, any advisory, and the state
-     table headed by the pointer at the step the build starts on, its Range row naming the
+     table headed by the pointer at the step the build starts on, the range line beneath it naming the
      run that lands that step's range when the plan declares ranges. Relay that block whole and run no second command; the
      plan-pause card above is the one place `handoff` is still called, because no verb has
      run yet there.

package/skills/refine/SKILL.md

@@ -3,7 +3,7 @@ name: refine
 description: "Keep intent.md true: attack the plan for holes (append as Open questions) and refine or repair the Frame, Decisions, Constraints, Steps, and build ranges to match reality (`ranges` re-cuts the whole section). Usable at any point; you propose, the human approves."
 argument-hint: "[focus | ranges]"
 disable-model-invocation: true
-allowed-tools: Read, Edit, Bash(plumbbob status:*), Bash(plumbbob order:*)
+allowed-tools: Read, Edit, Bash(plumbbob status:*), Bash(plumbbob order:*), Bash(plumbbob defer:*)
 ---
 
 # PlumbBob: refine the plan
@@ -45,10 +45,15 @@ is fine; refining is always available.
   message (`yes to all leans`, or `yes to all leans except Q3: <their answer>`), no
   doc-flipping, no extra round-trip per hole. A resolved question gets
   `*resolved:* <date>, <the answer>` in place of its `*resolve by:*` on the opener line. The human
-  can also leave one to the work (`defer Q3 until <what settles it>`): keep the question
-  and swap its `*resolve by:*` for `*deferred:* <date>, until <what settles it>` on the
-  opener line, and the table moves it to a `Deferred` line beneath, still open
+  can also leave one to the work (`defer Q3 until <what settles it>`): run
+  `plumbbob defer Q3 "<what settles it>"`, which keeps the question and swaps its
+  `*resolve by:*` for `*deferred:* <date>, until <what settles it>` on the opener line,
+  and the table moves it to a `Deferred` line beneath, still open
   ([D120 (deferred-questions)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d120)).
+  A question the table still shows that the human has already set aside (parked, settled
+  as a tangent, or kept open as a log) is drift: propose deferring it, until what the
+  build says it waits on, rather than asking it again
+  ([D123 (defer-records)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d123)).
   Never retype the table as a list of your own
   ([D118 (questions-table)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d118)).
 - **Repair (re-sync to reality).** When the plan has drifted (a Decision was overtaken

package/skills/run/SKILL.md

@@ -3,7 +3,7 @@ name: run
 description: "Run what is left of the range holding the next step, or of range N: the plan's `## Build ranges` names the steps, the turn hook mints their grant from the plan, and the run walks them the way a typed range is walked, then ends on the stop card, the range's review with every open park proposed, which one reply settles. A bare range builds its one step to its pause. Reads the build skill beside it for the per-step loop."
 argument-hint: "[range-number]"
 disable-model-invocation: true
-allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob build:*), Bash(plumbbob handoff:*), Bash(plumbbob check:*), Bash(plumbbob checkpoint:*), Bash(plumbbob park:*), Bash(plumbbob agent:*), Bash(plumbbob spike:*), Bash(git diff:*), Bash(plumbbob harvest:*), Bash(plumbbob order:*), Bash(git log:*)
+allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob build:*), Bash(plumbbob handoff:*), Bash(plumbbob check:*), Bash(plumbbob checkpoint:*), Bash(plumbbob park:*), Bash(plumbbob defer:*), Bash(plumbbob agent:*), Bash(plumbbob spike:*), Bash(git diff:*), Bash(plumbbob harvest:*), Bash(plumbbob order:*), Bash(git log:*)
 ---
 
 # PlumbBob: run a range
@@ -223,8 +223,9 @@ The card's proposals are settled in one reply
 and the Your Call block names the replies. Read the human's message as one of them:
 
 - **`looks good`** confirms the review and locks in every lean as proposed, as the line
-  beneath the card's Your Call label says. Fold each confirmed blocker into `intent.md` by
-  the harvest skill's rules first, then run `plumbbob harvest`, which flips the parks,
+  beneath the card's Your Call label says. Fold each confirmed blocker into `intent.md`, and
+  defer each open question a confirmed tangent sets aside, by the harvest skill's rules
+  first, then run `plumbbob harvest`, which flips the parks,
   writes the Harvest lines, and writes the range's review beneath a dated line in the Log.
   A blocker that becomes a step goes into a range still to come, or a bare range of its
   own, never into the range this card reviews: that range has landed, its call is the one
@@ -250,7 +251,7 @@ and the Your Call block names the replies. Read the human's message as one of th
   `plumbbob status --run "<the same argument>"` again. When its grant line says
   `unlike the run`, the record re-cut the range the run would walk (a blocker added or moved a
   step in it), and the grant the hook minted before the record no longer covers it: relay
-  the record's ending whole and end the turn there, where its Range row names the re-cut run
+  the record's ending whole and end the turn there, where the range line beneath its Next Up names the re-cut run
   for the human to type
   ([D102 (settle-in-one-reply)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d102)).
   Otherwise relay the record's ending and walk the run from section 4.

package/templates/intent.md

@@ -149,8 +149,9 @@ build reports zero open questions
 fill it in and it counts.
 
 When the human would rather let the work answer a question, it is deferred, not
-resolved: keep the question and swap *resolve by:* for *deferred:* <date>, until
-<what settles it> ON THE OPENER LINE, so the opener reads
+resolved: `plumbbob defer Q4 "<what settles it>"` keeps the question and swaps
+*resolve by:* for *deferred:* <date>, until <what settles it> ON THE OPENER LINE, so
+the opener reads
 
   **Q4 (latency-budget)**: What latency budget do we hold?, *deferred:* 2026-10-31, until step 4's latency numbers
 
@@ -158,6 +159,10 @@ It stays open and still counts, but the card lists it on a line beneath the tabl
 rather than in it, so `yes to all leans` leaves it alone. Once the work answers it,
 swap the marker for *resolved:* as above
 ([D120 (deferred-questions)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d120)).
+A question parked, settled as a tangent, or kept open as the running log of something
+the build tunes waits on the work too, so it is deferred the same way; left on
+*resolve by:*, the card counts it as a call still owed
+([D123 (defer-records)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d123)).
 
 Size to the work: a tiny build's single, obvious question may stay one bare line;
 the *plain:*/*lean:* pair earns its keep only when a human decision genuinely waits