plumbbob 0.13.6 → 0.13.8

package/dist/verbs/handoff.js

@@ -49,8 +49,9 @@ import { PLAN_COMMIT_MARKER, commitNumstat, commitsBetween, commitsSince, diffNu
 import { blocks, cell, notice, printEnding, stateTable } from "../lib/notice.js";
 import { hasStep } from "../lib/steplist.js";
 import { isArtifactPath, parseStepSeam } from "../lib/intent.js";
-import { buildLogPath, checkpointsPath, detailPath, hasSession, inSpike, intentPath, readPause, readStats, readStop, readTurn, resolveBuild, seamPath, stepPath, tickPath, writePause, writeStop, } from "../lib/sidecar.js";
-import { buildOrderPhrase, countDiff, diffFileItems, diffRowValue, foldVerdict, lastLedgerSha, measureRange, normalizeDetailHeadings, parseBuildOrder, parseBuildRanges, parseConstraintCount, parseLastCheckpoint, parseOpenQuestions, parseOrderedSteps, parseParkTotals, parseRecap, parseRecommendation, parseSections, parseSteps, parseSummary, rangeLanded, rangeSpan, rangeStanding, recapLines, remainingOrder, resolveRun, runBracket, seamRowFromDiff, spentRowValue, stopFollowUp, summaryCheckRow, } from "../lib/orient.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, 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.
@@ -123,10 +124,17 @@ export function handoff(cwd, args = []) {
         // decision turn still ends on the model's recommendation when it wrote one.
         const first = steps.find((s) => !s.done);
         const detail = settleDetail(root, rawDetail);
+        // The open questions ride above the moves as their own table, which says
+        // what the Questions row would count, so the row stays off this card. The
+        // moves that settle them ride only while one waits on the human: a
+        // question deferred to the work is no call to make now.
+        const openRows = parseOpenQuestionRows(intent);
+        const questions = questionsPart(openRows, where);
         const plan = [
             SEAM_RULE,
-            planCallBlock(first, cardRun(intent, null)),
-            stateTable(stateRows({ intent, buildLog, verdict: null, now: null, stop: null, nextUp: first, exclude: null, where })),
+            questions ?? '',
+            planCallBlock(first, cardRun(intent, null), planPublish(root, slug), questionTotals(openRows).toAnswer > 0),
+            stateTable(stateRows({ intent, buildLog, verdict: null, now: null, stop: null, nextUp: first, exclude: null, where, questions: false })),
         ];
         const command = reprintCommand('--plan', undefined, named);
         return emit(root, { tier: 'decision', render: 'plan', command }, cardFoot(plan, detail, detailWhere));
@@ -169,7 +177,7 @@ export function handoff(cwd, args = []) {
             // The boundary the human already read: the reply above this line is what
             // they asked for, and the block would push it off the screen. Driver
             // tier, since nothing is pending to hold the turn for.
-            return emit(root, { tier: 'driver', render: 'pointer' }, [pointerLine(intent, nextUp, current, where)]);
+            return emit(root, { tier: 'driver', render: 'pointer' }, [pointerLine(nextUp, where)]);
         }
         // The boundary: the orientation-tier ending, the state table headed by the
         // Verdict, with the Stop row where a range just landed, and no decision
@@ -301,10 +309,10 @@ function landedRange(intent, steps, step) {
  * The Stop row's fact: why the build stops at this boundary. The range over
  * the count, a plain hyphen, the stop as the plan wrote it, and a bracket
  * pointing at the item, where its note can be read. The stop card's state
- * table carries the same row.
+ * table carries the same row, the range bold (D115 (card-weights)).
  */
 function stopValue(landed, where) {
-    return `Range ${landed.range.item} of ${landed.count} landed - ${landed.range.stop} (${detailsLink(where, landed.range.line)})`;
+    return `**Range ${landed.range.item}** landed - ${landed.range.stop} (${detailsLink(where, landed.range.line)})`;
 }
 /**
  * The `details:` clause every bracket on a card carries, in its short linked
@@ -332,10 +340,19 @@ export function detailsLink(path, line) {
  * step in flight, with no range just landed, and with a detail file written
  * for anything but that range, since a card with none of the model's review
  * on it would ask the human to approve nothing. It shows once per stop: while
- * the STOP stamp names the range, a later render is the one-line reminder,
- * whatever changed since (a lean the human changed, a park, a gate run), and
- * `--full` prints the card again. Every card it prints rewrites the stamp with
- * the turn it printed in, which is the turn `plumbbob harvest` waits past.
+ * the STOP stamp names the range, a render in a later turn is the one-line
+ * reminder, whatever changed since (a lean the human changed, a park, a gate
+ * run), and `--full` prints the card again. A render in the turn the card
+ * printed in prints it again in the same form, since the human has not read
+ * it yet: that is the retry the relay check asks for when a turn dropped it.
+ * Every card it prints rewrites the stamp with the turn it printed in, which
+ * is the turn `plumbbob harvest` waits past.
+ *
+ * When the landing that completed the range answered that step's own pause
+ * card, already shown, the human read that step's Summary, Readout, and
+ * recommendation a moment ago, so the card prints short: the Harvested part,
+ * Your Call, the state table with its Stop row, and the link, and `--full`
+ * prints it whole (D119 (short-stop-after-a-halt)).
  */
 function stopCard(root, slug, named, full) {
     const intent = readOr(intentPath(root, slug));
@@ -345,7 +362,7 @@ function stopCard(root, slug, named, full) {
         process.stderr.write(landed);
         return 1;
     }
-    const { range, count, step } = landed;
+    const { range, step } = landed;
     const detail = settleDetail(root, readOr(detailPath(root)));
     if (parseDetailRange(detail) !== range.item) {
         process.stderr.write(notice({
@@ -356,22 +373,26 @@ function stopCard(root, slug, named, full) {
         return 1;
     }
     const stamp = readStop(root, slug);
-    if (!full && stamp !== null && stamp.range === range.item) {
+    const turn = readTurn(root);
+    const printedThisTurn = turn !== null && stamp?.turn === turn;
+    if (!full && stamp !== null && stamp.range === range.item && !printedThisTurn) {
         // The stop the human already read: the reply above this line is what they
         // asked for, and the card would push it off the screen.
         const command = reprintCommand('--stop', undefined, named);
         return emit(root, { tier: 'decision', render: 'stop-reminder', command }, [
-            `**Next Up**: Back to Range ${range.item} of ${count}'s stop - ${range.stop}`,
+            `**Next Up**: Back to **Range ${range.item}**'s stop - ${range.stop}`,
         ]);
     }
-    writeStop(root, slug, { range: range.item, turn: readTurn(root) });
+    writeStop(root, slug, { range: range.item, turn });
     const where = relative(root, intentPath(root, slug));
     const review = stopReview(root, slug, intent, range, detail);
     const parks = parkList(readOr(buildLogPath(root, slug)));
     const proposals = harvestProposals(detail);
     const nextUp = steps.find((s) => !s.done && s.n !== step);
-    const parts = [summaryBlock(parseSummary(detail))];
-    if (review.readout.length > 0) {
+    const shown = readPause(root, slug);
+    const short = !full && shown?.kind === 'landed' && shown.step === step && shown.answered === true;
+    const parts = short ? [] : [summaryBlock(parseSummary(detail))];
+    if (!short && review.readout.length > 0) {
         parts.push([READOUT_LABEL, '', ...fence('text', review.readout)].join('\n'));
     }
     parts.push(harvestPart(parks, proposals) ?? '', stopCallBlock(leanExample(parks, proposals), intent), stateTable(stateRows({
@@ -385,8 +406,15 @@ function stopCard(root, slug, named, full) {
         exclude: step,
         where,
     })));
-    const command = reprintCommand('--stop --full', undefined, named);
-    return emit(root, { tier: 'decision', render: 'stop', command }, cardFoot(parts, detail, relative(root, detailPath(root))));
+    // A retry in this turn reprints the card as it printed: `--stop` rebuilds a
+    // short card from the PAUSE stamp the landing left, and a card shown whole
+    // on request comes back whole (D119 (short-stop-after-a-halt)).
+    const command = reprintCommand(full ? '--stop --full' : '--stop', undefined, named);
+    const detailWhere = relative(root, detailPath(root));
+    // The short card keeps the link, one line that repeats nothing, and leaves
+    // the recommendation the pause card just gave.
+    const foot = short ? [...parts, `[more details](${detailWhere})`] : cardFoot(parts, detail, detailWhere);
+    return emit(root, { tier: 'decision', render: 'stop', command }, foot);
 }
 /**
  * The range the stop card reviews: the one the last landing completed, or the
@@ -589,7 +617,7 @@ function harvestPart(parks, proposals) {
         const lean = proposal === undefined ? 'no lean proposed' : proposal.reason.length === 0 ? proposal.kind : `${proposal.kind}: ${proposal.reason}`;
         return `| ${cell(name)} | ${cell(park.text)} | ${cell(why)} | ${cell(lean)} |`;
     });
-    const lead = `**Harvested**: ${open.length} of ${parks.length} parked idea${parks.length === 1 ? '' : 's'} open`;
+    const lead = `**Harvested**: **${open.length}** of ${parks.length} parked idea${parks.length === 1 ? '' : 's'} open`;
     return [lead, '', LEAN_TABLE_HEAD, '| --- | --- | --- | --- |', ...rows].join('\n');
 }
 // The lean table's header row, the same on the stop card, a boundary
@@ -672,7 +700,7 @@ function stopCallBlock(example, intent) {
         moves.push(callLine('`/plumbbob:finish`', `I record ${what} the same way, then write the report and close the build`));
     }
     else if (follow !== null) {
-        moves.push(callLine('`/plumbbob:run`', `I record ${what} the same way, then run range ${follow.range.item} of ${follow.count} to its stop`));
+        moves.push(callLine('`/plumbbob:run`', `I record ${what} the same way, then run range ${follow.range.item}${onModel(follow.range.model)} to its stop`));
     }
     moves.push(callLine('anything that reads as direction', `I change the ${parked ? 'lean' : 'review'} and say what moved; nothing is recorded until you approve`), callLine('`expand`, or any question', 'I show more of what is there; nothing changes, and `show the stop` brings all of this back'));
     const lockIn = parked ? [`Approving locks in each lean above; to change one, say so first (\`${example}\`).`, ''] : [];
@@ -706,7 +734,8 @@ function leanExample(parks, proposals) {
  * part shows each class the human confirmed. Null when the detail file
  * reviews no range the plan declares.
  */
-export function stopRecord(root, slug, detail, buildLog) {
+export function stopRecord(root, slug, written, buildLog) {
+    const detail = recordText(root, slug, written);
     const intent = readOr(intentPath(root, slug));
     const item = parseDetailRange(detail);
     const range = parseBuildRanges(intent).ranges.find((r) => r.item === item);
@@ -745,7 +774,8 @@ export function stopRecord(root, slug, detail, buildLog) {
  * than a requirement. Null when the detail file carries nothing to record, so a
  * hand-built step with no detail gets the bare dated line it always did.
  */
-export function stepRecord(root, slug, step, detail) {
+export function stepRecord(root, slug, step, written) {
+    const detail = recordText(root, slug, written);
     const summary = parseSummary(detail);
     const recommendation = parseRecommendation(detail);
     const sections = parseSections(detail);
@@ -779,7 +809,8 @@ export function stepRecord(root, slug, step, detail) {
  * findings behind it. Nothing is measured at the plan pause, so no Readout and
  * no Verdict ride here. Null when the detail file carries neither.
  */
-export function planRecord(detail) {
+export function planRecord(root, slug, written) {
+    const detail = recordText(root, slug, written);
     const recommendation = parseRecommendation(detail);
     const sections = parseSections(detail);
     if (recommendation === null && sections.length === 0) {
@@ -787,6 +818,16 @@ export function planRecord(detail) {
     }
     return [...withRecommendation([], recommendation), ...sectionBlocks(sections)].join('\n\n');
 }
+/**
+ * The detail file's text as the build log reads it: every relative link
+ * re-aimed from `.plumbbob/`, where `detail.md` lives, to the build folder the
+ * log lives in, so a link that worked while the pause was open still works in
+ * the record (D116 (links-re-rooted)). Under `--local` the two are one folder
+ * and the text comes back as written.
+ */
+function recordText(root, slug, written) {
+    return rerootLinks(written, sidecarDir(root), buildFolder(root, slug));
+}
 /**
  * The record's opening block: the Summary lead without the `(details: …)`
  * bracket, since the record is where the detail now lives, then the
@@ -826,7 +867,7 @@ export function driverPointer(root, slug) {
     // work already recorded.
     const landed = parseLastCheckpoint(readOr(checkpointsPath(root, slug)))?.n ?? null;
     const forward = steps.find((s) => !s.done && s.n !== (inFlight ?? landed));
-    return driver ?? nextUpLine(forward, steps.length, relative(root, intentPath(root, slug)));
+    return driver ?? nextUpLine(forward, relative(root, intentPath(root, slug)));
 }
 /**
  * The Verdict for a step that just landed: the assembled rows folded worst-of
@@ -919,21 +960,30 @@ function summaryBlock(summary) {
 // named it too would put the step on the card twice.
 const READOUT_LABEL = '**Readout**:';
 /**
- * A step named the way every pointer names it: the number, the count out of
- * the whole plan, and the title behind a plain hyphen.
+ * A step named the way every pointer names it: the number in bold, the model
+ * its `- model:` line recommends, and the title behind a plain hyphen
+ * (`**Step 2** on Opus - <title>`).
  *
- * The count is the plan's own, step number over total, so the Now line and
- * Next Up agree under a re-sequenced build order. It is dropped only where it
- * would lie: a step the plan no longer holds is its number alone, since
- * "Step 9 of 3" would be worse than no count.
+ * The model rides the step it is for, so a card naming two steps and a range
+ * never leaves the human asking which one a model belongs to
+ * (D115 (card-weights)). A step with no recommendation, and a step the plan
+ * no longer holds, are their number alone.
  */
 function stepPhrase(n, steps) {
     const step = steps.find((s) => s.n === n);
     if (step === undefined) {
-        return `Step ${n}`;
+        return `**Step ${n}**`;
     }
     const title = step.title.length > 0 ? ` - ${step.title}` : '';
-    return `Step ${n} of ${steps.length}${title}`;
+    return `**Step ${n}**${onModel(step.model)}${title}`;
+}
+/**
+ * The clause naming the model a step or a range is for, ` on Sonnet`, read
+ * from its `- model:` line, or '' where none is written.
+ */
+function onModel(model) {
+    const token = modelToken(model);
+    return token === null ? '' : ` on ${capitalize(token)}`;
 }
 /**
  * What the `spent` row is rendered from: the step's own stamps and counters
@@ -1092,23 +1142,116 @@ function callLine(move, outcome) {
  * When that step sits in a range the run can walk, `looks good` names the run
  * instead, since the run is what the human types next; a step in no range, or
  * in a flagged one, keeps the build.
+ *
+ * Until the plan commit lands, `looks good` also says what that commit
+ * publishes, and a tracked folder adds the way out, `keep it local`, so the
+ * note rides the card where the decision is made and no model composes it
+ * (D117 (publish-on-the-card)).
+ *
+ * While a question waits on the human, two moves settle it: `yes to all leans`
+ * takes the table's leans, and `defer Q3 until …` leaves one to the work. A
+ * plan whose open questions are all deferred offers neither, since nothing
+ * there is a call to make now (D120 (deferred-questions)).
  */
-function planCallBlock(first, run) {
+function planCallBlock(first, run, publish, toAnswer) {
     const build = first === undefined ? '' : `; /plumbbob:build starts Step ${first.n}`;
     const starts = run.ok ? `; /plumbbob:run runs range ${run.range.item} from Step ${run.left[0]}` : build;
-    return [
-        '**Your Call**:',
-        '',
-        callLine('`looks good`', `I mark the plan decided${starts}`),
+    const commits = publish === null
+        ? ''
+        : publish.kind === 'tracked'
+            ? ` and commit it, so \`${publish.folder}\` rides this branch into the PR`
+            : ' and commit it record-only (git ignores `.plumbbob/` here, so the commit message carries the plan)';
+    const rows = [
+        callLine('`looks good`', `I mark the plan decided${commits}${starts}`),
+        ...(toAnswer
+            ? [
+                callLine('`yes to all leans`, or `yes to all leans except Q3: <your answer>`', 'I resolve each question in the table on its opener line, record the decision it settles, and show this card again'),
+                callLine('`defer Q3 until <what settles it>`', 'I mark Q3 deferred on its opener line, with what will settle it, and show this card again'),
+            ]
+            : []),
         callLine('`expand`, or any question', 'I show more of what is there; nothing changes'),
         callLine('anything that reads as direction', 'I take it as what to sharpen; the plan is cheap to change now'),
-    ].join('\n');
+    ];
+    if (publish?.kind === 'tracked') {
+        rows.push(callLine('`keep it local`', 'I run `plumbbob start --local`, so the plan commits record-only and the folder stays off the branch'));
+    }
+    return ['**Your Call**:', '', ...rows].join('\n');
+}
+/**
+ * The open questions as one table, a row per question: the handle and slug
+ * linked to the opener in `intent.md`, the question, why it matters, and the
+ * lean, each clipped to its first sentence so a row stays one line and the
+ * whole set fits on a screen (D118 (questions-table)). The expanded entry in
+ * `intent.md` stays what a cold reader needs; this is the chat-side view of
+ * it. A gap reads as one, the way the lean table's do: `not given` with no
+ * why, `no lean proposed` with no lean. Null with no question open.
+ *
+ * The table holds only the questions that wait on the human. A question
+ * deferred to the work rides one `**Deferred**:` line beneath it, linked to
+ * its opener with what will settle it, and with every open question deferred
+ * that line stands alone (D120 (deferred-questions)).
+ *
+ * ```text
+ * **Open questions**: **1** to answer · 1 deferred
+ *
+ * | Question | Why it matters | Lean |
+ * | --- | --- | --- |
+ * | [**Q1** (round-lines)](…/intent.md#L54): Where do the round lines go? | Two rounds run together | The reply |
+ *
+ * **Deferred**: [**Q2** (latency-budget)](…/intent.md#L58) until step 4's latency numbers
+ * ```
+ */
+export function questionsPart(rows, where) {
+    if (rows.length === 0) {
+        return null;
+    }
+    const toAnswer = rows.filter((q) => q.deferred === null);
+    const deferred = rows.filter((q) => q.deferred !== null);
+    const body = toAnswer.map((q) => {
+        const question = `[${questionHandle(q)}](${where}#L${q.line}): ${firstSentence(q.question)}`;
+        const why = q.why === null || q.why.length === 0 ? 'not given' : firstSentence(q.why);
+        const lean = q.lean === null || q.lean.length === 0 ? 'no lean proposed' : firstSentence(q.lean);
+        return `| ${cell(question)} | ${cell(why)} | ${cell(lean)} |`;
+    });
+    const table = toAnswer.length === 0
+        ? []
+        : [`**Open questions**: ${questionsValue(questionTotals(rows))}`, '', QUESTIONS_TABLE_HEAD, '| --- | --- | --- |', ...body];
+    const settles = (q) => (q.deferred === null || q.deferred.length === 0 ? 'until (not given)' : firstSentence(q.deferred));
+    const line = deferred.length === 0 ? [] : [`**Deferred**: ${deferred.map((q) => `[${questionHandle(q)}](${where}#L${q.line}) ${settles(q)}`).join(' · ')}`];
+    return [table.join('\n'), ...line].filter((part) => part.length > 0).join('\n\n');
+}
+/** A question's handle as the table and the Deferred line show it: the id bold, then its slug. */
+function questionHandle(q) {
+    return q.slug === null ? `**${q.id}**` : `**${q.id}** (${q.slug})`;
+}
+// The questions table's header row, the same on the plan card and under
+// `status --questions`.
+const QUESTIONS_TABLE_HEAD = '| Question | Why it matters | Lean |';
+/**
+ * A field's first sentence, without its closing period: a cell reads as a
+ * phrase, and a question keeps its question mark. The whole text when no
+ * sentence ends inside it.
+ */
+function firstSentence(text) {
+    const sentence = /^(.+?[.?!])(?=\s|$)/.exec(text.trim())?.[1] ?? text.trim();
+    return sentence.replace(/\.$/, '');
+}
+/**
+ * Read what the plan commit will publish through the same probe `checkpoint
+ * --plan` stages by, so the card's promise and the commit cannot disagree
+ * (D117 (publish-on-the-card)).
+ */
+function planPublish(root, slug) {
+    if (planCommitted(root, slug)) {
+        return null;
+    }
+    return buildFolderIgnored(root, slug) ? { kind: 'record-only' } : { kind: 'tracked', folder: `${relative(root, buildFolder(root, slug))}/` };
 }
 /**
  * The driver turn's pointer: back to the step still in flight, since a park or
- * a spike interrupts a step without ending it. No model clause rides here; the
- * step is already being built, so the `/model` call is behind us. Null when no
- * step is open, which is the caller's cue to fall back to the forward pointer.
+ * a spike interrupts a step without ending it, named as the Now row names it.
+ * Null when no step is open, which is the caller's cue to fall back to the
+ * forward pointer.
  */
 function driverNextUpLine(steps, inFlight) {
     return inFlight === null ? null : `**Next Up**: Back to ${stepPhrase(inFlight, steps)}`;
@@ -1134,73 +1277,112 @@ const ORDER_CAP = 5;
  * something: the Verdict, the step in flight, the Stop, Next Up, the range the
  * next run walks, the build order where `## Build order` re-sequences the
  * plan, the parks once anything has been parked, and the open questions the
- * plan still carries. The first row present becomes the header, which is the
- * Verdict wherever one was measured (D111 (state-table)).
+ * plan still carries, split by who acts on them. The first row present
+ * 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);
-    const range = rangeSegment(input.intent, steps, input.nextUp, input.exclude);
+    const range = rangeSegment(input.intent, steps, input.exclude);
     const order = buildOrderPhrase(remainingOrder(parseSteps(input.intent), parseBuildOrder(input.intent), input.exclude), ORDER_CAP);
     const parks = parseParkTotals(input.buildLog);
-    const questions = parseOpenQuestions(input.intent);
+    const questions = questionTotals(parseOpenQuestionRows(input.intent));
     const rows = [
         input.verdict === null ? null : { label: 'Verdict', value: input.verdict },
         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, steps.length, input.where, range.model ?? input.nextUp?.model ?? null) },
-        range.segment.length === 0 ? null : { label: 'Range', value: range.segment },
+        { label: 'Next Up', value: pointerText(input.nextUp, input.where) },
+        range.length === 0 ? null : { label: '', value: range },
         order.length === 0 ? null : { label: 'Order', value: order },
-        parks.total === 0 ? null : { label: 'Parked', value: `${parks.open} of ${parks.total} open` },
-        questions === 0 ? null : { label: 'Questions', value: `${questions} open` },
+        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) },
     ];
     return rows.filter((r) => r !== null);
 }
+/**
+ * The Questions row's fact, split by who acts: the questions that wait on the
+ * human, bold, as the Parked row bolds what the human acts on, then the ones
+ * deferred to the work (`**1** to answer · 2 deferred`), either half alone when
+ * the other is zero (D120 (deferred-questions)). The caller drops the row at
+ * zero.
+ */
+function questionsValue(totals) {
+    return [...(totals.toAnswer > 0 ? [`**${totals.toAnswer}** to answer`] : []), ...(totals.deferred > 0 ? [`${totals.deferred} deferred`] : [])].join(' · ');
+}
+/**
+ * The Parked row's fact: the parks still open, bold, over every park ever
+ * made, and while any is open the move that settles them, so a human who never
+ * read the docs learns the verb where the count is (D115 (card-weights)).
+ * Mid-step the move waits for the step to land, since a harvest runs only
+ * between steps.
+ */
+function parkedValue(parks, midStep) {
+    const count = `**${parks.open}** of ${parks.total} open`;
+    if (parks.open === 0) {
+        return count;
+    }
+    return midStep ? `${count}: /plumbbob:harvest once this step lands` : `${count}: /plumbbob:harvest`;
+}
 /**
  * The bare forward pointer, the one line a boundary already shown ends on:
- * the Next Up line the driver tier keeps, with the range's model in its
- * bracket while the next run is a range, as the table's Next Up row has it.
+ * the Next Up line the driver tier keeps, written as the table's Next Up row
+ * writes it.
  */
-function pointerLine(intent, nextUp, exclude, where) {
-    const steps = parseOrderedSteps(intent);
-    const range = rangeSegment(intent, steps, nextUp, exclude);
-    return nextUpLine(nextUp, steps.length, where, range.model ?? nextUp?.model ?? null);
+function pointerLine(nextUp, where) {
+    return nextUpLine(nextUp, where);
 }
 /**
- * The Range row's fact, and the model the pointer's bracket bolds while it
- * suggests a range: the run `/plumbbob:run` typed now would walk,
- * `3 of 5: /plumbbob:run (steps 6-9)`, with the model of the range holding
- * the step Next Up names; 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 count.
+ * 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 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
- * (`range 3 of 5 lands with step 9`). The model is read with the step the turn
- * is about landed, so at that last-step pause it is the next range's, the one
- * the human picks a model for. A flagged range, and a range with no
- * `- model:` line, leave the step's model in the bracket.
- */
-function rangeSegment(intent, steps, nextUp, exclude) {
-    const landed = steps.map((s) => (s.n === exclude ? { ...s, done: true } : s));
-    const { holding, command } = rangeStanding(parseBuildRanges(intent), landed, nextUp?.n ?? null);
-    const model = holding !== null && command !== null ? holding.model : null;
+ * 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} of ${run.count}`;
-        const lands = paused !== null && run.left.length === 1;
-        return { segment: lands ? `${name} lands with step ${paused}` : `${name}: /plumbbob:run (${runBracket(run)})`, model };
+        return `**Range ${run.range.item}**${onModel(run.range.model)}: /plumbbob:run ${when(run)}`;
     }
     if (run.kind === 'uncovered') {
-        return { segment: run.words, model };
+        return run.words;
     }
-    return { segment: run.kind === 'flagged' ? `${run.item} of ${run.count} needs a re-cut (${run.words})` : '', model };
+    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
@@ -1212,33 +1394,29 @@ function cardRun(intent, paused) {
     return resolveRun({ intent, inFlight: paused, spiking: false, item: null });
 }
 /**
- * The forward pointer's fact: the next undone step with the progress count,
- * its title, and a closing bracket carrying its advisory `- model:`
- * recommendation and where to read the step in full. No next step ⇒ the
+ * The forward pointer's fact: the next undone step, the model it is for, its
+ * title, and a closing bracket saying where to read it in full
+ * (`**Step 3** on Sonnet - <title> (details: …)`). No next step ⇒ the
  * finish/step nudge instead.
  *
- * The model is the second bold token the line spends, because it is the one
- * the human acts on (a `/model` call) before the next run; the path is the
- * short link every `details:` bracket carries (`detailsLink`). The state
- * table's Next Up row carries it; `nextUpLine` labels it for the one line a
- * driver turn ends on.
+ * The model rides the step it is for, the one the human acts on (a `/model`
+ * call) before building it (D115 (card-weights)); the path is the short link
+ * every `details:` bracket carries (`detailsLink`). The state table's Next Up
+ * row carries it; `nextUpLine` labels it for the one line a driver turn ends on.
  */
-function pointerText(nextUp, total, where, model = nextUp?.model ?? null) {
+function pointerText(nextUp, where) {
     if (nextUp === undefined) {
         return 'Nothing planned - /plumbbob:step or /plumbbob:finish';
     }
     const title = nextUp.title.length > 0 ? ` - ${nextUp.title}` : '';
-    const token = modelToken(model);
-    const bracket = token === null ? [] : [`model: **${capitalize(token)}**`];
-    bracket.push(detailsLink(where, nextUp.line));
-    return `Step ${nextUp.n} of ${total}${title} (${bracket.join(', ')})`;
+    return `**Step ${nextUp.n}**${onModel(nextUp.model)}${title} (${detailsLink(where, nextUp.line)})`;
 }
 /**
  * The forward pointer as one labeled line: the driver tier's pointer, and the
  * line a boundary already shown ends on.
  */
-function nextUpLine(nextUp, total, where, model = nextUp?.model ?? null) {
-    return `**Next Up**: ${pointerText(nextUp, total, where, model)}`;
+function nextUpLine(nextUp, where) {
+    return `**Next Up**: ${pointerText(nextUp, where)}`;
 }
 /**
  * The model token from a `- model:` recommendation: the first word, so a
@@ -1253,7 +1431,7 @@ function modelToken(model) {
 }
 /**
  * Capitalize a token's first letter for the card's title-case furniture
- * (`(model: Sonnet)`); the rest rides through unchanged.
+ * (`on Sonnet`); the rest rides through unchanged.
  */
 function capitalize(s) {
     return s.length === 0 ? s : `${s[0]?.toUpperCase()}${s.slice(1)}`;

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.
@@ -99,11 +100,22 @@ export function harvest(cwd, _args) {
     const counted = classWords(settled);
     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} of ${stop.count} recorded`, 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;
 }