@vincemakes/kiso-tui-cells 0.23.0 → 0.24.1

package/dist/components.js

@@ -8,7 +8,15 @@
  * lives HERE: every line a component returns must fit the terminal
  * width — the compositor's crash-on-violation invariant backs it up
  * (a component that forgets to fold CRASHES with a diagnostic, never
- * silently truncates — the crash is the contract, not a symptom).
+ * silently truncates — the crash is the contract UNDER TEST; in the
+ * field the row is cut and the fact is said, once, through the notice
+ * channel. DECLARED REVERSAL of "the crash is the contract, not a
+ * symptom" (owner-lane, 2026-09-04): two instances of this class in two
+ * days, one caught by a gate (DC-45) and one by the owner on the first
+ * frame of an ordinary command (DC-48). In a gate the crash is right; in
+ * a human's hands it costs them the composer and the session to save
+ * them a row one column too wide. `KISO_INVARIANTS=throw` is what every
+ * suite here runs under).
  *
  * The fold is SGR-AWARE: a line whose bold/dim span would straddle a
  * fold boundary closes the span at the break and reopens it on the
@@ -118,9 +126,20 @@ export { visibleWidth } from "./width.js";
 export function bodySpacing(prev, rows) {
     if (rows.length === 0 || prev === null || prev.length === 0)
         return rows;
-    if (rows.length > 1 || prev.length > 1)
-        return ["", ...rows];
-    return rows;
+    // R13 D1 — ONE blank between any two elements, whatever their height.
+    //
+    // W11 spaced by height: one-row siblings packed tight, anything
+    // multi-row breathed on both sides. A reader could not tell where the
+    // next blank would fall — and worse, the spacing was a function of a
+    // cell's CURRENT height, so a cell growing from one row to five moved
+    // everything around it. That is the mechanism behind R7a and behind
+    // R12 Round 2's settle shift, both of them "the screen moved under
+    // the reader".
+    //
+    // A constant cannot do that: a live block, its settled form and the
+    // card it becomes are spaced identically BY CONSTRUCTION, which is
+    // exactly what R7a's one-row stand-in was simulating.
+    return ["", ...rows];
 }
 /** The container — vertical concatenation with the W11 formula. No
  *  component decides its own spacing: every blank in the body is the
@@ -212,6 +231,9 @@ export function cellComponent(cell) {
  * the same rule as three thousand short ones.
  */
 const USER_CHIP_ROWS = 12;
+/** R13 D4 — the chip's inner pad: two columns, so its text begins in
+ *  the same column as everything else on the page. */
+const CHIP_PAD = "  ";
 class UserMessage {
     cell;
     constructor(cell) {
@@ -219,7 +241,12 @@ class UserMessage {
     }
     render(W, _ctx) {
         const p = palette();
-        const chipW = Math.max(1, W - 2);
+        // R13 D4 — TWO columns of inner pad, where R2 had one. The chip
+        // keeps its surface (reverse video, one row per folded line, no
+        // pad rows — R12 Round 2's ruling stands); what changes is where
+        // its text STARTS, so the human's words begin in the same column
+        // as the model's (E3) and as a card's rows (E4).
+        const chipW = Math.max(1, W - 2 * CHIP_PAD.length);
         const rows = [];
         // REL-0152-D13: fold only as far as the bound needs. A pasted file
         // has thousands of lines and folding all of them to show twelve is
@@ -264,7 +291,7 @@ class UserMessage {
         // row is two cells per character and pads by cells.
         const inner = chipW;
         for (const row of content) {
-            rows.push(`${p.rv} ${row}${" ".repeat(Math.max(0, inner - displayWidth(row)))} ${p.rvEnd}`);
+            rows.push(`${p.rv}${CHIP_PAD}${row}${" ".repeat(Math.max(0, inner - displayWidth(row)))}${CHIP_PAD}${p.rvEnd}`);
         }
         if (!truncated)
             return rows;
@@ -276,7 +303,16 @@ class UserMessage {
         const shown = rows.length;
         const total = paras.length;
         const more = Math.max(0, total - shown);
-        rows.push(`${p.dim}\u2514 ${more > 0 ? `+${more} more line${more === 1 ? "" : "s"}` : "cut here"} \u00b7 sent in full${p.reset}`);
+        // DC-45: THE NOTICE FOLDS TOO. It was written at a fixed 30 columns
+        // and emitted verbatim at every width, so a paste of thirteen lines
+        // in a terminal narrower than the sentence tripped the compositor's
+        // invariant ① and killed the session. The tiers are TUI2-R1.5 ⑤'s
+        // discipline: `sent in full` is the SEMANTICS — the whole reason
+        // the row exists — so the count gives way before it, and `cutLine`
+        // is the backstop that holds at any width there is.
+        const count = more > 0 ? `+${more} more line${more === 1 ? "" : "s"}` : "cut here";
+        const short = more > 0 ? `+${more}` : "cut";
+        rows.push(cutLine(`${p.dim}\u2514 ${pickTier([`${count} \u00b7 sent in full`, `${short} \u00b7 sent in full`, "sent in full", count], Math.max(1, W - 2))}${p.reset}`, W));
         return rows;
     }
 }
@@ -338,7 +374,27 @@ class ThinkingBlock {
         const text = escapeTerminal(this.cell.text).trim();
         if (text === "")
             return [];
-        const room = Math.max(1, W - 2);
+        // DC-47 — THINKING GOES ONE LEVEL DEEPER THAN PROSE, and the
+        // reason is a law rather than a taste.
+        //
+        // §7.2: the indent is the price of §1.2 — italic and dim are
+        // escape sequences, so a rendered frame with its colour stripped
+        // (a terminal capture, a paste out of the scrollback, a log of
+        // what was drawn) would lose the line between the model's
+        // reasoning and its answer. R13's E3 moved PROSE to column 2,
+        // which is where the thinking already was, so after
+        // `sed 's/\x1b\[[0-9;]*m//g'` the two became the same row.
+        // Measured, not reasoned: both rendered
+        // `"  Weighing the two shapes."` exactly.
+        //
+        // NOT a pipe, though §7.2 used to say so: `thinkingEnd`'s inactive
+        // path writes `foldThinking` — one dim line — so a pipe never sees
+        // a thinking paragraph to confuse with prose.
+        //
+        // So the thinking takes the next column in. It is still the only
+        // carrier that survives a pipe, and it is still one indent step —
+        // what moved is which step, because prose took the one it had.
+        const room = Math.max(1, W - THINK_COL.length);
         const rows = [];
         for (const para of text.split(/\n\s*\n/)) {
             const flat = para.replace(/\s+/g, " ").trim();
@@ -350,7 +406,7 @@ class ThinkingBlock {
             // invariant ①b (a row is one physical row) holds by
             // construction rather than by remembering to split.
             for (const line of foldLine(flat, room))
-                rows.push(`  ${p.dim}${p.italic}${line}${p.italicEnd}${p.reset}`);
+                rows.push(`${THINK_COL}${p.dim}${p.italic}${line}${p.italicEnd}${p.reset}`);
         }
         return rows;
     }
@@ -633,39 +689,10 @@ class ToolExecution {
         const c = this.cell;
         const verb = escapeTerminal(displayVerb(c.name));
         const verbCol = verb.length < 5 ? `${verb}${" ".repeat(5 - verb.length)}` : verb;
-        const parts = c.rolled?.parts;
-        if (c.rolled !== null && parts !== undefined) {
-            // TUI2-R1 (B) — the exploration row: a run that spans more than
-            // one read-only tool. The counts are BOLD (what the reader is
-            // being told), the timing and the affordance dim — the
-            // prototype's placement. The affordance names what the key
-            // SHOWS here ("lists them"), because a group row's expand is a
-            // list of calls, not a body of output.
-            const r = c.rolled;
-            const counts = exploreCounts(parts);
-            const head = `  explored ${p.bold}${counts}${p.reset}`; // R2: no tick
-            const tail = ` (${r.elapsed}s)`;
-            const room = W - visibleWidth(head) - tail.length;
-            const affordance = " · ctrl+o lists them";
-            return [cutLine(`${head}${p.dim}${tail}${affordance.length <= room ? affordance : ""}${p.reset}`, W)];
-        }
-        if (c.rolled !== null) {
-            // W13 — the rolled-up group's ONE row + the target children:
-            // the work order's claimed shape, verbatim — the verbCol's
-            // 5-char pad reproduces the "read  5 files" double space, the
-            // children are the first 3 basename targets, the overflow row
-            // carries the ctrl+o affordance (its "└ … ctrl+o" joins the
-            // W15 expand history — the head's commit captures it).
-            const r = c.rolled;
-            const noun = ROLLUP_NOUN[c.name] ?? "calls";
-            const out = gutterCut("  ", `${verbCol} ${r.count} ${noun} (${kUnit(r.lines)} lines, ${r.elapsed}s)`, W); // R2: no tick
-            const shown = r.targets.slice(0, 3);
-            if (shown.length > 0)
-                out.push(`  ${p.dim}${CUT_ROW}${escapeTerminal(shown.join(" · "))}${p.reset}`);
-            if (r.targets.length > 3)
-                out.push(`  ${p.dim}${CUT_ROW}+${r.targets.length - 3} more — ctrl+o expands${p.reset}`);
-            return out;
-        }
+        // R13 — the W13 rollup row and TUI2-R1 (B)'s exploration row stood
+        // here, ahead of everything else a settled call could be. Both are
+        // retired with the `rolled` field they read (see the compositor's
+        // #foldOrRollup for the reversal in full).
         if (c.state === "done") {
             // R3i phase 5: an answered (or declined) ask_user renders its
             // OWN block — the questions and what the human said. The row
@@ -689,7 +716,7 @@ class ToolExecution {
             if (c.reason !== null) {
                 const by = attribution(c);
                 const out = gutterCut("  ", `${p.red}${escapeTerminal(`${c.name} ${toolTargetOf(c)}`)} (${escapeTerminal(c.reason)}${by})${p.reset}`, W);
-                out.push(...toolBlockBody(c, W));
+                out.push(...toolBlockBody(c, W, ctx));
                 return out;
             }
             const elapsed = c.startedAt !== null && c.doneAt !== null ? ((c.doneAt - c.startedAt) / 1000).toFixed(1) : "?";
@@ -703,8 +730,17 @@ class ToolExecution {
             // "200 of 250 lines", a diff's "+1 -1", a shell's "exit 0" — is a
             // different fact and stays.
             const rawMeta = settledMeta(c);
-            const dup = hiddenLines(c, W) !== null && new RegExp(`^${hiddenLines(c, W)} lines?$`).test(rawMeta);
-            const meta = dup ? "" : escapeTerminal(rawMeta);
+            // VD-6's suppression RETIRED with the thing it was suppressing.
+            // A read card said `(2 lines, 0.0s) · 2 lines · ctrl+o expands`
+            // because the parens and the suffix were written by different
+            // rounds, each unaware the other was counting; the fix blanked
+            // the meta whenever the suffix would repeat it. R13 takes the
+            // count OUT of the suffix, so there is one place again and the
+            // meta is it — blanking it now would drop the fact entirely.
+            // "Stated exactly once" is unchanged and is what `countedHead`
+            // below preserves: a meta that already counts lines gets no
+            // second count beside it.
+            const meta = escapeTerminal(rawMeta);
             // A4: the target rides the settled head row — the verb's
             // summary column (W3's 5-char pad keeps the paths lined up).
             // A5: an extension's auto-approval appends `· approved by
@@ -724,7 +760,9 @@ class ToolExecution {
             // TUI2-R1.5 ⑤: the shortest tier is RESERVED — the affordance is
             // the semantics. TUI2-R1.5 pin 4: and the parts give way in a
             // PINNED ORDER, rather than whichever happened to be last.
-            const text = settledHeadText(verbCol, escapeTerminal(toolTargetOf(c)), meta, approvedBy, elapsed, W - 2 - (hidden === null ? 0 : SUFFIX_MIN));
+            const nAll = countLines(c.resultText);
+            const countedHead = nAll > 0 && !/^\d+( of \d+)? lines?$/.test(rawMeta) ? `${nAll} line${nAll === 1 ? "" : "s"}` : "";
+            const text = settledHeadText(verbCol, escapeTerminal(toolTargetOf(c)), meta, approvedBy, elapsed, W - 2 - (hidden === null ? 0 : SUFFIX_MIN), countedHead);
             // R2 (owner, 2026-08-27): no tick, no cross. A symbol earns its
             // cell by carrying a fact the words do not, and a row that
             // already says `exit 0` does not need one more thing saying it
@@ -732,8 +770,7 @@ class ToolExecution {
             // metadata, in words, which is also the only form that survives
             // a pipe with the colour stripped. A failure keeps its colour
             // AND its words — see settledMeta.
-            const parts = toolBlockParts(c, W);
-            const body = parts.rows;
+            const body = toolBlockParts(c, W, ctx).rows;
             if (body.length > 0 && c.expanded) {
                 // An EXPANDED block is already showing everything, and its own
                 // footer ("ctrl+o collapses") is what closes it. Giving it an
@@ -743,13 +780,13 @@ class ToolExecution {
                 const head = c.isError ? `  ${p.red}${text}${p.reset}` : `  ${text}`;
                 return slabBlock(appendSuffix(head, expandSuffix(hidden, W - visibleWidth(head))), body, null, W);
             }
-            if (parts.output > 0) {
-                // R9 P2 — THE SLAB'S SHAPE. A call with rows on screen is one
-                // object: the head row names it, the output sits inside, and
-                // the outcome CLOSES it on its own line (§7.5's words, moved
-                // off the head row because the head row is no longer the only
-                // row). D6: the target is bold there — the head row's job is
-                // to say WHAT was run, and the metadata has its own row now.
+            if (body.length > 0) {
+                // R13 — THE CARD, when there is something to preview: the head
+                // row names the call, the preview sits inside, and the outcome
+                // CLOSES it on its own line (§7.5's words, moved off the head
+                // row because the head row is no longer the only row). D6: the
+                // target is bold there — the head row's job is to say WHAT was
+                // run, and the metadata has its own row now.
                 //
                 // A failure takes NO tint on the head row (R9): only the
                 // outcome word is coloured, which is §1.2 exactly — the
@@ -767,28 +804,28 @@ class ToolExecution {
                 // what happened and how long it took — is never cut open.
                 const join = (...xs) => xs.filter((x) => x !== "").join(" · ");
                 const attr = approvedBy.replace(/^ · /, "");
-                const words = pickTier([join(meta, counted, `${elapsed}s`, attr), join(meta, counted, `${elapsed}s`), join(meta, `${elapsed}s`), meta], W - visibleWidth(NOTE_ROW));
+                const words = pickTier([join(meta, counted, `${elapsed}s`, attr), join(meta, counted, `${elapsed}s`), join(meta, `${elapsed}s`), meta], W - visibleWidth(noteIndent()));
                 const outcome = c.isError ? `${p.red}${words}${p.reset}` : words;
                 return slabBlock(head, body, outcome, W);
             }
-            // No output on screen: the row is PLAIN, and the outcome stays on
-            // it in the form every width gate already pins.
+            // R13 — nothing to preview: the SAME card, three rows, with the
+            // outcome riding the head row because there is nothing between
+            // them to close.
             //
-            // Owner ruling 2026-09-02, narrowing R9's "one-row slab": §1.6
-            // gives the wash to the machine's VERBATIM text, and a row like
-            // `read loop.ts · 412 lines · 0.1s` is kiso's summary of a result
-            // — not one line of it. A surface with nothing verbatim on it is
-            // a surface making a claim it cannot keep, so the wash appears
-            // only where the call's own output does.
-            const out = c.isError ? [`  ${p.red}${text}${p.reset}`] : [`  ${text}`];
-            out[0] = appendSuffix(out[0], expandSuffix(hidden, W - visibleWidth(out[0])));
-            out.push(...body);
-            return out;
+            // DECLARED REVERSAL of the owner's 2026-09-02 narrowing ("a call
+            // with no output on screen has no slab at all"), which read §1.6
+            // as giving the wash to the machine's VERBATIM text only. The
+            // ruling of 2026-09-03 supersedes it: the surface says WORK, not
+            // VERBATIM, and a page where some calls are cards and others are
+            // loose rows is the instability the owner was pointing at. §1.6
+            // moves with it.
+            const bare = c.isError ? `  ${p.red}${text}${p.reset}` : `  ${text}`;
+            return slabBlock(appendSuffix(bare, expandSuffix(hidden, W - visibleWidth(bare))), [], null, W);
         }
         if (c.state === "approval") {
             // W2: the ❯ is the GUTTER (the left edge), never the line's tail
             const out = gutterCut(`${p.bold}❯${p.reset} `, `${verbCol} ${liveTarget(c)}`, W);
-            out.push(...toolBlockBody(c, W));
+            out.push(...toolBlockBody(c, W, ctx));
             return out;
         }
         if (c.state === "running") {
@@ -809,10 +846,68 @@ class ToolExecution {
             // cannot be predicted: a turning mark implies progress the
             // product does not have. With no ground the breath freezes to a
             // static `●` and says the same thing more quietly.
-            const out = gutterCut(ctx.grouped === true ? "  " : `${breathFrame(ctx.spinnerI)} `, `${verbCol} ${liveTarget(c)}`, Math.max(4, W - dur.length));
-            out[0] = `${out[0]}${p.dim}${dur}${p.reset}`;
-            out.push(...toolBlockBody(c, W));
-            return out;
+            // R13 E2 — A RUNNING CALL IS THE SAME CARD, allocated at the
+            // SETTLED card's height from its first frame. The settle then
+            // changes CONTENT and never position: the spinner becomes two
+            // spaces in the same two columns, the live window gives back
+            // the rows the result did not need, and the metadata row that
+            // said `3s` says `exit 0 · 90 lines · 3.2s`.
+            //
+            // The elapsed moves OFF the head row onto that metadata row,
+            // which is where the settled card keeps it — the head row's job
+            // is to say what is running, and it says the same thing before
+            // and after.
+            //
+            // DC-43: with too little room for the seven-row skeleton (two
+            // pads, the head, two blanks, one preview row and the metadata)
+            // there is no card — the call keeps its head row until it
+            // commits, which is the one form that fits anywhere.
+            const liveRows = ctx.liveWindow ?? CAP_PREVIEW;
+            const gutter = ctx.grouped === true ? "  " : `${breathFrame(ctx.spinnerI)} `;
+            if (liveRows <= 0) {
+                // the degraded form is the head row ALONE, so it keeps the
+                // duration it would otherwise have lost with its card — cut
+                // against the room the duration leaves (VD-4: the duration
+                // is its own segment, never welded to a cut word).
+                const bare = gutterCut(gutter, `${verbCol} ${liveTarget(c)}`, Math.max(4, W - dur.length));
+                return [`${bare[0]}${p.dim}${dur}${p.reset}`];
+            }
+            // DC-46 — the two GESTURES ride the status row, where they cost
+            // nothing. They were a footer INSIDE the window, spending one of
+            // its rows on a sentence that is not output; with the window
+            // grown from its content, that row was the difference between a
+            // settle that swaps content and one that changes height. The
+            // row's shape is the settled outcome row's, so the settle
+            // rewrites it in place: `3s · esc stops` → `exit 0 · 90 lines ·
+            // 3.2s`.
+            const gestures = c.name === "shell" ? " · esc stops · alt+⏎ redirects" : "";
+            const status = pickTier([`${elapsed}s${gestures}`, `${elapsed}s`], Math.max(1, W - visibleWidth(noteIndent())));
+            const live = toolBlockBody(c, W, ctx);
+            if (live.length > 0)
+                return slabBlock(gutterCut(gutter, `${verbCol} ${liveTarget(c)}`, W)[0], live, status, W);
+            // DC-48 — THE THREE-ROW CARD IS ONE ROW, so it is assembled here
+            // against the room it actually has.
+            //
+            // This branch used to cut the head to `W` and hand it to
+            // `slabBlock`, which joins head and outcome and cut nothing —
+            // so the row came out `W` wide PLUS the whole status, and the
+            // compositor did what it promises: it threw. On the owner's
+            // 80-column terminal a long `find` produced a 113-column row on
+            // its FIRST FRAME, which is the first second of every command.
+            //
+            // Pin 4's order: the command is the cuttable span and the
+            // elapsed is never cut open, so the command takes what the
+            // status leaves — the `· ` between them and the two-column
+            // gutter included.
+            // the status takes its own tier against the room the row has, not
+            // against a whole width: on a narrow terminal the gestures give
+            // way so the COMMAND keeps something to say, and the elapsed —
+            // pin 4's core — never does.
+            const MIN_TARGET = 10; // the gutter, the verb column, a character of command
+            const oneRow = pickTier([`${elapsed}s${gestures}`, `${elapsed}s`], Math.max(1, W - MIN_TARGET - 3));
+            const room = Math.max(4, W - visibleWidth(oneRow) - 3);
+            const only = gutterCut(gutter, `${verbCol} ${liveTarget(c)}`, room)[0];
+            return slabBlock(`${only}${p.dim} · ${oneRow}${p.reset}`, [], null, W);
         }
         // W2: ◦ replaces → for QUEUED — · is the separator inside every
         // metadata group; a queued marker that is also the separator
@@ -839,7 +934,7 @@ class ToolExecution {
  * never a cap.
  */
 function hiddenLines(c, W) {
-    if (c.expanded || c.state !== "done" || c.rolled !== null || c.reason !== null)
+    if (c.expanded || c.state !== "done" || c.reason !== null)
         return null;
     if (c.name === "delegate")
         return null; // its body is the one-line summary, always whole
@@ -848,13 +943,14 @@ function hiddenLines(c, W) {
         return null;
     if (c.isError)
         return null; // errorBody's own cut row is the affordance there
-    // R9 P2 / D4: a settled shell has its tail back on screen, and when
-    // the tail is cut the slab's own note row says so and names the key.
+    // R13: a call that PREVIEWS carries the key on its own note row when
+    // something is cut, and needs no affordance at all when nothing is.
     // A head-row suffix as well would be TUI2-R1's two affordances for
-    // one cell — the thing that rule exists to forbid.
-    if (c.name === "shell")
+    // one cell — the thing that rule exists to forbid. read_file is the
+    // one call with no preview (E1), so the key lives on its head row.
+    if (c.name !== "read_file")
         return null;
-    return n; // every other settled call renders NO body — all of it is behind the key
+    return n;
 }
 /**
  * TUI2-R1 (A) — the suffix, in the width that is LEFT.
@@ -900,12 +996,24 @@ const SUFFIX_MIN = " · ctrl+o".length;
  *      compressible thing on the row — a reader recognises a command
  *      from its head — and it is the only part with a natural ellipsis.
  */
-function settledHeadText(verbCol, target, meta, attr, elapsed, room) {
-    const core = `(${meta === "" ? "" : `${meta}, `}${elapsed}s)`;
-    const withAttr = `(${[meta, attr.replace(" · ", "")].filter((x) => x !== "").join(" · ")}${meta === "" && attr === "" ? "" : ", "}${elapsed}s)`;
+function settledHeadText(verbCol, target, meta, attr, elapsed, room, counted = "") {
+    // R13 — ONE GRAMMAR FOR BOTH CARDS. This row used to close with W4's
+    // parentheses — `read  a.ts (0.1s) · 10 lines · ctrl+o expands` —
+    // while the bodied card's outcome row said `exit 0 · 90 lines · 0.4s`
+    // in a `·` chain. Two shapes for the same facts, and which one a call
+    // got depended on whether it happened to have a preview. The chain
+    // wins: it is the one the outcome row already uses, it reads in one
+    // direction, and it puts the elapsed where the other card puts it.
+    //
+    // The giving-way order is pin 4's, unchanged: the ATTRIBUTION drops
+    // first, then the count, and the core — what happened and how long it
+    // took — is never cut open; below that the target itself truncates.
+    const join = (...xs) => xs.filter((x) => x !== "").join(" · ");
+    const core = join(meta, counted, `${elapsed}s`);
+    const withAttr = join(meta, counted, `${elapsed}s`, attr.replace(" · ", ""));
     const lead = `${verbCol} `;
-    const fit = (t, parens) => {
-        const line = `${lead}${t}${parens === "" ? "" : ` ${parens}`}`;
+    const fit = (t, tail) => {
+        const line = `${lead}${t}${tail === "" ? "" : ` · ${tail}`}`;
         return visibleWidth(line) <= room ? line : null;
     };
     // 1. everything
@@ -916,12 +1024,26 @@ function settledHeadText(verbCol, target, meta, attr, elapsed, room) {
     const bare = fit(target, core);
     if (bare !== null)
         return bare;
+    // 2b. the COUNT gives way next (pin 4), where the suffix is not
+    //     already carrying it
+    const short = fit(target, join(meta, `${elapsed}s`));
+    if (short !== null)
+        return short;
     // 3. the target truncates, the core stays whole
-    const budget = room - visibleWidth(lead) - visibleWidth(core) - 2; // the space + the ellipsis
+    const stem = join(meta, `${elapsed}s`);
+    const budget = room - visibleWidth(lead) - visibleWidth(stem) - 4; // the ellipsis + " · "
     if (budget >= 1)
-        return `${lead}${widthCut(target, budget)}… ${core}`;
-    // 4. below that even the core cannot ride: the row is the call's
-    //    identity and its affordance, and no half-open parenthesis.
+        return `${lead}${widthCut(target, budget)}… · ${stem}`;
+    // 4. DC-48 — the ELAPSED still rides, and the target takes what is
+    //    left. This used to return the target alone, on the argument that
+    //    a cut core would leave a half-open parenthesis; R13's chain has
+    //    no bracket to leave open, so the reason retired with the
+    //    parentheses and pin 4's own rule applies at every width: what
+    //    happened and how long it took is never cut away.
+    const floor = `${elapsed}s`;
+    const left = room - visibleWidth(lead) - visibleWidth(floor) - 4; // the ellipsis + " · "
+    if (left >= 1)
+        return `${lead}${widthCut(target, left)}… · ${floor}`;
     return `${lead}${widthCut(target, Math.max(1, room - visibleWidth(lead)))}`;
 }
 /**
@@ -947,8 +1069,13 @@ function attribution(c) {
 export function expandSuffix(lines, room) {
     if (lines === null)
         return "";
-    const count = `${lines} line${lines === 1 ? "" : "s"}`;
-    for (const tier of [` · ${count} · ctrl+o expands`, ` · ${count} · ctrl+o`, " · ctrl+o"]) {
+    // R13 — the COUNT left this suffix for the head row's own `·` chain,
+    // where the bodied card keeps it too (`… · 10 lines · 0.1s`). It was
+    // here because the parenthesised core had nowhere to put it and the
+    // suffix was the only tail the row had; with one grammar for both
+    // cards there is one place, and VD-6's "stated exactly once" is what
+    // forbids leaving a copy behind.
+    for (const tier of [" · ctrl+o expands", " · ctrl+o"]) {
         if (tier.length <= room)
             return tier;
     }
@@ -1051,58 +1178,6 @@ const EXPLORE_NOUN = {
 export function isExploreTool(name) {
     return EXPLORE_NOUN[name] !== undefined;
 }
-/** "8 files · 14 searches" — the per-tool counts in first-call order. */
-export function exploreCounts(parts) {
-    return parts
-        .map((part) => {
-        const [singular, plural] = EXPLORE_NOUN[part.name] ?? ["call", "calls"];
-        // R3h (fable, 2026-08-29): DISTINCT subjects. This counted calls
-        // while exploreRows — the very next function, the expansion of
-        // THIS row — deduped them with `×N`. So the head said "6 files"
-        // over a list showing four, one of them `a.ts ×3`. The head and
-        // the body are two views of one run and must count alike; the
-        // body was right (a file read twice is one file).
-        const n = foldCountsObjects(part.name) ? new Set(part.subjects).size : part.subjects.length;
-        return `${n} ${n === 1 ? singular : plural}`;
-    })
-        .join(" · ");
-}
-/** TUI2-R1 (B) — the expanded list: ONE row per tool, the verb column
- *  then the distinct subjects in first-call order, a repeated subject
- *  carrying its ×count, the first three shown and the rest counted.
- *  A search's subject is its PATTERN (quoted — the thing that was
- *  looked for); a read's or a list's is its path. */
-export function exploreRows(parts, W) {
-    const p = palette();
-    const rows = [];
-    for (const part of parts) {
-        const counts = new Map();
-        for (const s of part.subjects)
-            counts.set(s, (counts.get(s) ?? 0) + 1);
-        const shown = [...counts.entries()].slice(0, 3).map(([s, n]) => (n > 1 ? `${s} ×${n}` : s));
-        const more = counts.size > 3 ? ` (+${counts.size - 3})` : "";
-        const verb = displayVerb(part.name);
-        rows.push(cutLine(`${p.dim}${BODY_ROW}${escapeTerminal(`${verb.padEnd(6)} ${shown.join(" · ")}${more}`)}${p.reset}`, W));
-    }
-    // TUI2-R1.5 ① (VD-15): the footer used to promise "/last shows the full
-    // outputs". /last shows the LAST call only — for a nine-call burst that
-    // is one output out of nine, and a footer that sends the human to a
-    // place the content is not is worse than a footer that says nothing.
-    // R8a: the footer is an in-block note — the same indent, no glyph —
-    // and the corner opens the block's first row, like every other one.
-    rows.push(cutLine(`${p.dim}${NOTE_ROW}${COLLAPSE_ROW}${p.reset}`, W));
-    return openBlock(rows);
-}
-/** The count term with the singular/plural forms — "no reads", "1 read",
- *  "5 reads". The noun's singular drops the plural suffix ("dirs" → "dir",
- *  "matches" → "match"). */
-function countTerm(n, singular, plural) {
-    if (n === 0)
-        return `no ${plural}`;
-    if (n === 1)
-        return `1 ${singular}`;
-    return `${n} ${plural}`;
-}
 /** W14 — the folded-turn line: a whole QUIET turn (no text), once it is
  *  scrollback, becomes ONE line — the work order's claimed shape
  *  (`▞ thought 19s · 5 reads · no edits`), the counts accumulated at
@@ -1340,252 +1415,19 @@ function stretchTerms(t, live) {
         return `${e[tense(name)]} ${n} ${n === 1 ? e[2] : e[3]}`;
     });
 }
-/** R3i — the trouble clause: which call, and what happened, in WORDS.
- *  Law 1.3 says an outcome is stated in words, "the only form that
- *  survives a pipe"; the colour on this clause is emphasis over those
- *  words, never the fact itself. */
-function troubleClause(t) {
-    return t.trouble
-        .filter(([, n]) => n > 0)
-        .map(([kind, n, what]) => (what === "" || kind === "interrupted" ? `${n} ${kind}` : `${n} ${kind}: ${what}`))
-        .join(" · ");
-}
-/**
- * R4 (C1) — the fold NAMES ITS OWN TARGET.
- *
- * `ctrl+o` used to be printed identically on every fold on the screen,
- * and the key walked a ring whose order nothing on screen expressed —
- * so the owner's report was exact: "there is no way to know which
- * stretch it opens". The tint that marks the next target can only be
- * drawn on a LIVE row, and every fold worth reopening is, by
- * construction, in the scrollback where nothing can be tinted.
- *
- * A pointer cannot fix this either, and the bound is worth stating
- * once: SGR mouse reports address the VIEWPORT, so a fold that has
- * scrolled into the terminal's own scrollback is unreachable by any
- * pointer, permanently, on the primary screen. The ordinal is not a
- * cheaper substitute for clicking — it is the form of the affordance
- * that reaches every fold, and it survives a pipe as characters.
- *
- * The number rides the KEY, inside the width ladder, so it is paid for
- * by the same give-way order as every other span (law: the key never
- * gives way — it just got two characters longer).
- */
-export function stretchLine(t, W) {
-    const p = palette();
-    const live = t.phase !== "settled";
-    // DECLARED SUPERSESSION (R6/D3, owner-ruled) — THE STRETCH LINE WEARS
-    // NO MARK, in any phase.
-    //
-    // Law 1.3: a symbol earns its cell by carrying a fact the words do
-    // not. When every settled fold, the live line AND the status row all
-    // wear a star, none of them distinguishes anything — it is the tick
-    // and the cross again (R2 retired those on exactly this ground), at
-    // the stretch scale. design.md §7.4 had already ruled the principle
-    // one scale down: "only the call still running carries a mark,
-    // because only it is moving", with a settled call's mark "(none) —
-    // the outcome is in the words. SETTLED." A settled STRETCH wearing
-    // one contradicted a precedent the file had already ratified.
-    //
-    // Nothing settled is being reversed: §4 lists this mark PROPOSED and
-    // §8 lists it OPEN. This is that proposal's ruling arriving, as a
-    // decline, on the owner's own dogfood.
-    //
-    // The replacement is a two-space INDENT, not a column shift: the row
-    // joins the settled-call family's geometry, the indent survives a
-    // pipe as bytes (prose never starts at column 3), and both forms are
-    // 2 cells so the width ladder below does not reflow. The status row's
-    // twinkle survives as the ONE moving mark; `✦ took` survives as the
-    // turn's seal.
-    //
-    // R7a AMENDS this by ONE case: the live ACTING line takes the
-    // breathing mark, passed in. D3 declined a mark on the SETTLED fold,
-    // where the words already carry the outcome; a line that means "work
-    // is in flight RIGHT NOW" carries a fact its words do not, which is
-    // exactly the test law 1.3 sets. It is also where the mark was
-    // migrating TO: §7.4's "only the call still running carries one" now
-    // applies at the stretch scale, one mark for the activity instead of
-    // one per call. Owner-ruled 2026-08-31, on the ground that a fast
-    // call's per-row mark is gone before the eye lands.
-    const mark = t.mark ?? " ";
-    // R4a (owner ruling, 2026-08-30) — the fold row prints NO key.
-    //
-    // R4 printed `· ctrl+o 3` so the row could name its own target. The
-    // owner's objection is the right one: a number you cannot type is not
-    // a selector, it is decoration that costs a column — and the
-    // reference implementation, checked rather than assumed, prints
-    // nothing on the row either. Its expansion lives in a MODE you enter,
-    // where the pointer can reach every fold including the ones that have
-    // scrolled away; the row itself stays clean.
-    //
-    // So the affordance is retired here and owed to that mode. Until it
-    // exists, `ctrl+o` still opens the most recent fold — it is simply no
-    // longer advertised on a row that cannot say which one it means.
-    const key = "";
-    const lead = t.phase === "thinking" ? [`thinking ${t.thoughtSeconds}s`] : t.phase === "settled" && t.thoughtSeconds > 0 ? [`thought ${t.thoughtSeconds}s`] : [];
-    const clauseText = troubleClause(t);
-    let meta = [...lead, ...(t.phase === "thinking" ? [] : stretchTerms(t, live))].join(" · ");
-    let clause = clauseText === "" ? "" : ` · ${clauseText}`;
-    let words = t.words === undefined || t.words === "" ? "" : ` ${escapeTerminal(t.words).replace(/\s+/g, " ")} `;
-    const width = () => 2 + (words === "" ? 0 : visibleWidth(words) + 3) + visibleWidth(meta) + visibleWidth(clause) + visibleWidth(key);
-    const trim = (text, room, floor) => (room >= floor ? `${widthCut(text, room)}…` : "");
-    if (words !== "" && width() > W)
-        words = trim(words, W - (width() - visibleWidth(words)) - 1, 4);
-    if (width() > W) {
-        for (const [long, short] of STRETCH_COMPACT) {
-            meta = meta.replaceAll(long, short);
-            if (width() <= W)
-                break;
-        }
-    }
-    if (width() > W) {
-        const room = W - (width() - visibleWidth(meta)) - 1;
-        meta = room >= 2 ? `${widthCut(meta, room)}…` : "…";
-    }
-    if (width() > W && clause !== "")
-        clause = trim(clause, W - (width() - visibleWidth(clause)) - 1, 5);
-    // the degenerate floor: below the width where even the mark and one
-    // character fit, the row is a hard cut of what it would have said.
-    const row = `${mark}${words === "" ? "" : ` ${p.rv}${words}${p.rvEnd}${p.dim} ·${p.reset}`} ${meta}${clause === "" ? "" : `${p.red}${clause}${p.reset}`}${key === "" ? "" : `${p.dim}${key}${p.reset}`}`;
-    return [visibleWidth(row) <= W ? row : cutLine(row, W)];
-}
-/** R6/D3: the quiet turn's fold wears no mark either — the SECOND
- *  emission site, and the one the D3 brief did not name. Same ruling,
- *  same two-space indent; see stretchLine above for the argument. */
-export function turnFold(t, W) {
-    const p = palette();
-    // R3b (owner, 2026-08-27): ZERO TERMS ARE DROPPED. W14 always wrote
-    // `no reads · no edits`, which is a sentence about things that did not
-    // happen — on a segment fold, where a run is usually all reads or all
-    // edits, half the row was the half that said nothing. A term earns its
-    // place by having a count.
-    // R3h (fable, 2026-08-29): the THOUGHT term obeys the same zero-drop
-    // rule every other term got at R3b. It was exempt by accident — it
-    // was written before the rule — so a model that emits no thinking
-    // folded every turn of its life under `thought 0s`, a sentence about
-    // something that did not happen, in the lead position.
-    const meta = [...(t.thoughtSeconds > 0 ? [`thought ${t.thoughtSeconds}s`] : []), ...foldTerms(t.reads, t.edits, t.others)].join(" · ");
-    // R3f: the same one-row rule. This one is worse than the thinking
-    // fold's — the fold is a COMMITTED row, so a multi-line user message
-    // would desync the committed-line accounting permanently rather than
-    // for one frame. (The live UserMessage chip keeps its multi-row form:
-    // it folds per paragraph and each row is already one row.)
-    const words = escapeTerminal(t.words).replace(/\s+/g, " ");
-    // R3g (2026-08-28) — THE KEY IS LOAD-BEARING, SO IT GIVES WAY LAST.
-    //
-    // R3b wrote "the suffix gives way first at a narrow width", by
-    // analogy with the settled card's affordance. The analogy does not
-    // hold: the card's rows are still on the screen when its hint is
-    // dropped, and a fold's are not. A fold with no key is the turn's
-    // work behind a line with no way back — the one thing the fold's own
-    // header says it must never be. So the META gives way first (a cut
-    // count is still a true count), and the key survives.
-    //
-    // Two live cases, both reachable at W=80: the wordless fold went
-    // keyless as soon as the terms grew (R3g's verb+noun phrasing pushed
-    // it over), and the CHIP fold never had a key at all — it was
-    // written without one, so every folded turn that carried the user's
-    // words was unreachable by the key its siblings advertise. Found by
-    // an independent review (fable) and then by the paced-rollup gate,
-    // which got `kind: "none"` back from expandNext.
-    // R3h: the COMPACT tier. The owner's own sentence — "thought 17s ·
-    // read 4 files · listed 1 directory · ran 4 shell commands" — is 81
-    // cells with the key at W=80: one over, so the tail was cut off the
-    // exact shape this round exists to produce. The nouns shorten before
-    // anything is lost, which is the same "degrade, never truncate"
-    // ladder every other row here walks.
-    // A LADDER, cheapest first, and it stops as soon as the row fits: the
-    // owner's canonical sentence is ONE cell over at W=80, and spending
-    // every substitution to buy one cell would shorten words that had
-    // room. "directory" is the cheapest to lose (nobody misreads "dir");
-    // "commands" is next and still says what happened.
-    const COMPACT = [
-        ["directories", "dirs"],
-        ["directory", "dir"],
-        ["shell commands", "commands"],
-        ["shell command", "command"],
-    ];
-    const compactAll = (text) => {
-        let out = text;
-        for (const [long, short] of COMPACT)
-            out = out.replaceAll(long, short);
-        return out;
-    };
-    const KEY = " · ctrl+o";
-    const keyW = KEY.length;
-    const key = `${p.dim}${KEY}${p.reset}`;
-    if (words === "") {
-        const keyed = `  ${meta}${key}`;
-        if (visibleWidth(keyed) <= W)
-            return [keyed];
-        let tightMeta = meta;
-        for (const [long, short] of COMPACT) {
-            tightMeta = tightMeta.replaceAll(long, short);
-            const tight = `  ${tightMeta}${key}`;
-            if (visibleWidth(tight) <= W)
-                return [tight];
-        }
-        // the meta cuts with the honest "…" — the COMPACT form of it, so a
-        // cut row still carries as many whole terms as the width allows;
-        // below the width where even the key fits there is nothing to
-        // preserve and the row is a cut.
-        const room = W - 2 - keyW - 1;
-        if (room < 2) {
-            // R3h: and below FOUR columns even that row is 4 cells wide (the
-            // gutter, one character, the "…"), so invariant ① threw AT the
-            // widths this branch exists to serve — the same class DC-15
-            // closed in the thinking fold, still open here. A width with no
-            // room for the mark is a width with nothing to say: the row is
-            // a hard cut of what it would have said.
-            const cut = `  ${widthCut(tightMeta, Math.max(1, W - 3))}…`;
-            return [visibleWidth(cut) <= W ? cut : cutLine(`  ${tightMeta}`, W)];
-        }
-        return [`  ${widthCut(tightMeta, room)}…${key}`];
-    }
-    // A9 (ruling R2, mock A): the user chip rides the fold — the human's
-    // words LEAD the one line, the same SGR-7 bracket as the live user
-    // row (#16f, side pads included). The words take the fold's width
-    // budget: W − the gutter (two spaces = 2, R6/D3) − the join (3) − the
-    // chip's side pads (2) − the cut-tail reserve (1, the "…") − the
-    // metadata's own width — the metadata survives, the words width-cut
-    // at the end with the honest "…" (the "…" alone is the honest floor:
-    // the words were there, cut).
-    const budget = Math.max(0, W - visibleWidth(`  ${meta}`) - 6 - keyW);
-    const cut = visibleWidth(words) > budget ? `${widthCut(words, budget)}…` : words;
-    const row = `  ${p.rv} ${cut} ${p.rvEnd} · ${meta}${key}`;
-    if (visibleWidth(row) <= W)
-        return [row];
-    // R3h: the same COMPACT ladder the wordless branch walks — the nouns
-    // shorten before the words or the metadata lose anything.
-    let chipMeta = meta;
-    for (const [long, short] of COMPACT) {
-        chipMeta = chipMeta.replaceAll(long, short);
-        const tighter = `  ${p.rv} ${cut} ${p.rvEnd} · ${chipMeta}${key}`;
-        if (visibleWidth(tighter) <= W)
-            return [tighter];
-    }
-    // the last resort: the METADATA gives way — the words hold their
-    // budget, the key holds its nine cells, the meta cuts with the honest
-    // "…"; invariant ① never trips at ANY width (a degenerate W's fold is
-    // a cut, never a crash).
-    const room = W - 8 - keyW - visibleWidth(cut);
-    if (room < 2) {
-        // R3h: the chip branch's own degenerate floor. The gutter, the
-        // bracket's pads, the join and the "…" are ten cells before a
-        // single character of content, so every width below ten threw
-        // invariant ① — see the wordless branch above for the same class.
-        const tail = `  ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(compactAll(meta), Math.max(1, W - 8 - visibleWidth(cut)))}…`;
-        return [visibleWidth(tail) <= W ? tail : cutLine(`  ${p.rv} ${cut} ${p.rvEnd}`, W)];
-    }
-    return [`  ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(compactAll(meta), room)}…${key}`];
-}
 // ---- the bounded-block flow contract (W7, W8, W10) ----
 /** The caps — screen rows counted AFTER the fold, at the current width
  *  (the W7 table). The renderer-cut row is inside the cap. */
-const CAP_SHELL_SETTLED = 5; // the shell output tail, settled
-const CAP_LIVE_WINDOW = 3; // the running tool's FIXED window (W8)
+/** R13 — ONE preview cap, every tool. It was the shell's alone while
+ *  the shell was the only settled call with rows on screen. */
+export const CAP_PREVIEW = 5;
+/** DC-46 — the running window's ceiling is the SETTLED preview's, and a
+ *  running card reaches it by growing rather than by being handed it.
+ *  `LIVE_WINDOW` (CAP_PREVIEW + 1) retires with the allocation it sized. */
+/** The rows a card costs besides its window: two pads, the head, two
+ *  blanks and the status row. Below this there is no card (DC-43). */
+export const CARD_CHROME = 6;
 const CAP_DIFF = 12; // the approval diff: head + the named middle + tail
-const CAP_ERROR = 3; // the error text head
 /** The block body rows' prefixes (W2's gutter table): │ a bounded
  *  block's body, └ the block's last row — what was cut, where the rest
  *  is — at the LEFT EDGE (the gutter column: the left edge alone
@@ -1600,13 +1442,35 @@ const CAP_ERROR = 3; // the error text head
  *  prose (2). Bytes still tell them apart; no column of glyphs.
  *
  *  `└` survives as the mark that OPENS the block, once, on its first
- *  row (see openBlock). In-block notes take NOTE_ROW — the same indent,
+ *  row (see openBlock). In-block notes take the same indent,
  *  no glyph — because a second `└` inside one block would be the same
  *  mark meaning two things (§4.1). CUT_ROW is unchanged for the
  *  surfaces that are not a tool block: the fold row's target list, the
  *  slot's overflow count. */
-const BODY_ROW = "    ";
-const NOTE_ROW = "    ";
+/** R8a's four columns — off the surface. Inside a painted card every
+ *  row sits at column 2 (R13 E4): the head row and the outcome row
+ *  bracket the preview, so the indent is no longer what says "these
+ *  rows are output". Where nothing paints, it is exactly that, and R8a
+ *  stands unchanged. */
+const BODY_ROW_FLAT = "    ";
+const NOTE_ROW_FLAT = "    ";
+const CARD_ROW = "  ";
+/** R13 E3 — the column the model's words begin in, the same one the
+ *  card's rows and the chip's text begin in. */
+const PROSE_COL = "  ";
+/** DC-47, ADJUDICATED — the model's THINKING begins in the SAME column
+ *  as everything else: two.
+ *
+ *  It went to four when E3 moved prose to two, so that stripping the
+ *  escapes would still tell them apart (§1.2). The owner looked at it
+ *  and ruled against it: "the thinking area is not indented by the same
+ *  two as the first line — it needs to keep the same first-line indent
+ *  as everything else" (2026-09-04). §1.8's one left edge outranks the
+ *  distinction, and §1.2 takes a DECLARED EXCEPTION for this one pair —
+ *  see design.md §1.2 and §7.2 for what is given up and what is not. */
+const THINK_COL = "  ";
+const bodyRow = () => (slabPaints() ? CARD_ROW : BODY_ROW_FLAT);
+const noteIndent = () => (slabPaints() ? CARD_ROW : NOTE_ROW_FLAT);
 const CUT_ROW = "└ ";
 /**
  * R9 P2 — THE SLAB: a single call's block is one washed object.
@@ -1665,7 +1529,7 @@ function noteRow(text, W, tone) {
     // its own. The row names a fact; a cut names it shorter.
     const open = tone === "body" ? p.washDim : p.dim;
     const close = tone === "body" ? p.washDimEnd : p.reset;
-    return [cutLine(`${open}${NOTE_ROW}${text}${close}`, W)];
+    return [cutLine(`${open}${noteIndent()}${text}${close}`, W)];
 }
 /**
  * Assemble a call's block.
@@ -1682,18 +1546,29 @@ function slabBlock(head, body, outcome, W) {
             out.push(...noteRow(outcome, W, "dim"));
         return out;
     }
-    const rows = [slabRow(head, W)];
-    if (body.length > 0)
-        rows.push(slabRow("", W));
-    for (const r of body)
-        rows.push(slabRow(r, W));
-    if (outcome !== null) {
-        if (body.length > 0)
-            rows.push(slabRow("", W));
-        for (const r of noteRow(outcome, W, "body"))
-            rows.push(slabRow(r, W));
+    // R13 — THE CARD. pad · head · blank · preview · blank · outcome ·
+    // pad, and a call with nothing to preview is three rows with its
+    // outcome riding the head. Every row sits at column 2 (E4): R8a put
+    // a block's body at column 4 so a pipe could tell output from prose,
+    // and inside a painted card the head and the outcome bracket it
+    // instead — off the surface R8a's indent is still the fact, which is
+    // why the degradation above keeps it.
+    if (body.length === 0) {
+        // DC-48: the join makes a ROW, so it is cut like every other row.
+        // The callers above size their parts against the room they have;
+        // this is the backstop that makes invariant ① hold whatever they
+        // do, and it is what was missing when a running card's head was
+        // cut to W and then had a whole status appended to it.
+        const only = cutLine(outcome === null ? head : `${head} ${outcome}`, W);
+        return [slabRow("", W), slabRow(only, W), slabRow("", W)];
     }
-    return rows;
+    const top = [slabRow("", W), slabRow(head, W), slabRow("", W), ...body.map((r) => slabRow(r, W))];
+    // An EXPANDED block closes with its own footer and passes no outcome;
+    // a blank row and an empty metadata row under it would be §1.3's
+    // empty mark twice over.
+    if (outcome === null)
+        return [...top, slabRow("", W)];
+    return [...top, slabRow("", W), ...noteRow(outcome, W, "body").map((r) => slabRow(r, W)), slabRow("", W)];
 }
 /** R8a — stamp `└` on a block's FIRST row, after every slice and note
  *  has been assembled, so the mark is always on the first row actually
@@ -1703,25 +1578,26 @@ function openBlock(rows) {
     // or a blank leading output line can put an empty row first, and a
     // corner there would be a mark on a row with nothing to mark — law
     // 1.3, which is the rule this whole change is serving.
-    const i = rows.findIndex((r) => visibleWidth(r) > visibleWidth(BODY_ROW));
+    const i = rows.findIndex((r) => visibleWidth(r) > visibleWidth(bodyRow()));
     if (i < 0)
         return rows;
     const first = rows[i];
-    const at = first.indexOf(BODY_ROW);
+    const at = first.indexOf(BODY_ROW_FLAT);
     if (at < 0)
         return rows;
     // the corner REPLACES two of the four indent columns, so the text
     // stays in the same column as every other row of the block.
-    return [...rows.slice(0, i), `${first.slice(0, at)}  \u2514 ${first.slice(at + BODY_ROW.length)}`, ...rows.slice(i + 1)];
+    return [...rows.slice(0, i), `${first.slice(0, at)}  \u2514 ${first.slice(at + BODY_ROW_FLAT.length)}`, ...rows.slice(i + 1)];
 }
 const blockMemo = new WeakMap();
 /** The block's body rows below the header (memoized, W9). */
-function toolBlockParts(c, W) {
+function toolBlockParts(c, W, ctx) {
     const memo = blockMemo.get(c);
     // the SURFACE is part of the key: the same cell renders different rows
     // painted and unpainted, and a ground resolved after the first frame
     // would otherwise be served the pre-ground shape forever.
-    const state = `${c.state}:${c.isError}:${c.name}:${c.expanded ? "x" : ""}:${slabPaints() ? "slab" : "flat"}`;
+    const liveRows = ctx.liveWindow ?? CAP_PREVIEW;
+    const state = `${c.state}:${c.isError}:${c.name}:${c.expanded ? "x" : ""}:${slabPaints() ? "slab" : "flat"}:${liveRows}`;
     const content = c.state === "approval" ? (c.diff ?? null) : c.resultText;
     if (memo !== undefined && memo.width === W && memo.state === state && memo.content === content)
         return memo;
@@ -1743,62 +1619,71 @@ function toolBlockParts(c, W) {
                 ? errorBody(c, W)
                 : c.name === "delegate"
                     ? delegateSettled(c, W)
-                    : // R9 P2 / D4 — DECLARED REVERSAL of TUI2-R1.5 ④(c) (VD-5),
-                        // owner-ruled. VD-5 collapsed a settled shell to its head
-                        // row because six ungrounded rows per call let three
-                        // shells own a screen. The slab is what changes that
-                        // arithmetic: the rows are inside a surface that says
-                        // where the call begins and ends, so five of them read as
-                        // one object rather than as five loose lines. The cap and
-                        // the tail direction are VD-5's own (CAP_SHELL_SETTLED,
-                        // the conclusion at the end); only the emptiness is
-                        // reversed.
-                        c.name === "shell"
-                            ? shellTail(c.resultText, W, slabPaints() ? "body" : "dim")
-                            : []
+                    : // R13 — EVERY settled call previews. The shell's tail is
+                        // VD-5's own cap and direction (the conclusion is at the
+                        // end); everything else shows its head, because that is
+                        // where its answer is. read_file is the single exception
+                        // (E1): its result is the file, kiso has nothing to add by
+                        // showing five lines of it, and the head row's key opens
+                        // the whole thing.
+                        noPreview(c)
+                            ? []
+                            : c.name === "shell"
+                                ? shellTail(c.resultText, W, slabPaints() ? "body" : "dim")
+                                : previewHead(c.resultText, W, slabPaints() ? "body" : "dim")
             : c.state === "running"
                 ? c.name === "delegate"
                     ? delegateRunning(c, W)
-                    : c.name === "shell"
-                        ? shellLiveTail(c.resultText, W)
-                        : liveWindow(c.resultText, W)
+                    : // R13 E1 — the call with no preview settled has none while
+                        // it runs either; its card is three rows the whole way.
+                        noPreview({ ...c, state: "done" })
+                            ? []
+                            : liveWindow(c, W, liveCap(c, liveRows), slabPaints() ? "body" : "dim")
                 : c.state === "approval"
                     ? diffBody(c.diff, W)
                     : [];
-    // R9 P2: how many of these rows are the call's OWN OUTPUT. A cut note
-    // is kiso's sentence about a result the TOOL truncated, not a line of
-    // it — a read that has only that note has nothing verbatim on screen
-    // and stays a ONE-ROW slab, outcome inline, exactly as R9 draws it.
-    const output = rows.length;
+    // E1 governs the PREVIEW — five lines of a file kiso has nothing to
+    // add to — not kiso's sentence about the result. `offset=201 for the
+    // rest` is actionable and no other row says it (W10 pins exactly
+    // that), so a read the TOOL capped takes one body row and a read it
+    // did not takes none. That shape difference is information: the two
+    // events are different, and the row is what says so.
     const note = c.expanded ? null : toolCutNote(c.name, c.resultText);
     if (note !== null)
-        rows.push(...foldLine(`${p.dim}${NOTE_ROW}${note}${p.reset}`, W));
+        rows.push(...foldLine(`${p.dim}${noteIndent()}${note}${p.reset}`, W));
     // TUI2-R1 (A): an EXPANDED block says how to put it back. The footer
     // rides a block that HAS rows — an expanded delegate whose summary
     // marker is missing renders nothing, and a lone footer under a head
     // row would be an affordance for an empty block.
     if (c.expanded && rows.length > 0)
-        rows.push(...foldLine(`${p.dim}${NOTE_ROW}${COLLAPSE_ROW}${p.reset}`, W));
+        rows.push(...foldLine(`${p.dim}${noteIndent()}${COLLAPSE_ROW}${p.reset}`, W));
     // R9 P2: `└` opens a block that has no surface. Inside a slab the
     // surface IS the container, and a corner in it is §1.3's empty mark
     // one scale up — so the corner and the slab are alternatives, never
     // both.
     const opened = slabPaints() ? rows : openBlock(rows);
-    const parts = { width: W, state, content, rows: opened, output };
+    const parts = { width: W, state, content, rows: opened };
     blockMemo.set(c, parts);
     return parts;
 }
-/** The rows alone — every caller but the settled branch, which needs to
- *  know whether any of them are the call's own OUTPUT. */
-function toolBlockBody(c, W) {
-    return toolBlockParts(c, W).rows;
+/** R13 E1 — the one settled call that previews NOTHING. A read's result
+ *  IS the file; five lines of it tell a reader less than the head row
+ *  already does, and the key opens the whole thing. (The reference
+ *  implementation makes the same call, for the same reason.) Everything
+ *  else previews: a shell its tail, the rest their head. */
+function noPreview(c) {
+    return c.state === "done" && !c.expanded && !c.isError && c.reason === null && c.name === "read_file";
+}
+/** The block's body rows. */
+function toolBlockBody(c, W, ctx) {
+    return toolBlockParts(c, W, ctx).rows;
 }
-/** Fold result text into dim body rows (the BODY_ROW prefix): escape,
+/** Fold result text into body rows (the block's own indent): escape,
  *  split, fold each line at W−prefix; trailing empty rows (the result's
  *  final newline) drop. */
 function blockRows(text, W, tone = "dim") {
     const p = palette();
-    const textW = Math.max(1, W - visibleWidth(BODY_ROW));
+    const textW = Math.max(1, W - visibleWidth(bodyRow()));
     const rows = [];
     // R9 P2: inside a SLAB the output rows are body strength, never dim —
     // §2.1 bars dim from the wash (3.91:1 light, 4.35:1 dark) and these
@@ -1808,9 +1693,9 @@ function blockRows(text, W, tone = "dim") {
     const close = tone === "dim" ? p.reset : "";
     for (const raw of escapeTerminal(text).split("\n")) {
         for (const row of foldLine(raw, textW))
-            rows.push(`${open}${BODY_ROW}${row}${close}`);
+            rows.push(`${open}${bodyRow()}${row}${close}`);
     }
-    while (rows.length > 0 && visibleWidth(rows[rows.length - 1]) === visibleWidth(BODY_ROW))
+    while (rows.length > 0 && visibleWidth(rows[rows.length - 1]) === visibleWidth(bodyRow()))
         rows.pop();
     return rows;
 }
@@ -1820,23 +1705,43 @@ function blockRows(text, W, tone = "dim") {
  *  direction). */
 function shellTail(text, W, tone = "dim") {
     const rows = blockRows(text, W, tone);
-    if (rows.length <= CAP_SHELL_SETTLED)
+    if (rows.length <= CAP_PREVIEW)
         return rows;
     // R9 P2 / D4: FIVE output rows, and the note is a row of its own. The
     // pre-slab arithmetic spent one of the five on the cut note, because
     // the note had nowhere else to live; the slab's metadata rows are not
     // output and are not counted against the output's cap.
-    const kept = CAP_SHELL_SETTLED;
+    const kept = CAP_PREVIEW;
     // The note goes ABOVE the tail: it says what was cut, and what was
     // cut is what came BEFORE these rows. One position on both surfaces —
     // the surface degrades, the content shape does not.
-    const cut = rows.length - kept;
-    const n = `${cut} earlier line${cut === 1 ? "" : "s"}`;
-    // the KEY is reserved (TUI2-R1.5 ⑤): the count gives way before it,
-    // because a row that says how much is hidden without saying how to
-    // see it is the silence TUI2-R1 (A) set out to remove.
-    const note = noteRow(pickTier([`… ${n} · ctrl+o expands`, `… ${n} · ctrl+o`, `… ${cut} · ctrl+o`, "· ctrl+o"], W - visibleWidth(NOTE_ROW)), W, tone);
-    return [...note, ...rows.slice(rows.length - kept)];
+    return [...cutNote(rows.length - kept, "earlier", W, tone), ...rows.slice(rows.length - kept)];
+}
+/** R13 — the preview every OTHER settled call gets: the FIRST rows,
+ *  capped at five, the cut note BELOW them. A shell's conclusion is at
+ *  the bottom of its output, so its preview is the tail and its note
+ *  opens the block (shellTail above); a list, a search, a fetch all
+ *  answer at the top, so the note closes it. One rule, two directions,
+ *  and the direction follows where the answer is.
+ *
+ *  This is the DECLARED REVERSAL of VD-5 for every tool but the shell
+ *  (0.22.0 reversed the shell alone): VD-5 collapsed a settled call to
+ *  its head row because ungrounded output rows owned the screen, and
+ *  the card is what changes that arithmetic — the rows are inside a
+ *  surface that says where the call begins and ends. */
+function previewHead(text, W, tone) {
+    const rows = blockRows(text, W, tone);
+    if (rows.length <= CAP_PREVIEW)
+        return rows;
+    return [...rows.slice(0, CAP_PREVIEW), ...cutNote(rows.length - CAP_PREVIEW, "more", W, tone)];
+}
+/** The preview's cut note, in one place so the head and the tail
+ *  directions cannot drift apart. The KEY is reserved (TUI2-R1.5 ⑤): a
+ *  row that says how much is hidden without saying how to see it is the
+ *  silence the affordance exists to remove. */
+function cutNote(cut, word, W, tone) {
+    const n = `${cut} ${word} line${cut === 1 ? "" : "s"}`;
+    return noteRow(pickTier([`… ${n} · ctrl+o expands`, `… ${n} · ctrl+o`, `… ${cut} · ctrl+o`, "· ctrl+o"], W - visibleWidth(noteIndent())), W, tone);
 }
 /** The error text head: the FIRST rows, capped at 3 — the answer is at
  *  the start (opencode's collapseToolOutput direction). The header row
@@ -1852,81 +1757,77 @@ function errorBody(c, W) {
     // FULL content including the "[Permission denied] " prefix (never
     // hide information — the folded body rides the pinned row).
     const skipFirst = c.name === "shell" && /^exit \d+/.test(c.resultText) ? 0 : c.reason !== null && c.reason !== undefined ? 0 : 1;
-    const rows = blockRows(c.resultText.split("\n").slice(skipFirst).join("\n"), W);
-    if (rows.length <= CAP_ERROR)
-        return rows;
-    const cut = foldLine(`${p.dim}${NOTE_ROW}+${rows.length - (CAP_ERROR - 1)} more · ctrl+o${p.reset}`, W);
-    return [...rows.slice(0, CAP_ERROR - 1), ...cut];
-}
-/** The running tool's FIXED-height window (W8): exactly 3 rows from
- *  the FIRST frame — blank-padded before output arrives, the renderer
- *  cut inside the window. The height changes exactly once, at settle —
- *  a cell that grows mid-list would shift every row after it on every
- *  delta (the parallel-tools jitter). */
-function liveWindow(text, W) {
-    const p = palette();
-    if (text === "") {
-        // R7a: blank, not two bare gutters. A `│` marks a row that HAS
-        // content; two of them above "waiting for output" drew a tall
-        // empty bar under every command that had not printed yet — which
-        // is most of them, for their first second.
-        // ...and the waiting row sits DIRECTLY under its header, with the
-        // blanks below it — VD-4's own rule ("the output starts under its
-        // own header and grows downward"), which the gutter rows used to
-        // satisfy by accident and blanks made visible as a two-row gap.
-        return [`${p.dim}${NOTE_ROW}waiting for output${p.reset}`, "", ""];
-    }
-    const rows = blockRows(text, W);
-    if (rows.length <= CAP_LIVE_WINDOW) {
-        while (rows.length < CAP_LIVE_WINDOW)
-            rows.push(""); // R7a: blank, not a bar
-        return rows;
-    }
-    const cut = foldLine(`${p.dim}${NOTE_ROW}+${rows.length - (CAP_LIVE_WINDOW - 1)} earlier rows · ctrl+o${p.reset}`, W);
-    return [...rows.slice(rows.length - (CAP_LIVE_WINDOW - 1)), ...cut];
+    // R13 — a failure is a CARD like any other call: the same cap of
+    // five, the same note wording, the same direction (an error's answer
+    // is at the top). It kept a cap of three and `+2 more · ctrl+o` from
+    // before the card existed, which made the one shape a reader most
+    // wants to read the one shape that showed least of itself.
+    return previewHead(c.resultText.split("\n").slice(skipFirst).join("\n"), W, slabPaints() ? "body" : "dim");
 }
 /**
- * TUI2-R1 (C) — the RUNNING shell's live tail.
- *
- * The rows are the sidecar's last lines, NEWEST AT THE BOTTOM (a tail
- * grows downward, and the row nearest the footer is the newest thing the
- * command said). The window is the SAME three rows W8 fixed: two tail
- * rows and the footer, blank-padded before the output fills them, so the
- * block's height still changes exactly once — at settle.
- *
- * With nothing observed the shape is exactly today's "waiting for
- * output": a sidecar that never appeared, a command that has not
- * printed, and a temp dir that refused the write are indistinguishable
- * from here, and all three mean the same thing — nothing to show.
- *
- * The footer names the state AND the two gestures that apply while a
- * command runs, because this is precisely when a human wants them.
+ * DC-46 — THE RUNNING WINDOW GROWS, and nothing pads it.
+ *
+ * DECLARED REVERSAL of W8's fixed window and of E2 as first written
+ * ("allocated at the settled card's height, and only ever shrinks at
+ * settle"). Both fixed a height so it would not move while a command
+ * ran; both fixed it at a height the SETTLE then changed, and the settle
+ * is where the cost landed. A card allocated at twelve rows and settling
+ * at three gives nine rows back, the window's top is clamped and cannot
+ * follow, and the difference is a blank band above the composer.
+ * Measured on the a7 replay: hole-frames 8.9 / 13.5 / 3.8 percent at
+ * 0.23.0 against 16.9 / 24.6 / 7.9 with the shrink. The only source is
+ * the shrink, so the cure is to stop shrinking.
+ *
+ * So the window IS its content: one row while nothing has arrived, one
+ * more per line to the cap, then the cut note above a scrolling tail.
+ * R7a's "blank, not a bar" retires with the padding it governed — it was
+ * about what to draw on rows a FIXED height reserved, and no height is
+ * reserved now.
+ *
+ * The direction is the SETTLED card's, so a settle swaps content and
+ * moves nothing: a shell shows its tail with the note above, everything
+ * else its head with the note below.
  */
-function shellLiveTail(text, W) {
-    if (text === "")
-        return liveWindow("", W);
+function liveWindow(c, W, cap, tone) {
     const p = palette();
-    // TUI2-R1.5 ④(b) (VD-4): the tail's first row is never a blank gutter.
-    // Two sources, both fixed here, and the W8 fixed-window height is kept
-    // by both fixes:
-    //  - leading empty lines in the sidecar (a 4096-byte tail can begin on
-    //    a line boundary, and the reader's .trimEnd only trims the other
-    //    end) are skipped;
-    //  - the short-output pad moved from the TOP to the BOTTOM. It exists
-    //    so the block's height never changes while the command runs (W8);
-    //    at the top it put an empty row above the command's very first
-    //    line, which is the frame the walkthrough filed. At the bottom the
-    //    output starts under its own header and grows downward, and the
-    //    height is just as fixed.
-    const all = blockRows(text, W);
-    const from = all.findIndex((r) => visibleWidth(r) > visibleWidth(BODY_ROW));
-    const rows = from < 0 ? [] : all.slice(from);
-    if (rows.length === 0)
-        return liveWindow("", W);
-    const kept = rows.slice(Math.max(0, rows.length - (CAP_LIVE_WINDOW - 1)));
-    while (kept.length < CAP_LIVE_WINDOW - 1)
-        kept.push(""); // R7a: blank, not a bar
-    return [...kept, cutLine(`${p.dim}${NOTE_ROW}live tail · esc stop · alt+⏎ redirect${p.reset}`, W)];
+    // TUI2-R1.5 ④(b) (VD-4): leading empty lines in the sidecar (a
+    // 4096-byte tail can begin on a line boundary) are skipped, so the
+    // output starts under its own header.
+    const all = blockRows(c.resultText, W, tone);
+    const from = all.findIndex((r) => visibleWidth(r) > visibleWidth(bodyRow()));
+    // DC-46, derived — NOTHING YET IS NO WINDOW AT ALL, so a running call
+    // with no output is the same THREE-ROW card as a settled one with
+    // none. The ruling's skeleton put a `waiting for output` row here; a
+    // command that returns nothing (`true`, a silent build) would then
+    // settle from seven rows to three, which is the very shrink the ruling
+    // exists to remove — its own rule cannot hold with that row in place.
+    //
+    // Nothing is lost: the breathing mark says the call is in flight and
+    // the status row's elapsed says how long, so a row reading "waiting
+    // for output" carries no fact they do not (§1.3). The card grows the
+    // instant a line arrives, and growth is what this design permits.
+    if (from < 0)
+        return [];
+    const rows = all.slice(from);
+    if (rows.length <= cap)
+        return rows;
+    return c.name === "shell"
+        ? [...cutNote(rows.length - cap, "earlier", W, tone), ...rows.slice(rows.length - cap)]
+        : [...rows.slice(0, cap), ...cutNote(rows.length - cap, "more", W, tone)];
+}
+/** DC-46 — the window's HIGH-WATER, per cell: the room a frame leaves
+ *  caps how far a window may GROW, and never shrinks one that already
+ *  grew. Without this a second call starting would pull the first's
+ *  window in, which is the same shrink by another route. Keyed on the
+ *  cell, like `blockMemo`, and it only ever matters while the cell is
+ *  live — a settled cell renders from its result alone. */
+const liveHighWater = new WeakMap();
+function liveCap(c, room) {
+    const want = Math.min(CAP_PREVIEW, Math.max(1, room));
+    const held = liveHighWater.get(c) ?? 0;
+    const cap = Math.max(want, held);
+    liveHighWater.set(c, cap);
+    return cap;
 }
 /**
  * R4 — the standing act slot.
@@ -1972,7 +1873,7 @@ export function slotTail(text, W, rows) {
         return [];
     const p = palette();
     const all = blockRows(text, W);
-    const from = all.findIndex((r) => visibleWidth(r) > visibleWidth(BODY_ROW));
+    const from = all.findIndex((r) => visibleWidth(r) > visibleWidth(bodyRow()));
     const body = from < 0 ? [] : all.slice(from);
     // R7a: no pad. The slot stopped padding (see slotPad) and this was
     // the same pad by another route — three blank rows under a call with
@@ -2133,7 +2034,18 @@ class MarkdownBlock {
         this.cell = cell;
     }
     render(W, _ctx) {
-        return renderBlock(this.cell.block, W);
+        // R13 E3 — THE MODEL'S WORDS MOVE TO COLUMN 2. A card's rows sit
+        // there (E4) and the chip's text does too (D4), so prose at column
+        // 0 would leave the page with three left edges for three registers
+        // — the opposite of one rhythm. The registers are told apart by
+        // SURFACE, which is §1.6's argument; the column is not one of the
+        // things doing that work.
+        //
+        // The block folds in the room the indent leaves, so invariant ①
+        // holds by construction. A block's own leading blank (its `gap`)
+        // stays EMPTY: an indented blank row is trailing whitespace, and
+        // §1.3 forbids a mark on a row with nothing to mark.
+        return renderBlock(this.cell.block, Math.max(1, W - PROSE_COL.length)).map((r) => (r === "" ? r : `${PROSE_COL}${r}`));
     }
 }
 /** The notice lines — the error surface. */