plumbbob 0.10.3 → 0.11.0

package/dist/lib/orient.js

@@ -3,21 +3,23 @@
 // one suggested next move. Pure and best-effort by design: it takes raw file
 // contents (no fs), and a malformed document degrades to fewer fields rather
 // than throwing.
-import { parseStepSeam } from "./intent.js";
+import { parseStepSeam, scopeDrift } from "./intent.js";
 /**
- * The lines of a named `## Section`, from its heading to the next `## ` (or EOF).
+ * The lines of a named `## Section`, from its heading to the next `## ` (or
+ * EOF), with the offset of the first line so a caller can name an absolute
+ * line number in the document rather than one relative to the section.
  */
 function sectionLines(content, heading) {
     const lines = content.split('\n');
     const start = lines.findIndex((l) => l.trim() === heading);
     if (start === -1) {
-        return [];
+        return { offset: 0, lines: [] };
     }
     let end = lines.findIndex((l, i) => i > start && l.startsWith('## '));
     if (end === -1) {
         end = lines.length;
     }
-    return lines.slice(start + 1, end);
+    return { offset: start + 1, lines: lines.slice(start + 1, end) };
 }
 /**
  * The build title: the first `# ` heading in intent.md, or null when absent.
@@ -42,7 +44,7 @@ export function parseTitle(intent) {
  * narrative roadmap prose lives in its own section and never lands here.
  */
 export function parseSteps(intent) {
-    const lines = sectionLines(intent, '## Steps');
+    const { offset, lines } = sectionLines(intent, '## Steps');
     const starts = [];
     lines.forEach((line, idx) => {
         const m = /^(\d+)\.\s+\[([ xX])\]\s+(.*)$/.exec(line);
@@ -65,7 +67,7 @@ export function parseSteps(intent) {
         const doneWhen = dw ? (dw[1] ?? '').trim() : null;
         const md = /^\s*-\s*model:\s*(.+)$/im.exec(block);
         const model = md ? (md[1] ?? '').trim() : null;
-        return { n: s.n, done: s.done, title: s.title, planned: /done when/i.test(block), doneWhen, model };
+        return { n: s.n, done: s.done, title: s.title, planned: /done when/i.test(block), doneWhen, model, line: offset + s.idx + 1 };
     });
 }
 /**
@@ -110,7 +112,7 @@ export function markStepDone(intent, n) {
  */
 export function parseOpenQuestions(intent) {
     const opener = /^-\s+(?:<a id="[^"]*"><\/a>\s*)?\*{0,2}Q\d+(?: \([^)]+\))?\*{0,2}:\s*(.*)$/;
-    return sectionLines(intent, '## Open questions').filter((l) => {
+    return sectionLines(intent, '## Open questions').lines.filter((l) => {
         const body = opener.exec(l.trim())?.[1];
         return body !== undefined && !/\bresolved\b/i.test(l) && !/^<[^>]*>/.test(body);
     }).length;
@@ -124,7 +126,18 @@ export function parseOpenQuestions(intent) {
  * never match.
  */
 export function parseParked(buildLog) {
-    return sectionLines(buildLog, '## Park list').filter((l) => /^-\s+\[ \]\s+\S/.test(l.trim())).length;
+    return sectionLines(buildLog, '## Park list').lines.filter((l) => /^-\s+\[ \]\s+\S/.test(l.trim())).length;
+}
+/**
+ * Count the constraints declared under `## Constraints`: the section's
+ * top-level list items, in whatever anchored or glossed form they are written.
+ *
+ * This is the readout's denominator for the constraints row. A constraint
+ * always applies (that is what makes it one), so the count is the CLI's to read
+ * rather than the model's to attest.
+ */
+export function parseConstraintCount(intent) {
+    return sectionLines(intent, '## Constraints').lines.filter((l) => /^-\s+\S/.test(l)).length;
 }
 /**
  * The last `step N <sha>` line in the checkpoints ledger, or null when no step
@@ -267,6 +280,422 @@ export function orient(input) {
         outOfBand: input.outOfBand,
     };
 }
+/** The recap's five measuring rows, in the fixed order the fold walks them. */
+const RECAP_ROW_NAMES = ['check', 'done-when', 'decisions', 'constraints', 'seam'];
+/**
+ * Classify one recap row's value by its leading word, per the closed vocabulary
+ * in docs/presentation.md's row table. Null when the value opens with none of
+ * the words the row's kind allows (an unparseable row is simply absent from
+ * the fold, the same as a row that never rode the recap at all).
+ */
+function classifyRecapRow(name, value) {
+    const v = value.trim();
+    const test = (re, verdict) => {
+        const m = re.exec(v);
+        return m === null ? null : { verdict, word: m[0] };
+    };
+    switch (name) {
+        case 'check':
+            return test(/^green\b/, 'true') ?? test(/^red\b/, 'failing') ?? test(/^error\b/, 'failing');
+        case 'done-when':
+            return test(/^met\b/, 'true') ?? test(/^not met\b/, 'failing') ?? test(/^drift\b/, 'drift');
+        case 'decisions':
+            return (test(/^honored\b/, 'true') ??
+                test(/^\d+ of \d+ honored\b/, 'true') ??
+                test(/^none exercised\b/, 'true') ??
+                test(/^bent\b/, 'failing') ??
+                test(/^drift\b/, 'drift'));
+        case 'constraints':
+            return (test(/^all honored\b/, 'true') ??
+                test(/^\d+ of \d+ honored\b/, 'true') ??
+                test(/^bent\b/, 'failing') ??
+                test(/^drift\b/, 'drift'));
+        case 'seam':
+            return test(/^held\b/, 'true') ?? test(/^strayed\b/, 'failing') ?? test(/^drift\b/, 'drift');
+    }
+}
+/**
+ * Parse the fenced recap the model writes into `.plumbbob/detail.md`: the
+ * `── recap · step N of M ──` header, the (subset of) five measuring rows
+ * present, and the free-text diff row. Null when no header is found.
+ *
+ * A row absent from the block is simply missing from `rows`: a vanished row
+ * the fold treats exactly like one that never applied, never like a failure.
+ * An indented `- ` or `→ ` line attaches to the row above it, which is how a
+ * row carrying two or more items, or a pointer at its evidence, survives the
+ * round trip through the file.
+ */
+export function parseRecap(detail) {
+    const lines = detail.split('\n');
+    const headerIdx = lines.findIndex((l) => /^──\s*recap\s*·\s*step\s+\d+\s+of\s+\d+\s*──$/.test(l.trim()));
+    if (headerIdx === -1) {
+        return null;
+    }
+    const header = /step\s+(\d+)\s+of\s+(\d+)/.exec(lines[headerIdx] ?? '');
+    if (header === null) {
+        return null;
+    }
+    const rows = {};
+    let diff = null;
+    let last = null;
+    for (let i = headerIdx + 1; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        if (line.trim().length === 0) {
+            break; // the fence is one contiguous block; a blank line ends it
+        }
+        const carried = /^\s+([-→])\s+(\S.*)$/.exec(line);
+        const open = last === null ? undefined : rows[last];
+        if (carried !== null) {
+            if (last !== null && open !== undefined) {
+                const item = (carried[2] ?? '').trim();
+                rows[last] = carried[1] === '→' ? { ...open, pointer: item } : { ...open, items: [...(open.items ?? []), item] };
+            }
+            continue;
+        }
+        const m = /^(\S[\w-]*)\s+(.+)$/.exec(line);
+        if (m === null) {
+            continue;
+        }
+        const label = m[1] ?? '';
+        const value = (m[2] ?? '').trim();
+        last = null;
+        if (label === 'diff') {
+            diff = value;
+        }
+        else if (RECAP_ROW_NAMES.includes(label)) {
+            const classified = classifyRecapRow(label, value);
+            if (classified !== null) {
+                rows[label] = { ...classified, evidence: value };
+                last = label;
+            }
+        }
+    }
+    return { step: Number(header[1]), total: Number(header[2]), rows, diff };
+}
+const PLUMB = { glyph: '●', state: 'Plumb' };
+const A_HAIR_OFF = { glyph: '◐', state: 'A hair off' };
+const OUT_OF_PLUMB = { glyph: '○', state: 'Out of plumb' };
+const NOT_STANDING = { glyph: '✗', state: 'Not standing' };
+/**
+ * Fold the recap's measuring rows worst-of with the step's accrued stats:
+ * drift beats a live failure beats an advisory beats plumb, and each rung
+ * names the one component that earned it. The advisory rung runs in a fixed
+ * order, the seam stray first.
+ */
+export function foldVerdict(rows, stats) {
+    for (const name of RECAP_ROW_NAMES) {
+        if (rows[name]?.verdict === 'drift') {
+            return { ladder: NOT_STANDING, worst: `${name} drifted` };
+        }
+    }
+    for (const name of RECAP_ROW_NAMES) {
+        const row = rows[name];
+        if (row !== undefined && row.verdict === 'failing') {
+            return { ladder: OUT_OF_PLUMB, worst: `${name} ${row.word}` };
+        }
+    }
+    if (stats.driftWarnings > 0) {
+        // First of the advisory rung, and uncounted: the stat bumps once per
+        // checkpoint rather than once per stray path, and this is the one advisory
+        // that asks a question of the plan rather than of the work.
+        return { ladder: A_HAIR_OFF, worst: 'staged outside the seam' };
+    }
+    if (stats.redChecks > 0) {
+        return { ladder: A_HAIR_OFF, worst: `${stats.redChecks} red run${stats.redChecks === 1 ? '' : 's'} before green` };
+    }
+    if (stats.reverts > 0) {
+        return { ladder: A_HAIR_OFF, worst: `${stats.reverts} revert${stats.reverts === 1 ? '' : 's'} on this step` };
+    }
+    if (stats.outOfBand > 0) {
+        return { ladder: A_HAIR_OFF, worst: `${stats.outOfBand} commit${stats.outOfBand === 1 ? '' : 's'} outside the ledger` };
+    }
+    return { ladder: PLUMB, worst: null };
+}
+// --- The assembled readout: the CLI-computed rows and the fence they ride in
+// (docs/presentation.md). `handoff` measures (the check summary, the numstat,
+// the seam file, the stats receipt) and this section turns each measurement
+// into its row, every value cut to the 67 columns the 13-character label pad
+// leaves inside the 80-column fence. ---
+/** The label pad: readout values start at column 14, so a value gets 67 of the 80. */
+const RECAP_VALUE_BUDGET = 67;
+/** The continuation indent: a row's `- ` items and its `→ ` pointer align under the value column. */
+const RECAP_INDENT = ' '.repeat(13);
+/** Where a red check row points when no single slot owns the failure. */
+const CHECK_SUMMARY = '.check/summary.json';
+/**
+ * The measured check row from the last run's summary: the verdict word and a
+ * count that sizes the gate. A narrowed run records its deselected slots as
+ * skipped entries and the row names them behind the separator, degrading to
+ * their count when the names overflow the value budget.
+ *
+ * Red expands where green collapses: one failing slot is named in the row and
+ * its raw output is the `→` pointer, and two or more collapse to a count with
+ * one `- ` line per slot.
+ */
+export function summaryCheckRow(summary) {
+    const ran = summary.checks.filter((c) => c.skipped !== true);
+    const skipped = summary.checks.filter((c) => c.skipped === true).map((c) => c.name);
+    const named = skipped.length === 0 ? '' : ` · without ${skipped.join(', ')}`;
+    const counted = skipped.length === 0 ? '' : ` · without ${skipped.length} others`;
+    const fit = (long, short) => (long.length <= RECAP_VALUE_BUDGET ? long : short);
+    if (summary.ok) {
+        const size = `${ran.length} of ${summary.checks.length} checks`;
+        return { verdict: 'true', word: 'green', evidence: fit(`green: ${size}${named}`, `green: ${size}${counted}`) };
+    }
+    const failing = ran.filter((c) => !c.ok);
+    const first = failing[0];
+    if (failing.length > 1) {
+        return {
+            verdict: 'failing',
+            word: 'red',
+            evidence: `red: ${failing.length} of ${ran.length} checks failing`,
+            items: failing.map((c) => c.name),
+            pointer: CHECK_SUMMARY,
+        };
+    }
+    if (first !== undefined) {
+        return {
+            verdict: 'failing',
+            word: 'red',
+            evidence: fit(`red: ${first.name} failing${named}`, `red: ${first.name} failing`),
+            pointer: first.output_file == null ? CHECK_SUMMARY : `.check/${first.output_file}`,
+        };
+    }
+    return { verdict: 'failing', word: 'red', evidence: fit(`red${named}`, 'red'), pointer: CHECK_SUMMARY };
+}
+/**
+ * The measured seam row: the changed work-plane paths against the step's seam
+ * tokens. Null when there is no seam to measure against or nothing changed
+ * (the row then vanishes, or the model's attested row stands).
+ *
+ * Green sizes the declared seam: how many of its tokens the diff actually
+ * touched, and that nothing landed outside them. Red states the size of the
+ * problem and lets the paths themselves be the evidence: one stray is the `→`
+ * pointer, and several break onto `- ` lines. `paths` are work-plane changes,
+ * artifacts already filtered by the caller.
+ */
+export function seamRowFromDiff(paths, seam) {
+    if (seam.length === 0 || paths.length === 0) {
+        return null;
+    }
+    const outside = scopeDrift(paths, seam);
+    if (outside.length === 0) {
+        const touched = seam.filter((token) => paths.some((p) => scopeDrift([p], [token]).length === 0)).length;
+        return { verdict: 'true', word: 'held', evidence: `held: ${touched} of ${seam.length} declared, no strays` };
+    }
+    const evidence = `strayed: ${outside.length} path${outside.length === 1 ? '' : 's'} outside the seam`;
+    const only = outside[0];
+    return outside.length === 1 && only !== undefined
+        ? { verdict: 'failing', word: 'strayed', evidence, pointer: only }
+        : { verdict: 'failing', word: 'strayed', evidence, items: outside };
+}
+/**
+ * Sum numstat entries into the diff row's three counts.
+ */
+export function countDiff(entries) {
+    return {
+        added: entries.reduce((sum, e) => sum + e.added, 0),
+        removed: entries.reduce((sum, e) => sum + e.removed, 0),
+        files: entries.length,
+    };
+}
+/**
+ * The diff row's value: `+<added> -<removed> across <N> files`, plus the
+ * `inline below` pointer when the patch rides the turn. Null when nothing
+ * changed: information only, and no change is no information.
+ */
+export function diffRowValue(counts, inline) {
+    if (counts.files === 0) {
+        return null;
+    }
+    const files = `${counts.files} file${counts.files === 1 ? '' : 's'}`;
+    return `+${counts.added} -${counts.removed} across ${files}${inline ? ' · inline below' : ''}`;
+}
+/**
+ * The `spent` row's value: what the step has consumed, read from what
+ * stats.json and the turn ledger already hold. Null when nothing is countable
+ * yet, which vanishes the row on a fresh session rather than printing zeroes.
+ *
+ * Tokens and cost stay out: the transcript is host-specific and a price table
+ * goes stale, while every fact here is on disk already.
+ */
+export function spentRowValue(input) {
+    const parts = [];
+    const elapsed = elapsedSpent(input);
+    if (elapsed !== null) {
+        parts.push(elapsed);
+    }
+    if (input.turns !== null && input.turns > 0) {
+        parts.push(`${input.turns} turn${input.turns === 1 ? '' : 's'}`);
+    }
+    if (input.gateMs !== null) {
+        parts.push(`${Math.round(input.gateMs / 1000)}s gate`);
+    }
+    if (input.redChecks > 0) {
+        parts.push(`${input.redChecks} red run${input.redChecks === 1 ? '' : 's'}`);
+    }
+    else if (input.gateMs !== null) {
+        parts.push('green first run');
+    }
+    if (input.driftWarnings > 0) {
+        parts.push(`${input.driftWarnings} drift warning${input.driftWarnings === 1 ? '' : 's'}`);
+    }
+    return parts.length === 0 ? null : parts.join(' · ');
+}
+/**
+ * The elapsed clause: the step's `startedAt` to its `landedAt` at the
+ * boundary, or to now while it is still open. Null when no stamp parses, or
+ * the span runs backwards (a hand-edited receipt), since a negative age is
+ * worse than a missing one.
+ */
+function elapsedSpent(input) {
+    const started = input.startedAt === undefined ? Number.NaN : Date.parse(input.startedAt);
+    if (!Number.isFinite(started)) {
+        return null;
+    }
+    const landed = input.landedAt === undefined ? Number.NaN : Date.parse(input.landedAt);
+    const ms = (Number.isFinite(landed) ? landed : input.now) - started;
+    if (ms < 0) {
+        return null;
+    }
+    if (ms < 60_000) {
+        return `${Math.round(ms / 1000)}s`;
+    }
+    const minutes = Math.round(ms / 60_000);
+    return minutes < 120 ? `${minutes} min` : `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+/**
+ * Collapse a green row to the count that sizes its universe; a failing row
+ * comes back untouched, since red is where a row expands to name its offender.
+ *
+ * `done-when` collapses to its bare word (the Summary above is its evidence),
+ * `decisions` to the tags the model listed, and `constraints` to the number
+ * declared in intent.md, which the CLI counts rather than trusting the model's
+ * arithmetic. The measured rows arrive collapsed already.
+ */
+function collapseRow(name, row, constraints) {
+    if (row.verdict !== 'true') {
+        return row;
+    }
+    switch (name) {
+        case 'done-when':
+            return { ...row, evidence: row.word };
+        case 'decisions': {
+            const tags = new Set(row.evidence.match(/\b[A-Z]\d+\b/g) ?? []);
+            return tags.size === 0 ? row : { ...row, evidence: `${tags.size} of ${tags.size} honored` };
+        }
+        case 'constraints':
+            return constraints === 0 ? row : { ...row, evidence: `${constraints} of ${constraints} honored` };
+        default:
+            return row;
+    }
+}
+/**
+ * The readout fence's inner lines: the measuring rows present, in their fixed
+ * order, then `diff` and `spent`, labels padded so every value starts at
+ * column 14. A row's `- ` items and its `→ ` pointer follow it on indented
+ * continuation lines.
+ *
+ * The step's identity is not in here: the `**Readout**:` label above the fence
+ * carries it, so it renders once. Empty when no row survived, so the caller can
+ * drop the label and the fence together rather than emit an empty instrument.
+ */
+export function recapLines(rows, extras) {
+    const body = [];
+    for (const name of RECAP_ROW_NAMES) {
+        const row = rows[name];
+        if (row === undefined) {
+            continue;
+        }
+        const shown = collapseRow(name, row, extras.constraints);
+        body.push(`${name.padEnd(13)}${shown.evidence}`);
+        for (const item of shown.items ?? []) {
+            body.push(`${RECAP_INDENT}- ${item}`);
+        }
+        if (shown.pointer !== undefined) {
+            body.push(`${RECAP_INDENT}→ ${shown.pointer}`);
+        }
+    }
+    if (extras.diff !== null) {
+        body.push(`${'diff'.padEnd(13)}${extras.diff}`);
+    }
+    if (extras.spent !== null) {
+        body.push(`${'spent'.padEnd(13)}${extras.spent}`);
+    }
+    return body;
+}
+// --- The detail file's prose: the Summary that opens a decision turn and the
+// recommendation that closes it (docs/presentation.md). The model writes both
+// into `.plumbbob/detail.md` and handoff renders them, so the whole turn is one
+// relayed block and the model authors nothing in the chat. ---
+/**
+ * A named section's prose from `.plumbbob/detail.md`, unwrapped: the lines
+ * inside a paragraph join into one and blank lines keep their paragraph
+ * breaks. Null when the section is absent or holds nothing.
+ *
+ * The turn's prose flows at the renderer's width, so whatever column the
+ * detail file happened to be hard-wrapped to never reaches the turn. The
+ * headings are matched case-insensitively: a file written the older lowercase
+ * way still parses.
+ */
+function sectionProse(detail, heading) {
+    const lines = detail.split('\n');
+    const start = lines.findIndex((l) => heading.test(l.trim()));
+    if (start === -1) {
+        return null;
+    }
+    let end = lines.findIndex((l, i) => i > start && l.startsWith('## '));
+    if (end === -1) {
+        end = lines.length;
+    }
+    const text = lines
+        .slice(start + 1, end)
+        .join('\n')
+        .trim();
+    if (text.length === 0) {
+        return null;
+    }
+    return text
+        .split(/\n{2,}/)
+        .map((paragraph) => paragraph
+        .split('\n')
+        .map((l) => l.trim())
+        .join(' '))
+        .join('\n\n');
+}
+/**
+ * The `## Summary` section of `.plumbbob/detail.md` and the numbered detail
+ * sections beneath it: the lead prose, then the title of every `## <n>`
+ * heading in the order the model wrote them. Null when the file carries no
+ * lead, which vanishes the block rather than labeling nothing.
+ *
+ * The titles pass through as the markdown the model wrote; they are the
+ * highlights, and their numbers are the handles `expand` binds to, so each
+ * renders under its own number rather than being renumbered by position.
+ */
+export function parseSummary(detail) {
+    const lead = sectionProse(detail, /^##\s+summary\s*$/i);
+    if (lead === null) {
+        return null;
+    }
+    const highlights = [];
+    for (const line of detail.split('\n')) {
+        const m = /^##\s+(\d+)\s+(\S.*?)\s*$/.exec(line);
+        if (m !== null) {
+            highlights.push({ n: Number(m[1]), title: m[2] ?? '' });
+        }
+    }
+    return { lead, highlights };
+}
+/**
+ * The `## Recommendation` section of `.plumbbob/detail.md`: the one or two
+ * plain sentences a decision turn ends on, or null when the model wrote none.
+ * `handoff` emits it after the card, unfenced; the eye lands on the last text,
+ * and the last text should say which move the model would take.
+ */
+export function parseRecommendation(detail) {
+    return sectionProse(detail, /^##\s+recommendation\s*$/i);
+}
 /**
  * Render an Orientation as the plain-text dashboard `status` prints.
  */

package/dist/lib/sidecar.js

@@ -319,6 +319,29 @@ export function appendHandoff(root, slug, entry) {
 export function clearHandoff(root, slug) {
     rmSync(handoffPath(root, slug), { force: true });
 }
+// --- The detail plane: `.plumbbob/detail.md`, one flat per-session file holding
+// the in-flight step's full detail. The model overwrites it before every pause
+// (the recap first, then numbered sections matching the highlights); checkpoint
+// folds it into the commit body and then clears it, so the durable archive is
+// the commit and no stale detail piles up. Flat like STATE/TURN, not per-build:
+// a session drives one build at a time, and a past step's expansion reads the
+// commit, never this file. ---
+/**
+ * detail.md: the in-flight step's full detail, at the flat sidecar root.
+ */
+export function detailPath(root) {
+    return join(root, DIRNAME, 'detail.md');
+}
+/**
+ * Clear detail.md once checkpoint has folded it into the commit body; absent is
+ * a no-op.
+ *
+ * The rmSync lives here with the sidecar's other deletions, the same home
+ * clearHandoff and clearTick keep.
+ */
+export function clearDetail(root) {
+    rmSync(detailPath(root), { force: true });
+}
 /**
  * stats.json: the per-build stats receipt, beside checkpoints.
  */
@@ -576,6 +599,11 @@ export function excludeControl(root) {
         // never writes, and never commits.
         `${DIRNAME}/TURN`,
         `${DIRNAME}/GRANT`,
+        // The in-flight step's detail file: flat per-session control the model
+        // overwrites before every pause. checkpoint folds it into the commit body
+        // and then clears it, so its archive is the commit, never a tracked path;
+        // excluding it keeps stageAll from ever sweeping it into a step commit.
+        `${DIRNAME}/detail.md`,
         `${DIRNAME}/builds/*/STEP`,
         `${DIRNAME}/builds/*/SEAM`,
         `${DIRNAME}/builds/*/SPIKE`,

package/dist/verbs/abandon.js

@@ -19,6 +19,8 @@ import { bumpStepStat, buildLogPath, clearHandoff, clearSeam, clearStep, clearTi
 import { checkLatch } from "../lib/latch.js";
 import { abandonLogLine, appendToSection } from "../lib/buildlog.js";
 import { parseSteps } from "../lib/orient.js";
+import { ending, notice, transition } from "../lib/notice.js";
+import { driverPointer } from "./handoff.js";
 /**
  * Drop the in-flight step while keeping its work: latch, clear the markers,
  * record the event, and return to the boundary.
@@ -29,13 +31,13 @@ import { parseSteps } from "../lib/orient.js";
 export function abandon(cwd, args) {
     const root = findRepoRoot(cwd);
     if (root === null || !hasSession(root)) {
-        process.stderr.write('plumbbob: no active session. Run `plumbbob start "<title>"` first.\n');
+        process.stderr.write(notice({ fact: 'no active session', remedy: 'plumbbob start "<title>"' }));
         return 1;
     }
     const { build: slug } = resolveBuild(root, args);
     const step = readInFlightStep(root, slug);
     if (step === null) {
-        process.stderr.write('plumbbob: no step in flight to abandon. abandon drops an in-flight step; from the boundary there is nothing to drop.\n');
+        process.stderr.write(notice({ fact: 'no step in flight to abandon', detail: ['abandon drops an in-flight step'] }));
         return 1;
     }
     // The same latch checkpoint runs, keyed on this step: a step exit is a boundary
@@ -55,7 +57,16 @@ export function abandon(cwd, args) {
     clearHandoff(root, slug);
     bumpStepStat(root, slug, step, 'abandons');
     logAbandon(root, slug, step);
-    process.stdout.write(`plumbbob: step ${step} abandoned — work kept in the tree, back at the boundary. The step stays planned.\n`);
+    // A step exit: with the step back at `[ ]` and its markers gone, the pointer
+    // aims forward from the boundary, at the very step just dropped.
+    process.stdout.write(ending({
+        lead: transition({
+            label: 'Abandoned',
+            fact: `Step ${step}`,
+            detail: ['work kept in the tree', 'the step stays planned'],
+        }),
+        pointer: driverPointer(root, slug),
+    }));
     return 0;
 }
 /**
@@ -68,12 +79,18 @@ export function abandon(cwd, args) {
  */
 function abandonPause(reason, step) {
     if (reason === 'ceiling') {
-        return `plumbbob: abandon refused — step ${step} is past the range you granted; pause here, then run it again to continue.\n`;
+        return notice({
+            fact: 'abandon refused',
+            detail: [`step ${step} is past the range you granted`],
+            remedy: 'pause here, then run it again to continue',
+        });
     }
-    return `plumbbob: abandon refused — no human turn since this step began. A step exit crosses the same
-boundary as a checkpoint, so abandon honors the same pause: end the turn, and the human's approval on
-their next turn is what lets it land. (An explicit \`/plumbbob:build --auto\` or a step range in the
-human's own prompt is the only self-approval.)
+    // The fact rides the register; the paragraph under it stays, because the
+    // pause affordance is an explanation, not a one-liner, and it mirrors the
+    // one the checkpoint latch prints.
+    return `${notice({ fact: 'abandon refused', detail: ['no human turn since this step began'] })}A step exit crosses the same boundary as a checkpoint, so abandon honors the same pause: end the
+turn, and the human's approval on their next turn is what lets it land. (An explicit
+\`/plumbbob:build --auto\` or a step range in the human's own prompt is the only self-approval.)
 `;
 }
 /**