plumbbob 0.13.0 → 0.13.2

package/dist/verbs/harvest.js

@@ -0,0 +1,224 @@
+// `plumbbob harvest`: record a harvest from the detail file. The skill decides
+// and the CLI records (D104 (harvest-records)): the model writes one proposal
+// per open park under the detail file's `## Harvest` section, the human
+// settles them in one reply, and this verb flips each settled park in
+// `build-log.md`, appends the dated Harvest lines, and, when the detail is a
+// range's, writes the range's review beneath a dated Log line, the way
+// `checkpoint` keeps a step's pause beneath its own. It commits nothing: the
+// record rides the next step's checkpoint, or the finish.
+//
+// A stop's record is latched (D103 (stop-latched)). It refuses in the turn
+// the stop card printed, since a run's long turn ends on proposals and that is
+// where a model would carry straight on into recording its own; it refuses a
+// range's detail no stop card showed, read off the digest the card's STOP
+// stamp keeps; and it refuses a range that no longer reads as landed, telling
+// a step landed and reopened from one that joined the range after it landed,
+// which moves to a range still to come. A harvest outside a stop (`# Detail · Harvest`) needs no stamp. A proposal
+// naming a handle the list lacks (`P9` with eight parked), or a class outside
+// the three, refuses the whole record, so the card and the ledger never
+// disagree about which parks are open; a park no proposal names stays open,
+// and the record says nothing about it.
+import { readFileSync, writeFileSync } from 'node:fs';
+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 { activeBuild, buildLogPath, checkpointsPath, clearDetail, clearStop, detailDigest, detailPath, hasSession, intentPath, readStop, } from "../lib/sidecar.js";
+import { hasStep } from "../lib/steplist.js";
+import { boundaryEnding, harvestProposals, parkList, parseDetailRange, stopRecord } from "./handoff.js";
+// The three classes a park settles as, in the order the ending counts them.
+const CLASSES = ['blocker', 'tangent', 'pivot'];
+// Where a refusal about the proposals sends the model: the file it wrote them in.
+const FIX_PROPOSALS = 'fix the Harvest proposals in .plumbbob/detail.md';
+/**
+ * Record the harvest the detail file proposes, and the range's review when the
+ * detail is a range's.
+ *
+ * Exit 1 on any refusal: no session, a detail file that is no range's or
+ * harvest's, the latch, a range no stop card showed or no longer landed, and a
+ * proposal it cannot settle. Each refusal names the move that unblocks it.
+ */
+export function harvest(cwd, _args) {
+    const root = findRepoRoot(cwd);
+    if (root === null || !hasSession(root)) {
+        process.stderr.write(notice({ fact: 'no active session', remedy: 'plumbbob start "<title>"' }));
+        return 1;
+    }
+    const slug = activeBuild(root);
+    const detail = readOr(detailPath(root));
+    const item = parseDetailRange(detail);
+    if (item === null && !isHarvestDetail(detail)) {
+        process.stderr.write(nothingToRecord(detail));
+        return 1;
+    }
+    const intent = readOr(intentPath(root, slug));
+    const buildLog = readOr(buildLogPath(root, slug));
+    const parks = parkList(buildLog);
+    let stop = null;
+    if (item !== null) {
+        const found = stopRange(root, slug, intent, detail, item);
+        if (typeof found === 'string') {
+            process.stderr.write(found);
+            return 1;
+        }
+        stop = found;
+    }
+    const subject = stop === null ? 'harvest not recorded' : `range ${stop.item} of ${stop.count}'s stop not recorded`;
+    const settled = settle(parks, harvestProposals(detail));
+    if (typeof settled === 'string') {
+        process.stderr.write(notice({ fact: subject, detail: [settled], remedy: FIX_PROPOSALS }));
+        return 1;
+    }
+    if (stop === null && settled.length === 0) {
+        process.stderr.write(notice({ fact: 'harvest not recorded', detail: ['the detail file settles no open park'], remedy: FIX_PROPOSALS }));
+        return 1;
+    }
+    // The review is read before the flip, so its Harvested part shows each lean
+    // the human confirmed beside the park it settled.
+    const record = stop === null ? null : stopRecord(root, slug, detail, buildLog);
+    const date = new Date().toISOString().slice(0, 10);
+    const where = stop === null ? boundaryWords(root, slug) : `at range ${stop.item} of ${stop.count}'s stop`;
+    let updated = flipParks(buildLog, settled.map((p) => p.handle));
+    updated = updated === null ? null : appendHarvest(updated, harvestLines(date, where, settled));
+    if (stop !== null) {
+        updated = updated === null ? null : appendToSection(updated, 'Log', logEntry(stopLogLine(date, stop.item, stop.count, stop.stop), record));
+    }
+    if (updated === null) {
+        process.stderr.write(notice({ fact: `${subject}`, detail: ['build-log.md is missing a section it writes to'], remedy: 'restore its Park list, Harvest, and Log sections' }));
+        return 1;
+    }
+    writeFileSync(buildLogPath(root, slug), updated);
+    clearDetail(root);
+    clearStop(root, slug);
+    // Outside a stop the label names the act, `Recorded`, since `Harvested` is
+    // the stop card's part and one label over a part that proposes and an ending
+    // that records would mean two things (D106 (leans-harvested)).
+    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] });
+    printEnding(root, {
+        tier: 'orientation',
+        render: 'harvest',
+        text: ending({ lead, pointer: boundaryEnding(root, slug, null).pointer }),
+    });
+    return 0;
+}
+/**
+ * The range a range's detail reviews, once the record may land: the plan
+ * holds the range, a stop card showed this detail, a human turn has read it,
+ * and every step of the range has landed. Otherwise the refusal, with the move
+ * that unblocks it.
+ *
+ * An undone step in the range reads two ways, told apart by the ledger. One
+ * with a `step N <sha>` line landed and was reopened, so it lands again and
+ * the card re-renders. One with none joined the range after the card, a
+ * blocker folded into the range that just landed, and `handoff --stop` would
+ * refuse too, since the last landing no longer completes the range; so the
+ * remedy moves the step to a range still to come and runs the record again,
+ * which holds in the same reply while the detail file stays as the card
+ * showed it.
+ */
+function stopRange(root, slug, intent, detail, item) {
+    const plan = parseBuildRanges(intent);
+    const count = plan.ranges.length + plan.malformed.length;
+    const range = plan.ranges.find((r) => r.item === item);
+    const refuse = (why, remedy) => notice({ fact: `range ${item} of ${count}'s stop not recorded`, detail: [why], remedy });
+    if (range === undefined) {
+        return refuse(`the plan has no range ${item}`, `write the range's number in the header of .plumbbob/detail.md`);
+    }
+    const stamp = readStop(root, slug);
+    if (stamp === null || stamp.range !== item || stamp.detail !== detailDigest(detail)) {
+        return refuse('no stop card showed its detail', 'plumbbob handoff --stop, then end the turn on the card');
+    }
+    if (!checkStopLatch(root, stamp.turn)) {
+        return refuse("its card printed this turn, and no human turn has read it", "end the turn on the card; the human's reply is what records it");
+    }
+    const held = parseOrderedSteps(intent).filter((s) => hasStep(range.steps, s.n));
+    if (held.length === 0) {
+        return refuse('the plan holds none of its steps', 'land it, then plumbbob handoff --stop');
+    }
+    const open = held.find((s) => !s.done);
+    if (open !== undefined) {
+        // A step the ledger landed was reopened since, and lands again; one it never
+        // landed was folded into the range after the card, and moves out instead.
+        return stepShas(readOr(checkpointsPath(root, slug))).has(open.n)
+            ? refuse(`step ${open.n} is open again`, 'land it, then plumbbob handoff --stop')
+            : refuse(`step ${open.n} joined it after it landed`, `move step ${open.n} to a range still to come, then plumbbob harvest`);
+    }
+    return { item, count, stop: range.stop };
+}
+/**
+ * The open parks the proposals settle, in list order, or the words for the
+ * first proposal that cannot be recorded: one naming a handle the list lacks,
+ * or a class outside the three, each named by the handle the card prints. A park no proposal names stays open; a proposal
+ * for a park already harvested settles nothing; and the first proposal for a
+ * park is the one the card showed.
+ */
+function settle(parks, proposals) {
+    for (const proposal of proposals) {
+        if (proposal.handle < 1 || proposal.handle > parks.length) {
+            return `P${proposal.handle} is not in the list; ${parks.length} parked`;
+        }
+        if (!CLASSES.includes(proposal.kind)) {
+            return `P${proposal.handle}'s class "${proposal.kind}" is not blocker, tangent, or pivot`;
+        }
+    }
+    return parks.flatMap((park) => {
+        const proposal = proposals.find((p) => p.handle === park.handle);
+        return park.open && proposal !== undefined ? [{ handle: park.handle, kind: proposal.kind, text: park.text, reason: proposal.reason }] : [];
+    });
+}
+/** The classes settled, counted in the ending's order: `1 blocker, 2 tangents`, or `nothing parked`. */
+function classWords(settled) {
+    const words = CLASSES.flatMap((kind) => {
+        const n = settled.filter((p) => p.kind === kind).length;
+        return n === 0 ? [] : [`${n} ${kind}${n === 1 ? '' : 's'}`];
+    });
+    return words.length === 0 ? 'nothing parked' : words.join(', ');
+}
+/** Where a harvest outside a stop ran, for its dated line: the boundary of the step that landed last. */
+function boundaryWords(root, slug) {
+    const last = parseLastCheckpoint(readOr(checkpointsPath(root, slug)));
+    return last === null ? 'before the first step landed' : `at the step ${last.n} boundary`;
+}
+/**
+ * Whether a detail file is a boundary harvest's wire, read off its
+ * `# Detail · Harvest` header.
+ */
+export function isHarvestDetail(detail) {
+    const first = detail.trimStart().split('\n', 1)[0] ?? '';
+    return /^#\s+Detail\s*·\s*Harvest\s*$/.test(first);
+}
+/**
+ * The refusal for a detail file that is no range's and no harvest's: a step's
+ * is checkpoint's to record, and an empty one, or one with no header, records nothing.
+ */
+function nothingToRecord(detail) {
+    const step = parseDetailStep(detail);
+    if (step !== null) {
+        return notice({
+            fact: 'nothing to record',
+            detail: [`the detail file is Step ${step}'s, not a range's or a harvest's`],
+            remedy: `plumbbob checkpoint ${step} records a step's detail`,
+        });
+    }
+    const why = detail.trim().length === 0 ? 'the detail file is empty' : 'the detail file names no range or harvest';
+    return notice({
+        fact: 'nothing to record',
+        detail: [why],
+        remedy: 'write the proposals in .plumbbob/detail.md under `# Detail · Harvest`',
+    });
+}
+/**
+ * Read a file as UTF-8, or '' when it is missing or unreadable.
+ */
+function readOr(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}

package/dist/verbs/order.js

@@ -14,16 +14,18 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { findRepoRoot } from "../lib/git.js";
 import { activeBuild, hasSession, intentPath } from "../lib/sidecar.js";
 import { clearBuildOrder, orderSteps, parseSteps, setBuildOrder } from "../lib/orient.js";
+import { expandStepList, parseStepList } from "../lib/steplist.js";
 import { ending, notice, printEnding, transition } from "../lib/notice.js";
 import { driverPointer } from "./handoff.js";
 /**
- * Set the build order to the given step numbers, the rest of the undone steps
- * following in document order, or clear it with `--reset`.
+ * Set the build order to the given step numbers and spans, the rest of the
+ * undone steps following in document order, or clear it with `--reset`.
  *
- * The line written is the whole remaining sequence, so a cold reader of
- * intent.md sees every undone step and not only the ones re-sequenced.
- * Refuses (exit 1) with no session, no numbers, a token that is not a number,
- * a number the plan lacks, a repeated number, or a step already checkpointed.
+ * The line written is the whole remaining sequence, each span spelled out, so a
+ * cold reader of intent.md sees every undone step and not only the ones
+ * re-sequenced. Refuses (exit 1) with no session, no numbers, a token that is
+ * neither a number nor a span, a number the plan lacks, a repeated number, or a
+ * step already checkpointed.
  */
 export function order(cwd, args) {
     const root = findRepoRoot(cwd);
@@ -45,8 +47,9 @@ export function order(cwd, args) {
         });
         return 0;
     }
-    // Numbers arrive space- or comma-separated: `order 7 8 5` and `order 7,8,5`
-    // read the same, since the line they write is the comma form.
+    // Numbers and spans arrive space- or comma-separated, with or without a space
+    // after a comma: `order 7 8 5`, `order 7,8,5`, and `order 1, 6, 2-4, 7, 5`
+    // all read, and a span names its steps in place, since the line is a sequence.
     const tokens = args
         .filter((a) => !a.startsWith('--'))
         .flatMap((a) => a.split(','))
@@ -60,14 +63,15 @@ export function order(cwd, args) {
         }));
         return 1;
     }
-    const stray = tokens.find((t) => !/^\d+$/.test(t));
+    const lists = tokens.map(parseStepList);
+    const stray = tokens.find((_, i) => lists[i] === null);
     if (stray !== undefined) {
-        process.stderr.write(notice({ fact: `\`${stray}\` is not a step number`, remedy: 'plumbbob order 7 8 5' }));
+        process.stderr.write(notice({ fact: `\`${stray}\` is not a step number or span`, remedy: 'plumbbob order 1, 6, 2-4, 7, 5' }));
         return 1;
     }
-    const given = tokens.map(Number);
     const steps = parseSteps(intent);
     const planned = steps.map((s) => s.n);
+    const given = expandStepList(lists.flatMap((list) => list ?? []), (n) => planned.includes(n));
     const unknown = given.find((n) => !planned.includes(n));
     if (unknown !== undefined) {
         process.stderr.write(notice({

package/dist/verbs/recover.js

@@ -18,7 +18,7 @@
 // deleting them is a gamble the human should take by hand.
 import { existsSync, readFileSync } from 'node:fs';
 import { findRepoRoot } from "../lib/git.js";
-import { parseBuildOrder, parseSteps } from "../lib/orient.js";
+import { parseBuildOrder, parseBuildRanges, parseOrderedSteps, parseSteps, rangeStanding } from "../lib/orient.js";
 import { activeBuild, checkpointsPath, clearHandoff, clearTick, grantPath, handoffPath, hasSession, intentPath, inSpike, listBuilds, readTurn, setActiveBuild, setGrant, stepPath, tickPath, } from "../lib/sidecar.js";
 import { spikeBranches, spikeWorktrees } from "./spike.js";
 /**
@@ -94,6 +94,7 @@ function sessionFindings(root) {
     const stepInFlight = existsSync(stepPath(root, slug));
     findings.push(...phaseFindings(root, slug, stepInFlight));
     findings.push(...orderFindings(root, slug));
+    findings.push(...rangeFindings(root, slug));
     findings.push(...leftoverFindings(root, slug, stepInFlight));
     return findings;
 }
@@ -126,6 +127,35 @@ function orderFindings(root, slug) {
         },
     ];
 }
+/**
+ * A build range naming a step the plan does not hold.
+ *
+ * The section under `## Build ranges` is hand-editable, and a refine can drop
+ * a step a range names; the card then suggests no command for that range, and
+ * the dashboard says why. Reported beside the build order's own finding, never
+ * repaired: where the stop belongs now is the human's call. Silent while the
+ * plan declares no ranges.
+ */
+function rangeFindings(root, slug) {
+    const intent = readOr(intentPath(root, slug));
+    const plan = parseBuildRanges(intent);
+    if (plan.ranges.length === 0) {
+        return [];
+    }
+    const missing = rangeStanding(plan, parseOrderedSteps(intent), null).drift.filter((d) => d.kind === 'missing');
+    if (missing.length === 0) {
+        const count = `${plan.ranges.length} range${plan.ranges.length === 1 ? '' : 's'}`;
+        return [{ name: 'build ranges', ok: true, detail: `every step they name is planned (${count})` }];
+    }
+    return [
+        {
+            name: 'build ranges',
+            ok: false,
+            detail: missing.map((d) => `range ${d.item} names a step the plan lacks: ${d.words}`).join('; '),
+            hint: 're-cut the range under ## Build ranges by hand, or with /plumbbob:refine',
+        },
+    ];
+}
 /**
  * The cursor names a build that is not there.
  *

package/dist/verbs/relay.js

@@ -25,7 +25,9 @@
 // has already landed. The once is counted in `RELAY` by the turn it held,
 // never by `stop_hook_active`, which checkride's gate sets on every red Stop
 // and which names no hook. It never sends `continue: false`, which would cancel
-// a sibling's block in the same round.
+// a sibling's block in the same round. A run's boundary that still owes its
+// stop card is a miss however whole the boundary was, since the card is the
+// run's ending, and its reason names `plumbbob handoff --stop` as the retry.
 //
 // The final message comes from the payload's `last_assistant_message`, never
 // from the transcript, which does not yet hold that message when Stop fires;
@@ -71,7 +73,10 @@ export function relayCheck(cwd, raw) {
     const turn = readTurn(root);
     if (record === null || turn === null || record.turn !== turn || record.held === turn)
         return null;
-    const carried = carriedEnding(record, payload.last_assistant_message, payload);
+    // A run's boundary that still owes its stop card is held whatever the turn
+    // relayed: the card is the run's ending, and `handoff --stop` overwrites
+    // this record once it prints.
+    const carried = record.owes !== undefined ? false : carriedEnding(record, payload.last_assistant_message, payload);
     // Whole, or not this check's to judge: let the turn end.
     if (carried !== false)
         return null;
@@ -206,6 +211,11 @@ function partsOf(text) {
  * turn missed, and the command or block that puts it back.
  */
 function reason(record) {
+    if (record.owes !== undefined) {
+        const { range, count, step } = record.owes;
+        return (`plumbbob: the turn ended on Step ${step}'s boundary, and range ${range} of ${count}'s stop card is still owed. ` +
+            "Write the range's detail file, run `plumbbob handoff --stop`, and end the turn on its output, whole, with nothing after it.");
+    }
     if (record.tier === 'decision') {
         const command = record.command ?? 'plumbbob handoff --full';
         return (`plumbbob: the turn did not close on the ${DECISION_NAMES[record.render] ?? 'pause'} it printed. ` +
@@ -219,6 +229,8 @@ function reason(record) {
 const DECISION_NAMES = {
     card: 'pause card',
     reminder: 'pause reminder',
+    stop: 'stop card',
+    'stop-reminder': 'stop reminder',
     plan: 'plan card',
 };
 // The command that printed an orientation ending, by its render, so the reason
@@ -226,6 +238,7 @@ const DECISION_NAMES = {
 const ORIENTATION_VERBS = {
     checkpoint: 'plumbbob checkpoint',
     'plan-commit': 'plumbbob checkpoint --plan',
+    harvest: 'plumbbob harvest',
     finish: 'plumbbob finish',
 };
 /**

package/dist/verbs/status.js

@@ -3,13 +3,19 @@
 // the in-flight STEP marker) into a where-am-I view that suggests one primary
 // next move while printing the full picture, so you can always override.
 // Read-only, always exits 0. Skills pre-inject this output to gate their own
-// behavior, so the `NO ACTIVE SESSION` sentinel is kept exact.
+// behavior, so the `NO ACTIVE SESSION` sentinel is kept exact. A stop card
+// still waiting for its reply marks its range and takes the next move. With
+// `--run`, it prints the run a `/plumbbob:run` invocation names above the
+// dashboard, and names the waiting card again beneath the run's grant.
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { PLAN_COMMIT_MARKER, commitsSince, findRepoRoot } from "../lib/git.js";
 import { SLOTS, readHarnessFile, resolveAgent, } from "../lib/agents.js";
 import { buildFolder, buildLogPath, checkpointsPath, hasSession, inSpike, intentPath, listBuilds, resolveBuild, stepPath, } from "../lib/sidecar.js";
-import { formatOrientation, lastLedgerSha, orient, parseRequestedStep } from "../lib/orient.js";
+import { readGrant } from "../lib/latch.js";
+import { formatOrientation, formatRunDashboard, lastLedgerSha, orient, parseRequestedStep, resolveRunArgs, } from "../lib/orient.js";
+import { normalizeStepList } from "../lib/steplist.js";
+import { waitingCard } from "./handoff.js";
 /**
  * Read a file as utf8, or '' when it is missing or unreadable.
  */
@@ -22,20 +28,32 @@ function readOr(path) {
     }
 }
 /**
- * Split `--invoked "<raw args>"` out of the argument list, ahead of any other
- * flag parsing.
+ * Split a flag carrying a skill invocation's raw text (`--invoked` or `--run`)
+ * out of the argument list, ahead of any other flag parsing.
  *
  * The value is the verbatim text of a skill invocation (the `$ARGUMENTS` the
- * `/plumbbob:build` skill passes through), so it can contain anything,
- * including tokens that look like this CLI's own flags; extracting it first
- * keeps such a value from confusing `resolveBuild`. A missing flag, or one
- * with no value, reads as null: no explicit ask.
+ * skill passes through), so it can contain anything, including tokens that
+ * look like this CLI's own flags; extracting it first keeps such a value from
+ * confusing `resolveBuild`. An absent flag reads as null; a flag with no value
+ * reads as `missing`, which `--invoked` takes as no explicit ask and `--run`
+ * as a run with nothing after the verb.
  */
-function takeInvoked(args) {
-    const i = args.indexOf('--invoked');
+function takeRaw(args, flag, missing) {
+    const i = args.indexOf(flag);
     if (i === -1)
-        return { invoked: null, rest: args };
-    return { invoked: args[i + 1] ?? null, rest: [...args.slice(0, i), ...args.slice(i + 2)] };
+        return { raw: null, rest: args };
+    return { raw: args[i + 1] ?? missing, rest: [...args.slice(0, i), ...args.slice(i + 2)] };
+}
+/**
+ * A grant as the GRANT file holds it in its normal form, or null for none:
+ * the text the run header holds against the grant a run would mint.
+ */
+function grantText(grant) {
+    if (grant === null)
+        return null;
+    if (grant.kind === 'auto')
+        return 'auto';
+    return grant.kind === 'steps' ? `steps ${normalizeStepList(grant.steps)}` : `range ${grant.ceiling}`;
 }
 /**
  * Print the orientation dashboard for the active build, plus its harness bindings.
@@ -46,6 +64,10 @@ function takeInvoked(args) {
  * `/plumbbob:build` skill passes its own invocation through), an explicit step
  * number in the raw text repoints the dashboard's marker, detail, and next
  * move at that step, so the injected state never contradicts the human's ask.
+ * With `--run "<raw args>"` (how the `/plumbbob:run` skill passes its own),
+ * the dashboard prints beneath a header naming the run the text resolves to
+ * and the grant the turn hook minted, or carries the refusal in its pointer
+ * when the run names nothing it can walk.
  */
 export function status(cwd, args = []) {
     const root = findRepoRoot(cwd);
@@ -53,7 +75,8 @@ export function status(cwd, args = []) {
         process.stdout.write('NO ACTIVE SESSION\n');
         return 0;
     }
-    const { invoked, rest } = takeInvoked(args);
+    const { raw: run, rest: afterRun } = takeRaw(args, '--run', '');
+    const { raw: invoked, rest } = takeRaw(afterRun, '--invoked', null);
     // A session with builds but no resolvable cursor (finish cleared it, or the repo
     // holds several builds and none is active) has no single dashboard to show, so
     // list the builds and point at `use` instead of rendering a broken, empty one.
@@ -73,19 +96,43 @@ export function status(cwd, args = []) {
     // checkpoint still surfaces. No ledger yet ⇒ nothing to reconcile against ⇒ 0.
     const checkpoints = readOr(checkpointsPath(root, slug));
     const anchor = lastLedgerSha(checkpoints);
-    const orientation = orient({
-        intent: readOr(intentPath(root, slug)),
+    const intent = readOr(intentPath(root, slug));
+    // The stop card still waiting, read once: the dashboard marks its range and
+    // names it as the move, and the run header's waiting line names it too.
+    const card = waitingCard(root, slug, intent);
+    const input = {
+        intent,
         buildLog: readOr(buildLogPath(root, slug)),
         checkpoints,
         inFlight: /^\d+$/.test(inFlightRaw) ? Number(inFlightRaw) : null,
         spiking: inSpike(root, slug),
         requested: parseRequestedStep(invoked),
         outOfBand: anchor === null ? 0 : commitsSince(root, anchor, PLAN_COMMIT_MARKER),
-    });
-    const lines = [formatOrientation(orientation), ...harnessSection(root, slug)];
+        waiting: card?.range ?? null,
+    };
+    const dashboard = run === null
+        ? formatOrientation(orient(input))
+        : withWaiting(formatRunDashboard(input, resolveRunArgs(run, input), grantText(readGrant(root))), card);
+    const lines = [dashboard, ...harnessSection(root, slug)];
     process.stdout.write(`${lines.join('\n')}\n`);
     return 0;
 }
+/**
+ * The run dashboard with the waiting line beneath the run header's grant line,
+ * the header's fourth line, naming the stop card still waiting for its reply
+ * (`range 3 of 5's stop card, recorded before the run`). With no card waiting,
+ * or no header (a run that refuses has no grant line to ride), the dashboard
+ * is returned as it is.
+ */
+function withWaiting(dashboard, card) {
+    const lines = dashboard.split('\n');
+    const grant = lines.findIndex((l) => l.startsWith('     grant: '));
+    if (card === null || grant === -1) {
+        return dashboard;
+    }
+    lines.splice(grant + 1, 0, `     waiting: range ${card.range} of ${card.count}'s stop card, recorded before the run`);
+    return lines.join('\n');
+}
 /**
  * The active build's harness bindings: the agents bound to each slot, per
  * `defaults` and per step.