plumbbob 0.13.3 → 0.13.5

package/.claude-plugin/plugin.json

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

@@ -102,7 +102,7 @@ payoff is [measured, not asserted](#why-not-just), not just claimed. **Guidance
 work, a latch on the record.**
 
 <p align="center">
-  <img src="docs/media/build-record-in-pr.svg" alt="A pull request's file list with the build folder beside the source" width="760">
+  <img src="site/media/build-record.svg" alt="The record in the wall, drawn: the scaffold is down and stacked on the ground, a bench mark is cut into the end stone of every course, and in the open cornerstone lie the rolled plan, tied with the red line, and the ledger, laid into the wall to stay" width="760">
 </p>
 
 ## Install
@@ -150,12 +150,7 @@ In Claude Code, inside any git repo with a clean tree:
    diff, the model supplies only the judgment, and nothing is written around it.
 
    ````markdown
-   **Now**: Step 1 of 3 - feat(limiter): add a token-bucket limiter
-
-   **Summary**: A per-IP token bucket now refuses the 6th attempt inside a minute. (details: [detail.md](.plumbbob/detail.md))
-
-   1. The bucket lives in memory, keyed by IP, refilling on read: five tokens a minute.
-   2. The clock is injected, so the test advances time instead of sleeping on it.
+   **Summary**: A per-IP token bucket now refuses the 6th attempt inside a minute.
 
    **Readout**:
 
@@ -166,22 +161,27 @@ In Claude Code, inside any git repo with a clean tree:
    constraints  1 of 1 honored
    seam         held: 2 of 2 declared, no strays
    diff         +61 -3 across 2 files
+                - src/limiter.ts +38 -3
+                - test/limiter.test.ts +23 -0
    spent        22 min · 2 turns · 41s gate · green first run
    ```
 
-   **Verdict**: ● Plumb
-
-   **Next Up**: Step 2 of 3 - feat(login): wire the limiter into POST /login (model: **Sonnet**, details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28))
-     · range 1 of 2 lands with step 1
-
    **Your Call**:
 
    - `looks good` → I checkpoint Step 1; back to the boundary
    - `expand`, or any question → I show more of what is there; nothing changes, and `show the pause` brings all of this back
-   - anything that reads as direction → I take it as what to change; nothing lands until you approve
+   - anything that reads as direction → I make the change and say what moved; nothing lands until you approve
    - `revert` → I wind the work back to the last checkpoint
 
+   | **Verdict** | ● Plumb |
+   | --- | --- |
+   | Now | Step 1 of 3 - feat(limiter): add a token-bucket limiter |
+   | Next Up | Step 2 of 3 - feat(login): wire the limiter into POST /login (model: **Sonnet**, details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28)) |
+   | Range | 1 of 2 lands with step 1 |
+
    **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.
+
+   [more details](.plumbbob/detail.md)
    ````
 
    ![The pause, drawn: a mechanical hand has set its stone on the line and hovers open and still, while a plumb bob in front comes to rest](site/media/pause.svg)
@@ -192,30 +192,30 @@ 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 line beneath Next Up names the run to type
+   and returns to the boundary, where the Range row beneath Next Up names the run to type
    next and the steps it will land:
 
    ```text
    **Checkpoint**: Step 1 complete (a1b2c3d4e, details: [build-log.md:70](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/build-log.md#L70))
 
-   **Verdict**: ● Plumb
-
-   **Next Up**: Step 2 of 3 - feat(login): wire the limiter into POST /login (model: **Sonnet**, details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28))
-     · range 2 of 2: /plumbbob:run (steps 2-3)
+   | **Verdict** | ● Plumb |
+   | --- | --- |
+   | Next Up | Step 2 of 3 - feat(login): wire the limiter into POST /login (model: **Sonnet**, details: [intent.md:28](.plumbbob/builds/2026-07-03-rate-limit-the-login-endpoint/intent.md#L28)) |
+   | Range | 2 of 2: /plumbbob:run (steps 2-3) |
    ```
 
    ![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)
 
    Ask instead (`expand 2`, or any question) and it shows more of what is there and
-   changes nothing. The answer closes on one line pointing back at the step, not on the
-   whole block again, since you have already read it; say `show the pause` to see the
-   block again. Direct it and it takes that as the fix, and nothing lands until you say
-   `looks good`.
+   changes nothing. Direct it and it makes the change and tells you what moved. Either
+   way the reply is its own, and it closes on one line pointing back at the step, not on
+   the whole block again, since you have already read it; say `show the pause` to see
+   the block again. Nothing lands until you say `looks good`.
 4. **Run again.** Fire `/plumbbob:run` again; re-firing it *is* the clock tick. Range 2
    lands steps 2 and 3, each on a green check with no pause between them, and ends on the
    **stop card**: the range's review (a summary of both steps, a readout measured across
-   them, the Verdict), with every idea parked along the way listed under `Harvested` and
-   a lean proposed for each. One reply settles it: `looks good` records the review and
+   them, the Verdict), with every idea parked along the way in a table under `Harvested`:
+   each park, why it matters, and the lean proposed for it. One reply settles it: `looks good` records the review and
    every lean, and `make P1 a blocker` changes one first. `/plumbbob:build` stays the
    granular move whenever you want it, one step to its pause. Whenever you lose the
    thread, `/plumbbob:status` shows where you are and names the next move.

package/dist/cli-core.js

@@ -87,17 +87,18 @@ const VERBS = [
     },
     {
         name: 'handoff',
-        description: 'print the footer card that ends a turn (pause, boundary, plan, driver, or stop), or a reminder for a pause or a stop already shown',
-        synopsis: ['handoff [<n>] [--full] [--plan] [--driver] [--stop] [--build <slug>]'],
+        description: 'print the footer card that ends a turn (pause, boundary, plan, driver, stop, or harvest), or the one line for a card already shown',
+        synopsis: ['handoff [<n>] [--full] [--plan] [--driver] [--stop] [--harvest] [--build <slug>]'],
         args: [{ name: '<n>', gloss: 'step to report on (default: the in-flight step, else the last checkpointed one)' }],
         flags: [
-            { name: '--full', gloss: 'print the whole pause card, or with --stop the whole stop card, even when it was already shown' },
+            { name: '--full', gloss: 'print the whole pause card or boundary, or with --stop the whole stop card, even when it was already shown' },
             { name: '--plan', gloss: 'render the plan-pause card instead of a step tier' },
             { name: '--driver', gloss: "render a driver turn's pointer back at the open step" },
             { name: '--stop', gloss: "render the stop card for the range the last landing completed, from the range's detail file" },
+            { name: '--harvest', gloss: "render a boundary harvest's lean table and its moves, from a `# Detail · Harvest` detail file" },
             BUILD_FLAG,
         ],
-        notes: "Writes only the detail file (a blank line around each heading), the PAUSE stamp, and with --stop the STOP stamp; refuses (exit 1) with no session, with two of --plan, --driver, and --stop together, and with --stop when a step is in flight, no range that lands its steps just landed, or the detail file is not that range's.",
+        notes: "Writes only the detail file (a blank line around each heading), the PAUSE stamp naming the card shown, and with --stop the STOP stamp; refuses (exit 1) with no session, with two of --plan, --driver, --stop, and --harvest together, with --stop when a step is in flight, no range that lands its steps just landed, or the detail file is not that range's, and with --harvest when the detail file is not a harvest's or no park is open.",
     },
     {
         name: 'check',
@@ -167,7 +168,7 @@ const VERBS = [
         name: 'harvest',
         description: "record a harvest from the detail file, and at a run's stop the range's review",
         synopsis: ['harvest'],
-        notes: "Reads the detail file's `## Harvest` proposals (`- park 6 → tangent: <reason>`), 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; then clears the detail file and the STOP stamp, and commits nothing. Refuses (exit 1) with no session, a detail file that is no range's or harvest's, a range's detail in the turn its stop card printed, one no stop card showed, one whose range is open again, or one whose range a step joined after it landed, and a proposal naming a park the list lacks or a class other than blocker, tangent, or pivot.",
+        notes: "Reads the detail file's `## Harvest` proposals (`- P6 → tangent: <reason>`, with `- title:` and `- why:` lines beneath), 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; then clears the detail file and the STOP stamp, and commits nothing. Refuses (exit 1) with no session, a detail file that is no range's or harvest's, a range's detail in the turn its stop card printed, a range no stop card showed, one whose range is open again, or one whose range a step joined after it landed, and a proposal naming a park the list lacks or a class other than blocker, tangent, or pivot.",
     },
     {
         name: 'spike',

package/dist/lib/notice.js

@@ -11,9 +11,11 @@
 // the edge, and an optional indented arrow line carrying what to do next. One
 // shape, so moving it is one edit rather than a sweep. The pointer at the next
 // step is not a line's job: `handoff` renders one, and the verb prints it as
-// the ending's last part. The formatters are pure string assembly, no fs, no
-// gate; `printEnding` is the one function here that writes, and every ending
-// a verb prints goes through it so the relay check knows what was said.
+// the ending's last part, either as the state table that closes a card or an
+// orientation ending (D111 (state-table)) or as the one labeled line a driver
+// turn ends on. The formatters are pure string assembly, no fs, no gate;
+// `printEnding` is the one function here that writes, and every ending a verb
+// prints goes through it so the relay check knows what was said.
 import { writeRelay } from "./sidecar.js";
 /** The column budget a notice line aims to fit, matching the readout fence. */
 const WIDTH = 80;
@@ -66,15 +68,48 @@ export function advisory(a) {
     return line(`${capitalize(trimFact(a.fact))} ⚠`, a);
 }
 /**
- * Assemble a transition's whole ending: the labeled lead line, the Verdict
- * where one was measured, the advisories, the Stop part where a range landed,
- * and the pointer.
+ * Assemble a transition's whole ending: the labeled lead line, the
+ * advisories, then the state table or the driver's pointer.
  *
  * The order is the type's field order, so a verb composes parts and never a
  * sequence. A part with nothing in it vanishes rather than leaving a gap.
  */
 export function ending(e) {
-    return blocks([e.lead, e.verdict ?? null, ...(e.advisories ?? []), e.stop ?? null, e.pointer ?? null]);
+    return blocks([e.lead, ...(e.advisories ?? []), stateTable(e.state ?? []), e.pointer ?? null]);
+}
+/**
+ * Render the state table: two columns, one row per fact, the first row the
+ * header. '' with no rows, so a caller can pass a table it may not have.
+ *
+ * The header is the fact the human reads first, the Verdict wherever one was
+ * measured, and its label rides bold so it reads as the headline even where a
+ * renderer does not bolden a header row. The rows beneath keep plain labels.
+ * A table rather than labeled lines because these are the facts the human
+ * scans for, and a table is the shape that sets them apart from the prose
+ * around them (D111 (state-table)).
+ *
+ * ```text
+ * | **Verdict** | ● Plumb |
+ * | --- | --- |
+ * | Now | Step 2 of 3 - feat(login): wire the limiter into POST /login |
+ * ```
+ */
+export function stateTable(rows) {
+    const [head, ...body] = rows;
+    if (head === undefined)
+        return '';
+    return [
+        `| **${cell(head.label)}** | ${cell(head.value)} |`,
+        '| --- | --- |',
+        ...body.map((r) => `| ${cell(r.label)} | ${cell(r.value)} |`),
+    ].join('\n');
+}
+/**
+ * A table cell's text: on one line, with every pipe escaped, so a step title
+ * or a park holding one cannot split its row.
+ */
+export function cell(text) {
+    return text.replace(/\s*\n\s*/g, ' ').replace(/\|/g, '\\|').trim();
 }
 /**
  * Stack a turn's parts: one blank line between each, one beneath the last.

package/dist/lib/orient.js

@@ -167,14 +167,14 @@ export function remainingOrder(steps, order, exclude) {
     return byOrder.some((n, i) => n !== byDocument[i]) ? byOrder : [];
 }
 /**
- * The build order as the note's labeled field: `order:`, then the next `cap`
- * step numbers in sequence, the rest folded to a count (`and 2 more`), the way
- * a long detail degrades on every one-liner; '' for an empty order. With no
- * cap, the whole sequence.
+ * The build order as the state table's Order row says it: the next `cap` step
+ * numbers in sequence, the rest folded to a count (`and 2 more`), the way a
+ * long detail degrades on every one-liner; '' for an empty order. With no cap,
+ * the whole sequence.
  *
- * A label, where the phrase once read `build order 7, 8, 5`, because the
- * note's other segments read as labeled fields and a label is how the eye
- * finds one in a line of three (D108 (order-label)).
+ * The label is the row's, `Order`, which is where the note's `order:` field
+ * went when the note became rows (D111 (state-table), revising
+ * D108 (order-label)).
  */
 export function buildOrderPhrase(order, cap) {
     if (order.length === 0) {
@@ -182,7 +182,7 @@ export function buildOrderPhrase(order, cap) {
     }
     const shown = cap === undefined ? order : order.slice(0, cap);
     const rest = order.length - shown.length;
-    return `order: ${shown.join(', ')}${rest > 0 ? ` (and ${rest} more)` : ''}`;
+    return `${shown.join(', ')}${rest > 0 ? ` (and ${rest} more)` : ''}`;
 }
 /**
  * Write `order` as the one numeric line under `## Build order`: in place of
@@ -356,7 +356,7 @@ export function rangeStanding(plan, ordered, step) {
     return {
         count,
         holding,
-        command: flag === null && left.length > 0 ? `/plumbbob:build ${leftExpression(holding, left)}` : null,
+        command: flag === null && left.length > 0 ? `/plumbbob:build ${leftExpression(holding, left.map((s) => s.n))}` : null,
         flag,
         completed: ordered[at]?.done === true && rangeLanded(holding, ordered) ? holding : null,
         drift,
@@ -420,8 +420,7 @@ function stopCardMove(item, count, follow) {
  * with each climbing run folded to a span, a bare range's lone number included.
  */
 function leftExpression(range, left) {
-    const ns = left.map((s) => s.n);
-    return !range.bare && ns.length === 1 ? `${ns[0]}-${ns[0]}` : formatStepList(ns);
+    return !range.bare && left.length === 1 ? `${left[0]}-${left[0]}` : formatStepList(left);
 }
 /** The words for steps no range names: `no range names step 12`, or `steps 11, 12`. */
 function noRangeWords(steps) {
@@ -515,6 +514,344 @@ function stepPhrase(items) {
     const one = items.length === 1 && /^\d+$/.test(items[0] ?? '');
     return { words: `${one ? 'step' : 'steps'} ${items.join(', ')}`, be: one ? 'is' : 'are' };
 }
+// The most ways of placing one tangle's ranges the re-cut tries, counted as
+// the product of each range's stretches. A step moved out of a range splits it
+// in two, so one moved step makes two and three make eight, and an order that
+// scatters past this is a re-cut for the human anyway.
+const ORDER_CAP = 64;
+/**
+ * Re-cut the plan's ranges to follow its build order, and write each command
+ * the re-cut changed into its item.
+ *
+ * The plan comes back as it was, with nothing re-cut, when the order settles
+ * nothing, and when an item's opener does not hold its command where the write
+ * can find it, so a re-cut is written whole or not at all.
+ */
+export function recutPlan(intent) {
+    const plan = parseBuildRanges(intent);
+    const recut = recutRanges(plan, parseOrderedSteps(intent));
+    const written = recut.length === 0 ? null : writeRecut(intent, plan.ranges, recut);
+    return written === null ? { intent, recut: [] } : { intent: written, recut };
+}
+/**
+ * The ranges re-cut so that each holds one stretch of the build order, with
+ * every undone step in one wherever the order settles which.
+ *
+ * Only an open range moves. A landed range takes no step, since its call was
+ * made; a bare range keeps its one step and takes no other, since it builds
+ * that step to its pause; and every range keeps a step of its own, so no stop
+ * is left with nothing to stop on. Where the order interleaves the steps of two
+ * or more ranges, they are re-cut by the fewest steps moved between them, and
+ * left as written when two re-cuts tie or the one would split a range's longest
+ * stretch. A step no range names then joins one by where the order puts it, the
+ * way a moved step does: the range around it, else the one it builds ahead of,
+ * else the one it builds after. Nothing is re-cut when an item does not parse, an
+ * open range names a step the plan lacks, or two open ranges name one undone
+ * step, since which range holds what is the human's call there.
+ */
+function recutRanges(plan, ordered) {
+    const open = plan.ranges.filter((r) => !rangeLanded(r, ordered));
+    const owners = ownership(open, ordered);
+    if (owners === null || plan.malformed.length > 0 || open.some((r) => missingDrift(r, ordered).length > 0)) {
+        return [];
+    }
+    const undone = ordered.filter((s) => !s.done).map((s) => s.n);
+    const placed = new Map(owners);
+    const unsettled = new Set();
+    for (const tangle of tangles(undone.filter((n) => owners.has(n)), owners)) {
+        const moved = fewestMoves(tangle, owners);
+        if (moved === null) {
+            tangle.tangled.forEach((r) => unsettled.add(r));
+        }
+        moved?.forEach((range, n) => placed.set(n, range));
+    }
+    placeUnnamed(undone, placed, unsettled);
+    return open.flatMap((range) => {
+        const was = ordered.filter((s) => hasStep(range.steps, s.n)).map((s) => s.n);
+        const now = ordered.filter((s) => (s.done ? hasStep(range.steps, s.n) : placed.get(s.n) === range)).map((s) => s.n);
+        return was.join() === now.join() ? [] : [{ item: range.item, steps: now }];
+    });
+}
+/**
+ * Each undone step's open range, or null when two open ranges name one undone
+ * step, which no sequence can settle.
+ */
+function ownership(open, ordered) {
+    const owners = new Map();
+    for (const step of ordered.filter((s) => !s.done)) {
+        const named = open.filter((r) => hasStep(r.steps, step.n));
+        if (named.length > 1) {
+            return null;
+        }
+        if (named[0] !== undefined) {
+            owners.set(step.n, named[0]);
+        }
+    }
+    return owners;
+}
+/**
+ * The owned steps' tangles. A range's span runs from its first step in build
+ * order to its last, and ranges whose spans overlap are tangled; a range alone
+ * in its span is already one stretch. Each tangle carries the range on either
+ * side of it as well, since a step at the tangle's edge may join one, and two
+ * tangles that share such a range are one.
+ */
+function tangles(owned, owners) {
+    const cores = spanGroups(owned, owners);
+    const bounds = [];
+    cores.forEach((core, i) => {
+        const last = bounds.at(-1);
+        if (core.ranges.length < 2) {
+            return;
+        }
+        if (last !== undefined && i - 1 <= last.hi) {
+            last.hi = Math.min(i + 1, cores.length - 1);
+        }
+        else {
+            bounds.push({ lo: Math.max(i - 1, 0), hi: Math.min(i + 1, cores.length - 1) });
+        }
+    });
+    return bounds.map(({ lo, hi }) => {
+        const run = cores.slice(lo, hi + 1);
+        return {
+            tangled: run.flatMap((c) => (c.ranges.length > 1 ? c.ranges : [])),
+            ranges: run.flatMap((c) => c.ranges),
+            steps: owned.slice(run[0]?.first ?? 0, (run.at(-1)?.last ?? -1) + 1),
+        };
+    });
+}
+/**
+ * The owned steps grouped by span, in build order: ranges whose spans overlap
+ * share a group, and each group carries where its first step and its last sit.
+ */
+function spanGroups(owned, owners) {
+    const spans = new Map();
+    owned.forEach((n, i) => {
+        const range = owners.get(n);
+        if (range !== undefined) {
+            spans.set(range, { first: spans.get(range)?.first ?? i, last: i });
+        }
+    });
+    const groups = [];
+    for (const [range, span] of [...spans].sort((a, b) => a[1].first - b[1].first)) {
+        const group = groups.at(-1);
+        if (group !== undefined && span.first < group.last) {
+            group.ranges.push(range);
+            group.last = Math.max(group.last, span.last);
+        }
+        else {
+            groups.push({ ranges: [range], first: span.first, last: span.last });
+        }
+    }
+    return groups;
+}
+/**
+ * The tangle re-cut by the fewest steps moved between its ranges, as each
+ * step's range once re-cut; null when no cut keeps every range to its rules,
+ * when two cuts move as few, since the order settles neither, when the one
+ * cut splits a range's longest stretch, since that moves the range's body
+ * rather than a step, or when too many sequences of its ranges are in play.
+ *
+ * The ranges may run in any sequence their stretches allow, and each sequence
+ * is cut the way that keeps the most steps where they were.
+ */
+function fewestMoves(tangle, owners) {
+    const stretches = stretchesOf(tangle.steps, owners);
+    const cuts = (rangeOrders(tangle.ranges, stretches) ?? []).flatMap((order) => cutInOrder(order, tangle.steps, owners) ?? []);
+    const most = Math.max(...cuts.map((c) => c.kept));
+    const best = cuts.filter((c) => c.kept === most);
+    const [only] = best;
+    if (only === undefined || best.length > 1 || only.ways > 1 || !keepsBodies(tangle, stretches, only.placed)) {
+        return null;
+    }
+    return new Map(only.placed);
+}
+/**
+ * Whether a cut keeps each range's body: one of its longest stretches, whole,
+ * so a re-cut moves the steps the order moved and never the bulk of a range.
+ */
+function keepsBodies(tangle, stretches, placed) {
+    return tangle.ranges.every((range) => {
+        const own = stretches.filter((s) => s.range === range);
+        const longest = Math.max(...own.map((s) => s.size));
+        return own.some((s) => s.size === longest && tangle.steps.slice(s.start, s.start + s.size).every((n) => placed.get(n) === range));
+    });
+}
+/**
+ * The sequences a tangle's ranges may run in: each range placed where one of
+ * its stretches sits, so every sequence a cut could take, each once; null when
+ * the stretches would make more than `ORDER_CAP` choices.
+ */
+function rangeOrders(ranges, stretches) {
+    const anchors = ranges.map((range) => stretches.filter((s) => s.range === range));
+    if (anchors.reduce((n, a) => n * a.length, 1) > ORDER_CAP) {
+        return null;
+    }
+    const choices = anchors.reduce((sets, options) => sets.flatMap((set) => options.map((o) => [...set, o])), [[]]);
+    const orders = new Map();
+    for (const choice of choices) {
+        const order = [...choice].sort((a, b) => a.start - b.start).map((s) => s.range);
+        orders.set(order.map((r) => r.item).join(), order);
+    }
+    return [...orders.values()];
+}
+/** A tangle's steps as stretches, each an unbroken run of one range's steps. */
+function stretchesOf(steps, owners) {
+    const runs = [];
+    steps.forEach((n, i) => {
+        const range = owners.get(n);
+        const last = runs.at(-1);
+        if (range !== undefined && last?.range === range && last.start + last.size === i) {
+            last.size += 1;
+        }
+        else if (range !== undefined) {
+            runs.push({ range, start: i, size: 1 });
+        }
+    });
+    return runs;
+}
+/**
+ * A tangle cut in one sequence of its ranges, keeping the most steps in the
+ * range that named them; null when no cut keeps every range to its rules.
+ *
+ * Each range takes one block of the tangle's steps, in the sequence given, and
+ * each block holds a step of its own; a bare range's block is its one step. A
+ * block ends on a step of its own unless a bare range follows it, so a step
+ * moved between two ranges joins the one it builds ahead of, or the one before
+ * when the one ahead is bare, the rule a step no range names joins by. The
+ * search keeps, for each range in turn and each step its block may end at, the
+ * most steps kept, so it costs the ranges times the steps squared.
+ */
+function cutInOrder(order, steps, owners) {
+    const rows = [[{ kept: 0, ways: 1, from: -1 }]];
+    order.forEach((range, j) => {
+        const counts = runningCount(steps, owners, range);
+        const row = [];
+        rows[j]?.forEach((cell, from) => {
+            const prior = order[j - 1];
+            if (cell === undefined || (prior !== undefined && !range.bare && owners.get(steps[from - 1] ?? 0) !== prior)) {
+                return;
+            }
+            for (const block of rangeBlocks(range, counts, from)) {
+                keep(row, block.to, cell, block.kept, from);
+            }
+        });
+        rows.push(row);
+    });
+    const end = rows[order.length]?.[steps.length];
+    return end === undefined ? null : { kept: end.kept, ways: end.ways, placed: walkBack(rows, order, steps) };
+}
+/** How many of a range's own steps sit among a tangle's first `i` steps, for every `i` from none to all. */
+function runningCount(steps, owners, range) {
+    const counts = [0];
+    for (const n of steps) {
+        counts.push((counts.at(-1) ?? 0) + (owners.get(n) === range ? 1 : 0));
+    }
+    return counts;
+}
+/**
+ * The blocks a range can take from a tangle's step `from`: where each ends,
+ * and how many of the range's own steps it keeps. Each keeps one at least, and
+ * a bare range's block is its one step.
+ */
+function rangeBlocks(range, counts, from) {
+    const last = Math.min(range.bare ? from + 1 : Infinity, counts.length - 1);
+    const blocks = [];
+    for (let to = from + 1; to <= last; to += 1) {
+        const kept = (counts[to] ?? 0) - (counts[from] ?? 0);
+        if (kept > 0) {
+            blocks.push({ to, kept });
+        }
+    }
+    return blocks;
+}
+/**
+ * Record a block in the re-cut's search, in place: the cell where it ends keeps
+ * the most steps any way there does, and a second way to as many is a tie.
+ */
+function keep(row, to, prior, kept, from) {
+    const total = prior.kept + kept;
+    const at = row[to];
+    if (at === undefined || total > at.kept) {
+        row[to] = { kept: total, ways: prior.ways, from };
+    }
+    else if (total === at.kept) {
+        row[to] = { ...at, ways: Math.min(2, at.ways + prior.ways) };
+    }
+}
+/** Each step's range along the cut the search kept, read back from the last range's block. */
+function walkBack(rows, order, steps) {
+    const placed = new Map();
+    let to = steps.length;
+    order.forEach((_, i) => {
+        const j = order.length - i;
+        const from = rows[j]?.[to]?.from ?? 0;
+        const range = order[j - 1];
+        if (range !== undefined) {
+            steps.slice(from, to).forEach((n) => placed.set(n, range));
+        }
+        to = from;
+    });
+    return placed;
+}
+/**
+ * Give each run of steps no range names the range the order puts it in, in
+ * place in `placed`, read from the ranges on either side of the run. A run no
+ * range can take stays in none, and the dashboard flags it as before.
+ */
+function placeUnnamed(undone, placed, unsettled) {
+    const named = undone.map((n) => placed.get(n));
+    let start = 0;
+    while (start < undone.length) {
+        let end = start;
+        while (end < undone.length && named[end] === undefined) {
+            end += 1;
+        }
+        const range = end === start ? null : joinRange(named.slice(0, start).findLast((r) => r !== undefined), named[end], unsettled);
+        if (range !== null) {
+            undone.slice(start, end).forEach((n) => placed.set(n, range));
+        }
+        start = Math.max(end, start + 1);
+    }
+}
+/**
+ * The range a run of steps no range names joins, from the ranges on either
+ * side of it in build order: the range around it, else the one it builds ahead
+ * of, else the one it builds after. A bare range takes no other step, and a
+ * range the order left tangled takes none either, since where its stretch runs
+ * is still the human's call.
+ */
+function joinRange(before, after, unsettled) {
+    if ((before !== undefined && unsettled.has(before)) || (after !== undefined && unsettled.has(after))) {
+        return null;
+    }
+    if (before !== undefined && before === after) {
+        return before;
+    }
+    return [after, before].find((r) => r !== undefined && !r.bare) ?? null;
+}
+/**
+ * Write each re-cut range's command into its item's opener: its steps in build
+ * order, a landing range down to one step written `9-9` so it still lands. The
+ * stop, the model, and every other line of the item stay as written. Null when
+ * an opener does not hold its command in its first backticks, so the caller
+ * writes nothing rather than half a re-cut.
+ */
+function writeRecut(intent, ranges, recut) {
+    const lines = intent.split('\n');
+    for (const cut of recut) {
+        const range = ranges.find((r) => r.item === cut.item);
+        const at = (range?.line ?? 0) - 1;
+        const opener = lines[at] ?? '';
+        const quoted = /`([^`]*)`/.exec(opener);
+        if (range === undefined || quoted === null || (quoted[1] ?? '').trim() !== range.command) {
+            return null;
+        }
+        const command = `\`/plumbbob:build ${leftExpression(range, cut.steps)}\``;
+        lines[at] = `${opener.slice(0, quoted.index)}${command}${opener.slice(quoted.index + quoted[0].length)}`;
+    }
+    return lines.join('\n');
+}
 // --- The run: what `/plumbbob:run` names. The turn hook reads it to mint the
 // run's grant, `status --run` to print the run header, and the card to name the
 // run beneath Next Up, so all three read one answer from one plan. ---
@@ -1265,6 +1602,33 @@ export function countDiff(entries) {
         files: entries.length,
     };
 }
+// How many lines the changed files take beneath the diff row before the rest
+// folds to a count: seven named and `and 5 more`, so the list never runs past
+// eight lines.
+const DIFF_FILES_CAP = 8;
+/**
+ * The changed files beneath the diff row, one `<path> +<added> -<removed>`
+ * item per file, in git's path order. A file several commits touched is
+ * counted once, its lines summed. Past eight files the tail folds to a count
+ * (`and 5 more`), never a silent cut, and a path is never shortened: it is the
+ * name the human opens, and a cut one is wrong where a wrapped one is legible
+ * (D113 (short-card)).
+ */
+export function diffFileItems(entries) {
+    const byPath = new Map();
+    for (const e of entries) {
+        const prior = byPath.get(e.path) ?? { added: 0, removed: 0 };
+        byPath.set(e.path, { added: prior.added + e.added, removed: prior.removed + e.removed });
+    }
+    const items = [...byPath.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([path, c]) => `${path} +${c.added} -${c.removed}`);
+    if (items.length <= DIFF_FILES_CAP) {
+        return items;
+    }
+    const shown = items.slice(0, DIFF_FILES_CAP - 1);
+    return [...shown, `and ${items.length - shown.length} more`];
+}
 /**
  * The diff row's value: `+<added> -<removed> across <N> files`, plus the
  * `inline below` pointer when the patch rides the turn. Null when nothing
@@ -1400,6 +1764,9 @@ export function recapLines(rows, extras) {
     }
     if (extras.diff !== null) {
         body.push(`${'diff'.padEnd(13)}${extras.diff}`);
+        for (const item of extras.files ?? []) {
+            body.push(`${RECAP_INDENT}- ${item}`);
+        }
     }
     if (extras.spent !== null) {
         body.push(`${'spent'.padEnd(13)}${extras.spent}`);
@@ -1443,6 +1810,7 @@ export function measureRange(input) {
         steps: stepsRow(held, shas),
         rows,
         diff: rangeDiffValue(landed.flatMap((l) => l.files)),
+        files: diffFileItems(landed.flatMap((l) => l.files).filter((f) => !isArtifactPath(f.path))),
         spent: rangeSpentValue(stats),
         stats: {
             driftWarnings: sum('driftWarnings'),