@vincemakes/kiso-tui-cells 0.24.5 → 0.26.0

package/dist/components.js

@@ -25,12 +25,12 @@
  * (untouched); render.ts supplies the original text (palette, escape,
  * tint, fold wording).
  */
-import { displayWidth, visibleWidth } from "./width.js";
+import { displayWidth, visibleWidth, widthCut } from "./width.js";
 // TUI2-R2pre ④: the ONE display-verb table (strings.ts, beside
 // KEY_BINDINGS). strings.js imports only render/width here, so this edge
 // adds no cycle.
 import { displayVerb } from "./strings.js";
-import { bannerLines, breathFrame, escapeTerminal, foldThinking, foldResult, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, currentGround, } from "./render.js";
+import { bannerLines, breathFrame, cutLine, escapeTerminal, foldThinking, foldResult, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, currentGround, } from "./render.js";
 // TUI2-MD: the markdown renderer's surface reaches the tui through this
 // module (the tui's components shim re-exports it) — one import edge,
 // and it points one way: md.ts measures with the width authority, never
@@ -113,7 +113,8 @@ export function foldLine(line, W) {
  *  renderer can measure without importing this module back — the
  *  re-export is verbatim, so every existing importer and the barrel see
  *  exactly what they saw. */
-export { visibleWidth } from "./width.js";
+export { visibleWidth, widthCut } from "./width.js";
+export { cutLine } from "./render.js";
 /** The W11 spacing formula — "a row gets one blank line above it when
  *  the row is itself a block, or when the previous sibling was taller
  *  than one row". One-row siblings pack tight; anything multi-row
@@ -122,7 +123,7 @@ export { visibleWidth } from "./width.js";
  *  `prev` is the previous sibling's OWN rows (raw — a cell's own blank
  *  must never count toward its height). The blank is a JOIN artifact:
  *  the cell's own render stays blank-free, so per-cell accounting
- *  (heights, the fold cache) never sees a fake row. */
+ *  (heights, the line cache) never sees a fake row. */
 export function bodySpacing(prev, rows) {
     if (rows.length === 0 || prev === null || prev.length === 0)
         return rows;
@@ -168,9 +169,9 @@ export function cellComponent(cell) {
         case "user":
             return new UserMessage(cell);
         case "thinking":
-            // R7: the committed/live surface is the BLOCK. ThinkingFold
-            // survives for the pipe path (render.ts's foldThinking), whose
-            // bytes are asserted by the --plain identity gate.
+            // R7: the committed/live surface is the BLOCK; the pipe path
+            // prints render.ts's one-row foldThinking instead, whose bytes
+            // are asserted by the --plain identity gate.
             return new ThinkingBlock(cell);
         case "tool":
             return new ToolExecution(cell);
@@ -334,19 +335,14 @@ export function pendingQueueRows(lines, W) {
     }
     return out;
 }
-/** The thinking fold — one dim line, width-capped so the /think suffix
- *  rides the fold's own row (the #17 fix's slice, componentized). The
- *  slice is DISPLAY-WIDTH-based (the char-based slice overflowed with
- *  CJK — 2 cells per char — and tripped invariant ① on a real
- *  Chinese session). W2: the leading ⋯ is the thinking gutter — the
- *  midline mark (the state), never the text ellipsis (the truncation). */
 /**
  * R7 — THINKING IS A BLOCK OF WORDS.
  *
  * The owner's ruling, arrived at from a side-by-side with pi's screen:
  * the model's reasoning reads as its own paragraphs — italic, dim,
- * indented two — and is never folded away. `ThinkingFold` (below, kept
- * for the pipe path) summarised it to one row with a key; four rounds
+ * indented two — and is never folded away. A one-row fold (the pipe
+ * path's `foldThinking` is what remains of it) stood for it, with a
+ * key; four rounds
  * of machinery were then built to hand the rest back, and the owner's
  * complaint through all of them was the same sentence: I cannot see
  * what it was thinking.
@@ -411,79 +407,18 @@ class ThinkingBlock {
         return rows;
     }
 }
-class ThinkingFold {
-    cell;
-    constructor(cell) {
-        this.cell = cell;
-    }
-    render(W, _ctx) {
-        const p = palette();
-        const block = this.cell.text;
-        // R3f — the fold is ONE ROW, so its text is one line.
-        //
-        // `escapeTerminal` strips C0 but KEEPS \n and \t, and
-        // `charWidth(0x0A)` is 1 — so a multi-line thinking block sailed
-        // through every width check as a legal single row, and the
-        // terminal then wrapped it across the chrome. That shipped in
-        // 0.16.6 and is what smashed the composer: a model whose thinking
-        // opens with a numbered plan ("1. …\n2. …") produces exactly it.
-        // Invariant ①b now catches the class at the emit; this stops
-        // producing it. Whitespace collapses because the row is a
-        // SUMMARY — the full text is one ctrl+o away, unchanged.
-        const trimmed = escapeTerminal(block.trim()).replace(/\s+/g, " ");
-        // R2 (owner, 2026-08-27) — three changes, each independent.
-        //
-        // ITALIC marks the row as not-the-answer without spending a colour,
-        // on the same argument that admitted italic to the alphabet.
-        //
-        // The cut lands on a WORD. It used to cut on a byte, so the fold
-        // read as `…the user's h` and the reader's eye had to reassemble a
-        // word it already knew.
-        //
-        // The affordance moves to the RIGHT EDGE, so the left edge of every
-        // row on screen is content. The char count goes with the move: it
-        // told the reader nothing they could act on, and the row it was
-        // crowding is the one thing this cell says.
-        //
-        // The ≤100 short-circuit stays width-aware: a short block at a
-        // narrow width returned the line UNFOLDED and tripped invariant ①.
-        // DC-15: the affordance is DROPPED, not squeezed. `room` floored at
-        // 1 while `pad` floored at 1 independently, so a narrow terminal
-        // produced 2 + cut + pad + 6 = 11 cells no matter what W was — and
-        // invariant ① does not truncate, it THROWS. Measured 11 cells at
-        // every W ≤ 10. Below the width where the tail and one word of
-        // content can both stand, the row is the CONTENT: a cell that
-        // cannot hold the key's name has nothing to say about the key.
-        const tail = "/think";
-        const room = W - 2 - tail.length - 1;
-        // the belt: cutLine is SGR-aware and single-row, so the invariant
-        // holds by CONSTRUCTION at every width rather than by arithmetic
-        // that has to be re-proved every time a span moves.
-        if (room < 2)
-            return [cutLine(`${p.dim}⋯ ${p.italic}${wordCut(trimmed, Math.max(1, W - 2))}${p.italicEnd}${p.reset}`, W)];
-        const cut = wordCut(trimmed, room);
-        const body = `⋯ ${p.italic}${cut}${p.italicEnd}`;
-        const pad = Math.max(1, W - 2 - visibleWidth(cut) - tail.length);
-        return [cutLine(`${p.dim}${body}${" ".repeat(pad)}${tail}${p.reset}`, W)];
+/** The SGR spans still open at the end of `text`, given those open at
+ *  its start. A reset closes everything; anything else stacks. */
+function spansOpenAfter(text, before) {
+    let open = [...before];
+    for (const m of text.matchAll(/\x1b\[[0-9;]*m/g)) {
+        if (m[0] === "\x1b[0m")
+            open = [];
+        else
+            open.push(m[0]);
     }
+    return open;
 }
-/** R2 — cut at a word boundary, with the honest ellipsis. widthCut cuts
- *  at a cell, which is right for verbatim output and wrong for prose:
- *  the reader has to reassemble "h" into "home". Falls back to the cell
- *  cut when the first word alone overruns, because a row that cannot
- *  hold one word has no boundary to find. */
-function wordCut(text, room) {
-    if (visibleWidth(text) <= room)
-        return text;
-    const hard = widthCut(text, Math.max(1, room - 1));
-    const at = hard.lastIndexOf(" ");
-    return `${at > room / 3 ? hard.slice(0, at) : hard}\u2026`;
-}
-/** Fold a line's CONTENT at W−2 and prefix EVERY row with the gutter
- *  (W2: a wrapped tool row keeps its state mark — the left edge alone
- *  distinguishes the states at --plain; the UserMessage rail precedent,
- *  v5 #16f). The gutter carries its own SGR (e.g. the bold ✓). W21:
- *  exported for the approval panel's text args (the same │ gutter). */
 /**
  * TUI2-R1.5 ⑨ (VD-10) — the WORD-aware fold, for text a human reads.
  *
@@ -502,18 +437,6 @@ function wordCut(text, room) {
  * overflowing row would violate invariant ①, and a word that cannot fit
  * has to be broken somewhere.
  */
-/** The SGR spans still open at the end of `text`, given those open at
- *  its start. A reset closes everything; anything else stacks. */
-function spansOpenAfter(text, before) {
-    let open = [...before];
-    for (const m of text.matchAll(/\x1b\[[0-9;]*m/g)) {
-        if (m[0] === "\x1b[0m")
-            open = [];
-        else
-            open.push(m[0]);
-    }
-    return open;
-}
 export function foldWords(line, W) {
     if (W < 1)
         return [line];
@@ -659,25 +582,17 @@ function toolTargetOf(c) {
     }
     return toolTarget(c.name, input);
 }
-/** The tool execution line + the bounded block — every state is its
- *  own render; the lines fold (the summary gives way first). W7 (the
- *  flow contract): the block's BODY (the rows below the header) is
- *  capped in SCREEN rows AFTER the fold, at the current width — the
- *  renderer-cut row (`└ +N … · ctrl+o`) sits INSIDE the cap (a
- *  truncated block is cap−1 output rows + the cut row); the TOOL-cut
- *  row (`└ capped by …` — the tool's OWN truncation note, W10) is a
- *  DIFFERENT fact, never counted in the output cap. W3: the verb is
- *  stripped of its "_file" suffix and padded to 5 columns — the target
- *  paths line up (the pipe path strips the same suffix, render.ts —
- *  both paths print the same verb; a verb ≥ 5 columns is not padded).
- *  The block's cut note keeps the RAW name (it names the tool the
- *  model should call again). W4: the settled row's parentheses hold
- *  the human metadata (settledMeta) — the input summary lived in the
- *  running row; the OUTCOME is what the settled row says. A4: the
- *  settled row keeps the TARGET — verb + target + outcome, the running
- *  row's summary column (the W19 pinned row keeps the full call name
- *  instead). A5: the verdict rides the head row — a decidedBy present
- *  on the cell appends `· approved by X` (extension auto-approvals) or
+/** THE TOOL CARD — one per call, every state its own render (R13):
+ *  pad · head row · blank · the preview, capped at CAP_PREVIEW rows and
+ *  cut with a note that names the key · blank · the outcome row · pad;
+ *  a call with nothing to show is the three-row bodiless card. The body
+ *  is capped in SCREEN rows at the current width; the tool's OWN
+ *  truncation note (W10, `capped by …`) is a different fact, never
+ *  counted against the cap. W3: the verb drops its "_file" suffix and
+ *  pads to 5 columns so the targets line up (the pipe path prints the
+ *  same verb). A4: the settled head row is verb + target + outcome; the
+ *  W19 pinned deny keeps the full call name instead. A5: a decidedBy on
+ *  the cell appends `· approved by X` (an extension's auto-approval) or
  *  `· by X` on the pinned deny; the human decision needs no marker. */
 class ToolExecution {
     cell;
@@ -689,10 +604,9 @@ class ToolExecution {
         const c = this.cell;
         const verb = escapeTerminal(displayVerb(c.name));
         const verbCol = verb.length < 5 ? `${verb}${" ".repeat(5 - verb.length)}` : verb;
-        // 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).
+        // DECLARED REVERSAL (R13): the W13 rollup row and TUI2-R1 (B)'s
+        // exploration row stood here, ahead of everything else a settled
+        // call could be; both retired with the `rolled` field they read.
         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
@@ -771,15 +685,6 @@ class ToolExecution {
             // a pipe with the colour stripped. A failure keeps its colour
             // AND its words — see settledMeta.
             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
-                // outcome row as well would put two closing rows on one block
-                // and move the metadata off a head row every width gate pins.
-                // It takes the SURFACE and nothing else.
-                const head = c.isError ? `  ${p.red}${text}${p.reset}` : `  ${text}`;
-                return slabBlock(appendSuffix(head, expandSuffix(hidden, W - visibleWidth(head))), body, null, W);
-            }
             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
@@ -804,8 +709,34 @@ 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(noteIndent()));
-                const outcome = c.isError ? `${p.red}${words}${p.reset}` : words;
+                // DC-50 / R14: the key is RESERVED (§7.5), so its width comes
+                // out of the budget BEFORE the tiers are picked — not
+                // appended after, which is what the first build did and
+                // which let a narrow row cut the affordance off entirely.
+                // The tier ladder is what gives way; the key never is.
+                const keySuffix = c.expanded ? ` · ${COLLAPSE_ROW}` : "";
+                const words = pickTier([join(meta, counted, `${elapsed}s`, attr), join(meta, counted, `${elapsed}s`), join(meta, `${elapsed}s`), meta], W - visibleWidth(noteIndent()) - keySuffix.length);
+                // DC-50 / R14 — ONE CARD, ONE SKELETON, expanded or not.
+                //
+                // The expanded card used to take a DIFFERENT shape: its head
+                // row carried the outcome inline (`shell npm test · exit 0 ·
+                // 40 lines · 0.1s`), it had no outcome row at all, and the
+                // `ctrl+o collapses` affordance was a row of its own at the
+                // end of the body. That was defensible while an expanded card
+                // was rare — reachable only for a live or approval-parked
+                // cell — and it stopped being defensible the moment ctrl+o
+                // became a switch that expands EVERY settled card at once: a
+                // page where the same call has two skeletons depending on a
+                // global toggle is the instability this round is named for.
+                //
+                // So both states are pad · head · blank · body · blank ·
+                // outcome · pad. The head row says WHAT was run and nothing
+                // else; the outcome row says what happened, how much, how
+                // long — and carries the affordance, because the affordance
+                // is a fact about this card's state and the outcome row is
+                // where this card's facts live.
+                const withKey = `${words}${keySuffix}`;
+                const outcome = c.isError ? `${p.red}${withKey}${p.reset}` : withKey;
                 return slabBlock(head, body, outcome, W);
             }
             // R13 — nothing to preview: the SAME card, three rows, with the
@@ -863,7 +794,7 @@ class ToolExecution {
             // 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)} `;
+            const gutter = `${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
@@ -923,8 +854,8 @@ class ToolExecution {
  * The affordance is a statement about hidden content: a cell whose body
  * is already whole on screen must not advertise a key that would show it
  * the same thing, and a cell that already carries its own renderer cut
- * (`└ +N earlier rows · ctrl+o`, `└ +N more · ctrl+o`) already teaches
- * the key at the place the content stops. What is LEFT — and it is the
+ * (the `… N · ctrl+o expands` note) already teaches the key at the
+ * place the content stops. What is LEFT — and it is the
  * common case — is every settled non-shell call, whose collapsed body is
  * empty: the whole result sits behind the key with nothing on screen
  * saying so.
@@ -1012,23 +943,13 @@ function settledHeadText(verbCol, target, meta, attr, elapsed, room, counted = "
     const core = join(meta, counted, `${elapsed}s`);
     const withAttr = join(meta, counted, `${elapsed}s`, attr.replace(" · ", ""));
     const lead = `${verbCol} `;
-    const fit = (t, tail) => {
-        const line = `${lead}${t}${tail === "" ? "" : ` · ${tail}`}`;
-        return visibleWidth(line) <= room ? line : null;
-    };
-    // 1. everything
-    const full = fit(target, withAttr);
-    if (full !== null)
-        return full;
-    // 2. the attribution gives way
-    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;
+    const row = (tail) => `${lead}${target}${tail === "" ? "" : ` · ${tail}`}`;
+    // 1. everything; 2. the attribution gives way; 2b. the COUNT gives
+    //    way next (pin 4), where the suffix is not already carrying it —
+    //    the target whole through all three
+    const whole = firstFit([row(withAttr), row(core), row(join(meta, `${elapsed}s`))], room);
+    if (whole !== null)
+        return whole;
     // 3. the target truncates, the core stays whole
     const stem = join(meta, `${elapsed}s`);
     const budget = room - visibleWidth(lead) - visibleWidth(stem) - 4; // the ellipsis + " · "
@@ -1066,15 +987,12 @@ function attribution(c) {
         return "";
     return c.verdict.decision === "denied" ? " · denied" : " · approved";
 }
-export function expandSuffix(lines, room) {
+/** The expand key as a row's tail, in two tiers; empty when there is
+ *  nothing hidden. R13 moved the line COUNT off this suffix onto the
+ *  head row's own `·` chain (VD-6: stated exactly once). */
+function expandSuffix(lines, room) {
     if (lines === null)
         return "";
-    // 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;
@@ -1089,186 +1007,43 @@ function appendSuffix(row, suffix) {
     const p = palette();
     return `${row}${p.dim}${suffix}${p.reset}`;
 }
-/**
- * TUI2-R2 ⑤ (D, candidate 1) — the FOCUS tint.
- *
- * The cell the next ctrl+o will act on brightens its own `ctrl+o` token
- * to the code tint; the rest of the suffix — the separator, the count —
- * stays dim, because what is being marked is the KEY's target, not the
- * row. Zero new rows, zero new columns: the affordance the cell already
- * prints is the marker.
- *
- * Applied to a row rather than composed into it on purpose. The token is
- * emitted from several places (the settled suffix, the renderer's own
- * `└ +N … · ctrl+o` cut rows) and threading a flag through all of them
- * would put the invariant "exactly one bright token" in as many hands as
- * there are emitters. Here it has exactly one.
- *
- * NO_COLOR: p.dim is empty, so the row's bytes are untouched.
- */
-export function focusToken(row, W) {
-    const p = palette();
-    const at = row.lastIndexOf(EXPAND_KEY);
-    if (at !== -1) {
-        // the row already names the key — brighten the token in place, and
-        // leave every other span exactly as it was
-        if (p.dim === "")
-            return row;
-        // DC-3: the marker takes the WASH. It used to take the inline-code
-        // tint and inherited its 1.54:1 — the cue naming the key that
-        // reveals a cell was itself the least readable thing on a white
-        // terminal. The wash is right for a second reason: this token has
-        // to be UNIQUE on the frame ("exactly one bright token"), and an
-        // attribute like bold is spent everywhere. It closes with washEnd
-        // rather than a reset, so the surrounding dim survives instead of
-        // having to be re-applied.
-        return `${row.slice(0, at)}${p.lift}${EXPAND_KEY}${p.dim}${row.slice(at + EXPAND_KEY.length)}`;
-    }
-    // A LIVE row does not carry the affordance today, and the live cell is
-    // the one ctrl+o takes FIRST (expandNext scans the live tail before
-    // the committed ring) — so the row the key is aimed at was the one row
-    // that never said the key existed. The affordance IS the marker here:
-    // it appears on the focused row and nowhere else, which is why no
-    // unfocused row's bytes move (every existing live-row assertion
-    // renders a cell with no focus and is untouched).
-    const room = W - visibleWidth(row);
-    if (room < SUFFIX_MIN)
-        return row; // never at the cost of invariant ①
-    return `${row}${p.dim} · ${p.lift}${EXPAND_KEY}${p.reset}`;
-}
-/** DC-41 — the label in ONE place. The key has moved once now, and
- *  a constant named after its binding is a comment that lies. */
-const EXPAND_KEY = "ctrl+o";
-/** TUI2-R1 (A) — the expanded block's last row: the way back. The
- *  rollup's expanded list carries a second clause (its members' full
- *  outputs live in /last, which the group row cannot show). */
+/* DECLARED REVERSAL (D-S2-1, owner-ruled 2026-09-06): `focusToken` and
+   `EXPAND_KEY` stood here — TUI2-R2 ⑤'s bright ctrl+o token on the
+   newest live card, "exactly one bright token per frame". DC-50 made
+   ctrl+o a global switch, so there was no target left for a marker to
+   name; the status row's idle hint names the switch (`idleHint`). */
+/** TUI2-R1 (A) — the expanded card's key suffix: the way back. */
 const COLLAPSE_ROW = "ctrl+o collapses";
-/** W13 — the rollup opt-in table: which tools collapse, and the count
- *  NOUN (read_file calls → "5 files", list_dir → "5 dirs", search_text
- *  → "5 matches"). Only these tools opt in — a shell burst is never
- *  rolled up (its rows carry meaning). The folded-turn line (W14) reuses
- *  the plurals for its other-tool terms ("2 dirs", "1 match"). */
-export const ROLLUP_NOUN = {
-    read_file: "files",
-    list_dir: "dirs",
-    search_text: "matches",
-};
-// ---- TUI2-R1 (B): the exploration rollup ----
-/** TUI2-R1 (B) — the exploration row's nouns. Deliberately NOT
- *  ROLLUP_NOUN: that table says what a SINGLE-tool rollup counts
- *  ("5 matches"), and this row counts CALLS across tools, where
- *  "14 searches" is what happened. Both tables stay — changing the
- *  older one would move an assertion this round did not declare. */
-const EXPLORE_NOUN = {
-    read_file: ["file", "files"],
-    list_dir: ["dir", "dirs"],
-    search_text: ["search", "searches"],
-};
-/** TUI2-R1 (B) — the verb column of the expanded list names the ACT.
- *  TUI2-R2pre ④: this used to be a private three-tool table saying the
- *  same thing as the card head's `_file` strip, in a different way and
- *  for a different set of tools. Both are `displayVerb` now — the whole
- *  point of the ruling is that there is ONE answer to "what does the
- *  screen call this". The cut note, which used to be the deliberate
- *  exception here, moved with it (see toolCutNote). */
-/** Whether a tool joins an exploration run. Exactly the read-only set —
- *  writes, edits, shells and extension tools never group (a burst of
- *  side effects is a list of things that HAPPENED, and every row of it
- *  carries meaning). */
-export function isExploreTool(name) {
-    return EXPLORE_NOUN[name] !== undefined;
-}
-/** 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
- *  toolStart: read_file → "reads", edit_file → "edits", the other tools
- *  as first-call-order terms (the ROLLUP_NOUN plurals when the tool opts
- *  in, the verb + "s" otherwise).
- *  A9 (ruling R2, mock A): the user chip rides the fold — the human's
- *  words LEAD the one line, `✦ <chip> · thought 19s · read 5 files` —
- *  the chip the SAME SGR-7 bracket as the live user row (#16f, side
- *  pads included). The words take the fold's width budget and width-cut
- *  at the end with the honest "…" (never a silent truncate — invariant
- *  ① holds on the ONE row by construction).
- *
- *  DECLARED SUPERSESSION (R3g, 2026-08-28) — A9 also ruled that "the
- *  metadata terms give way LAST". They do not any more: the KEY does.
- *  A9 was taken when this line carried no key, and at a width where the
- *  chip, the full metadata and " · ctrl+o" cannot coexist, a fold with
- *  no key is the turn's work behind a line with no way back to it. So
- *  the order is now words, then metadata, then — never — the key. The
- *  glyph is ✦ and the zero terms are dropped (R3b), so the example above
- *  is written as the code renders it rather than as A9 first wrote it. */
-/**
- * R3b — what a run of work DID, in words. One definition, because two
- * surfaces say it: the fold line (`turnFold`, above) and the expand
- * header the compositor writes when that fold is opened. A second copy
- * would be a second answer to the same question, and the first thing to
- * drift would be the plurals — `search_text` is "matches", not
- * "searchs", and only the ROLLUP_NOUN table knows that.
- *
- * Zero terms are dropped (owner ruling, R3b): a term earns its place by
- * having a count.
- */
-/**
- * R3g (2026-08-28) — the fold's own terms, VERB + COUNT + NOUN.
- *
- * DECLARED SUPERSESSION. R3b built these terms out of ROLLUP_NOUN,
- * whose own comment says not to: that table names what a single-tool
- * rollup COUNTS ("5 matches" — five matched lines), and this line
- * counts CALLS. So one search_text call rendered `1 match`, a sentence
- * that is false whenever the search matched any other number — which is
- * almost always. `shell` fell through to the verb branch and read
- * `4 shells`.
- *
- * The phrasing is the owner's, from the shape they asked for:
- * "thought 17s · read 4 files · listed 1 directory · ran 4 shell
- * commands". A tool with no entry says `3 × <verb>`, which counts calls
- * without inventing a noun for them.
- */
+/* DECLARED REVERSAL (R13, owner-ruled 2026-09-03): the W13 rollup's
+   noun table (`ROLLUP_NOUN`) and TUI2-R1 (B)'s exploration-run set
+   (`EXPLORE_NOUN`, `isExploreTool`) stood here. Both collapses retired
+   with the fold; the verb column is `displayVerb` for every tool. */
 /**
- * R3i — ONE TERM TABLE, TWO TENSES: [past, progressive, singular, plural].
- *
- * The stretch line is the same row at every instant of a turn: while
- * the work runs it says what it is DOING, and at the settle it says
- * what it DID. That sentence is only true if both tenses come from one
- * table. The v9 review found the alternative already happening on a
- * hand-written prototype — `searching 1 pattern` live against `ran 1
- * search` settled, the NOUN swapping at the settle, and `running 4
- * shells`, which is verbatim the R3g defect the previous round removed.
- *
- * FOLD_TERM below is derived from this, so the settled vocabulary
- * cannot drift from the live one by construction.
+ * THE TERM TABLE — [past, singular, plural], one row per tool the recap
+ * names (R3g's phrasing, the owner's: "thought 17s · read 4 files ·
+ * listed 1 directory · ran 4 shell commands"). A tool with no entry
+ * says `3 × <verb>`, which counts calls without inventing a noun for
+ * them; a zero term is dropped (R3b: a term earns its place by having a
+ * count). The terms count CALLS, which is what the CLI hands them.
+ *
+ * DECLARED REVERSAL (R13, owner-ruled 2026-09-03): this table served
+ * the folded-turn line (W14, `turnFold`) and R3i's stretch line, and
+ * carried a PROGRESSIVE column so the live tense and the settled tense
+ * could not drift apart. Nothing folds and nothing reads the
+ * progressive; the recap (`foldTerms`) is the table's only reader.
+ * R3h's object-vs-act distinction (`foldCountsObjects`) retired with
+ * the fold that consumed it.
  */
 const TERM = {
-    read_file: ["read", "reading", "file", "files"],
-    edit_file: ["edited", "editing", "file", "files"],
-    write_file: ["wrote", "writing", "file", "files"],
-    list_dir: ["listed", "listing", "directory", "directories"],
-    search_text: ["ran", "running", "search", "searches"],
-    shell: ["ran", "running", "shell command", "shell commands"],
+    read_file: ["read", "file", "files"],
+    edit_file: ["edited", "file", "files"],
+    write_file: ["wrote", "file", "files"],
+    list_dir: ["listed", "directory", "directories"],
+    search_text: ["ran", "search", "searches"],
+    shell: ["ran", "shell command", "shell commands"],
 };
-const FOLD_TERM = Object.fromEntries(Object.entries(TERM).map(([name, [past, , singular, plural]]) => [name, [past, singular, plural]]));
-/**
- * R3h (fable, 2026-08-29) — WHICH TERMS COUNT OBJECTS.
- *
- * The rule, one sentence: a term that counts OBJECTS counts distinct
- * objects; a term that counts ACTS counts calls. `read 2 files` after
- * reading ONE file twice is a false sentence, and law 1.3 does not
- * become optional because the falsehood is small. `ran 2 searches`
- * after searching the same pattern twice is TRUE — the acts happened.
- *
- * The table sits beside FOLD_TERM so the two cannot drift: a tool whose
- * noun is a thing ("files", "directories") belongs here; a tool whose
- * noun is an act ("searches", "shell commands") does not.
- */
-const FOLD_COUNTS_OBJECTS = new Set(["read_file", "edit_file", "write_file", "list_dir"]);
-/** Does this tool's fold term count distinct targets rather than calls? */
-export function foldCountsObjects(name) {
-    return FOLD_COUNTS_OBJECTS.has(name);
-}
 function foldTerm(name, n) {
-    const t = FOLD_TERM[name];
+    const t = TERM[name];
     if (t === undefined)
         return `${n} × ${displayVerb(name)}`;
     return `${t[0]} ${n} ${n === 1 ? t[1] : t[2]}`;
@@ -1286,41 +1061,6 @@ export function foldTerms(reads, edits, others) {
     }
     return parts;
 }
-/**
- * R3i — THE STRETCH LINE: the turn's one working row, in three phases.
- *
- * A STRETCH is the run of thinking and tool calls between two blocks of
- * the model's prose. While it runs it is this line plus a bounded act
- * window; when it closes it commits as this same line, frozen, with its
- * key. The contract in one sentence: **the line you watch is the line
- * you keep** — the settle changes the mark, the tense and the key, and
- * nothing else.
- *
- *   thinking   ✧ thinking 4s
- *   acting     ✶ reading 6 files · running 4 shell commands
- *   settled    ✦ thought 9s · read 6 files · ran 4 shell commands · ctrl+o
- *
- * THE GIVE-WAY LADDER, in order, because at some width everything
- * cannot fit:
- *
- *   1. the human's WORDS (the A9 chip on a quiet turn) — they are on
- *      screen above, in the chip band;
- *   2. the NOUNS compact, cheapest word first, and stop as soon as the
- *      row fits — buying one cell must not spend every substitution;
- *   3. the COUNTS cut, with the honest "…";
- *   4. the TROUBLE CLAUSE cuts. The design first said it never gives
- *      way, and that was unimplementable: a long clause overflows after
- *      the counts have already cut to a bare "…", and invariant ①
- *      throws on that row;
- *   5. the KEY gives way NEVER. A fold with no key is the turn's work
- *      behind a line with no way back to it, which is the one thing
- *      this row must not be.
- *
- * `…` in this file means CUT HERE and nothing else — which is why the
- * live phases carry no trailing ellipsis for in-flight, though the
- * reference implementation uses one. The moving mark and the present
- * tense already say it twice.
- */
 /**
  * R3i phase 5 — THE ANSWERED QUESTION'S BLOCK.
  *
@@ -1338,7 +1078,7 @@ export function foldTerms(reads, edits, others) {
  * is emphasis, never information). A typed answer says `(typed)`,
  * because where an answer came from is a fact about it.
  *
- * It is WORDS, not work (law 1.7): it never folds into a stretch line,
+ * It is WORDS, not work (law 1.7): no summary ever stands for it,
  * because the one thing a summary must not do is speak for the human.
  *
  * A result that is not the ask's own JSON yields NOTHING. This renderer
@@ -1376,45 +1116,11 @@ export function askedBlock(resultText, seconds, W) {
         }),
     ];
 }
-const STRETCH_COMPACT = [
-    ["directories", "dirs"],
-    ["directory", "dir"],
-    ["shell commands", "commands"],
-    ["shell command", "command"],
-];
-/** R3i — a stretch of exactly ONE call names its TARGET instead of its
- *  count. `thought 2s · read 1 file` replaces two rows — the thinking
- *  and the call — with a row that says less than either of them did,
- *  and "thinking plus one call" is the commonest shape a narrating
- *  model makes. This is the answer to the defect R3d killed R3b's
- *  per-segment folds over; the "absorbs at least two rows" rule alone
- *  does not answer it. */
-function stretchTerms(t, live) {
-    // R4 — the tense is per TERM. A name with nothing in flight is in the
-    // past whatever the line's own phase is; with liveNames absent (the
-    // settled line) every term follows the line.
-    const tense = (name) => (live && (t.liveNames === undefined || t.liveNames.includes(name)) ? 1 : 0);
-    const total = t.calls.reduce((n, [, c]) => n + c, 0);
-    // R4 — the one-call TARGET form is the SETTLED line's. Live, the act
-    // slot directly below already names the target on its head row, so
-    // the line was printing the same words twice, one above the other
-    // (`running npm run check` over `shell npm run check`). Settled there
-    // is no slot, and naming the target is strictly more than counting to
-    // one — which is the R3i rule this keeps, where it applies.
-    if (total === 1 && t.targets.length === 1 && !live) {
-        const [name] = t.calls[0];
-        const e = TERM[name];
-        return [`${e === undefined ? name : e[0]} ${t.targets[0]}`];
-    }
-    return t.calls
-        .filter(([, n]) => n > 0)
-        .map(([name, n]) => {
-        const e = TERM[name];
-        if (e === undefined)
-            return `${n} × ${displayVerb(name)}`;
-        return `${e[tense(name)]} ${n} ${n === 1 ? e[2] : e[3]}`;
-    });
-}
+/* DECLARED REVERSAL (R13, owner-ruled 2026-09-03): the stretch line's
+   term machinery stood here — `StretchTerms`, `STRETCH_COMPACT`,
+   `stretchTerms` (R3i's one-line-per-stretch, R4's per-term tense).
+   The line retired with the fold; the TERM table above survives for the
+   turn's recap alone. */
 // ---- 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. */
@@ -1424,14 +1130,7 @@ 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
-/** 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
- *  distinguishes the states at --plain). Structural (constraint 1). */
 /** R8a — A TOOL BLOCK'S ROWS ARE INDENTED, NOT GUTTERED.
  *
  *  `│ ` on every row drew a bar down the left of every multi-row
@@ -1445,8 +1144,7 @@ const CAP_DIFF = 12; // the approval diff: head + the named middle + tail
  *  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. */
+ *  surfaces that are not a tool block. */
 /** 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
@@ -1516,10 +1214,18 @@ function slabRow(inner, W) {
  *  metadata rows: the parts give way in a PINNED ORDER, and the part
  *  that carries the semantics is the one reserved. */
 function pickTier(tiers, room) {
+    return firstFit(tiers, room) ?? tiers[tiers.length - 1];
+}
+/** The widest form that fits the row, or null when none does — the
+ *  settled head row asks this with its target whole, and only then
+ *  cuts the target. The three rows that give way in a pinned order
+ *  (the settled head, the running head, the outcome row) share this
+ *  walk; their ORDERS differ by ruling and stay their own. */
+function firstFit(tiers, room) {
     for (const t of tiers)
         if (visibleWidth(t) <= room)
             return t;
-    return tiers[tiers.length - 1];
+    return null;
 }
 function noteRow(text, W, tone) {
     const p = palette();
@@ -1570,30 +1276,20 @@ function slabBlock(head, body, outcome, W) {
         return [...top, slabRow("", W)];
     return [...top, slabRow("", W), ...noteRow(outcome, W, "body").map((r) => slabRow(r, W)), slabRow("", W)];
 }
-/**
- * 0.24.2 ③ — the appended expansion, as a CARD.
- *
- * `ctrl+o` used to append bare ground under a `✦` — the turn recap's own
- * mark, one symbol for two meanings (§4.1) — in a page where every other
- * piece of machine work is a card. And it lands after the recap, so the
- * only tie to the call it came from was that mark's sentence.
+/*
+ * RETIRED (DC-50 / R14, 2026-09-05) — `expandedCard`.
  *
- * The card's head row names the call, which is the tie, so the mark is
- * not needed for it. The body is the WHOLE result: an expansion that
- * capped would be no expansion.
+ * It drew the APPENDED block the old ctrl+o produced: a card printed far
+ * below the call it belonged to, which is why its head row had to carry
+ * `expanded · N turns back` and why its body carried section headers
+ * around the raw input and output. All of that was addressing — a way
+ * for a copy to say which original it was a copy of.
  *
- * Expanding IN PLACE is a different problem — committed rows are final
- * (§7.1) — and it waits for route B (DC-50).
+ * DC-50 removes the copy. An expanded card is the ordinary `toolCard`
+ * with `expanded` set, rendered where the call stands, so nothing needs
+ * to say where it came from. Its shape is gated in
+ * `r13-rhythm-surface.test.ts`.
  */
-export function expandedCard(verb, target, meta, sections, outcome, W) {
-    const p = palette();
-    const head = cutLine(`  ${verb} ${p.bold}${escapeTerminal(target)}${p.reset}${slabPaints() ? p.washDim : p.dim} · ${escapeTerminal(meta)}${slabPaints() ? p.washDimEnd : p.reset}`, W);
-    const body = [];
-    for (const raw of sections)
-        for (const row of blockRows(raw, W, slabPaints() ? "body" : "dim"))
-            body.push(row);
-    return slabBlock(head, body, outcome, W);
-}
 /** 0.24.2 ② — the live region's `thinking…` placeholder: dim italic at
  *  column 2, no glyph, the SAME shape a thinking paragraph takes so that
  *  whatever arrives replaces it in place. Never committed — see the
@@ -1687,7 +1383,13 @@ function toolBlockParts(c, W, ctx) {
     // 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)
+    //
+    // DC-50 / R14: a SETTLED card carries the affordance on its OUTCOME
+    // row instead, so that both states have one skeleton. This footer is
+    // for the states that have no outcome row to carry it — a card parked
+    // for approval, or one still running that was expanded before it
+    // settled.
+    if (c.expanded && rows.length > 0 && c.state !== "done")
         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
@@ -1861,91 +1563,12 @@ function liveCap(c, room) {
     liveHighWater.set(c, cap);
     return cap;
 }
-/**
- * R4 — the standing act slot.
- *
- * The stretch's ONE line sits above it; this is the region under it,
- * and it STANDS: allocated when the stretch opens, released at the
- * fold.
- *
- * R3i built the same window INTERMITTENTLY — a running call got its
- * fixed 1+3 block (W8), a finished one got nothing — so the live
- * region's height was a function of how many calls happened to be in
- * flight this frame. Over one real stretch that is 2 rows, then 7,
- * then 2, then 17 for a three-call batch, then 2 again, and every
- * transition scrolls everything above it. The owner's report was that
- * the screen "keeps jumping", and it was an accurate description of
- * the design, not a defect in its execution.
- *
- * The cure is not a smaller window, it is a STANDING one: between two
- * calls the slot keeps the call that just finished rather than
- * collapsing, and before any call it keeps the thinking that is
- * producing them — which is R3i ruling 5 ("thinking belongs on the
- * stretch line, IN THE ACT WINDOW, and in full in expansions") finally
- * wired, since R3i stated it while building no window for the thinking
- * phase to live in.
- *
- * Four rows, deliberately the same 1+3 shape W8 gave a running call, so
- * the commonest frame — exactly one call in flight — renders byte-for-
- * byte what 0.17.0 shipped.
- */
-export const ACT_SLOT_ROWS = 4;
-/**
- * R4 — the slot's body rows: the tail of `text`, newest at the BOTTOM,
- * bottom-padded to exactly `rows`.
- *
- * The same dim │ gutter a running call's window uses (W2's table), and
- * the same two VD-4 rules: leading blank gutters are skipped, and the
- * short-output pad goes at the BOTTOM so output starts under its own
- * header and grows downward. The slot's CONTENTS change; its shape
- * does not.
- */
-export function slotTail(text, W, rows) {
-    if (rows <= 0)
-        return [];
-    const p = palette();
-    const all = blockRows(text, W);
-    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
-    // nothing to say yet, which is the hole a7's blank-run guard prices.
-    // R8a: the corner opens whatever slice survives the cap.
-    return openBlock(body.slice(Math.max(0, body.length - rows)));
-}
-/** R4 — clamp or pad assembled slot rows to EXACTLY `rows`. The padding
- *  is what makes the slot stand; the clamp is what keeps the slot from
- *  ever being the thing that trips the force-commit cap (a slot that
- *  could overflow would commit real cells to relieve blank rows). */
-export function slotPad(content, rows) {
-    if (rows <= 0)
-        return [];
-    // R7a — THE SLOT NO LONGER PADS. It caps, and that is all.
-    //
-    // R4 padded to a fixed height because the slot's content came and
-    // went: a finished call left the block, the block shrank, and every
-    // row above it moved. The pad bought stability with rows drawn as
-    // `│`, which is why a tall empty gutter ran down the screen under
-    // every short block — the owner's own screenshot, and law 1.3's
-    // case: a mark on a row with nothing to mark.
-    //
-    // Blanking the gutter revealed the hole it had been covering, and
-    // the a7 replay priced the hole: blank runs over 2 in 653 of 733
-    // frames, the screen never durably filling. So the pad had to go —
-    // and the height it was buying is now bought by the CONTENT, since
-    // R7a keeps every call's row for the life of the stretch. A block
-    // whose rows only accumulate cannot shrink, so there is nothing
-    // left for a pad to hold up. Measured: 65 of 733 at 40x24, the
-    // pre-R7a number exactly, with the motion gates still green.
-    return content.slice(0, rows);
-}
-/** R4 — the slot's overflow row: the calls in flight beyond the head
- *  budget. It lives INSIDE the slot (it is one of the four rows), which
- *  is what keeps a parallel burst from growing the region. */
-export function moreRunningRow(n, W) {
-    const p = palette();
-    return cutLine(`  ${p.dim}${CUT_ROW}+${n} more running${p.reset}`, W);
-}
+/* DECLARED REVERSAL (R13, owner-ruled 2026-09-03): R4's standing act
+   slot stood here — `ACT_SLOT_ROWS`, `slotTail`, `slotPad`,
+   `moreRunningRow` — a fixed four-row region that held the stretch's
+   running call so the live region's height would not follow the call
+   count. Every call is its own card now, allocated at its own height
+   (E2, DC-46), so there is no slot for a call to occupy. */
 /** W12: the delegate's child sessions collapse to the tool row plus ONE
  *  line — the height NEVER changes (running → settled replaces the row
  *  in place). The running row derives from the INPUT: the parent has no
@@ -2146,45 +1769,6 @@ class Banner {
  *  done-collapse. Every live row CUTS at W (never folds) — the block's
  *  height is its row count. */
 export const CAP_TASK_LIVE = 6;
-/** W20 — the live block's fixed-window row cut: an SGR-aware ONE-ROW
- *  truncation (foldLine wraps; a wrapped row would break the height
- *  cap — every live row is exactly one screen row at every width).
- *  A line that fits (≤ W) passes through whole; an overflow cuts the
- *  content at W−1 — the ellipsis's slot — and the ellipsis rides AFTER
- *  the reset (post-reset — the PTY needles' convention). The cut row
- *  never exceeds W (invariant ①). W21: exported for the approval
- *  panel's single-row lines (the rule line, the title, the divider,
- *  the options/affordance rows). */
-export function cutLine(line, W) {
-    if (visibleWidth(line) <= W)
-        return line;
-    let out = "";
-    let width = 0;
-    for (let i = 0; i < line.length;) {
-        if (line[i] === "\x1b") {
-            // exec returns an ARRAY — copying m coerces it (the match), but
-            // m.length is the CAPTURE count (1), not the sequence length:
-            // the old `i += m.length` re-processed the sequence's bracket
-            // text as literal rows, doubling every code in a cut line
-            // (the W21 panel-slot red test). Index 0 is the sequence.
-            const m = /^\x1b\[[0-9;]*m/.exec(line.slice(i))?.[0] ?? line[i];
-            out += m;
-            i += m.length;
-            continue;
-        }
-        const cw = displayWidth(line[i]);
-        if (width + cw > W - 1)
-            break; // reserve the ellipsis's column
-        out += line[i];
-        width += cw;
-        i += 1;
-    }
-    // R8a: the reset comes from the PALETTE, not hardcoded. `\x1b[0m`
-    // here put an escape into every cut row under NO_COLOR and behind a
-    // pipe — the one context COLOR_OFF exists to keep clean (§1.2). A
-    // coloured palette is byte-identical, because its reset IS `\x1b[0m`.
-    return `${out}${palette().reset}…`;
-}
 /** W20 — the settled block's duration, the `2h 14m` form (the task
  *  narrative's long-horizon idiom): minutes+seconds under an hour,
  *  hours+minutes past it. */
@@ -2259,7 +1843,7 @@ class Checklist {
         return [cutLine(header, W), ...itemRows.map((r) => cutLine(r, W))];
     }
 }
-// ---- the chrome components (the status container, the slot, the footer) ----
+// ---- the chrome components (the status container, the footer) ----
 /** The status container's row: the status text (+ the tail) with the
  *  right-aligned "/ commands · ↑ history" hint in the idle state —
  *  the hint CUT FIRST when the width is short (the #16g rule); when
@@ -2282,20 +1866,28 @@ class Checklist {
  *  survives longest because it is the door to everything; `ctrl+r`
  *  outranks `↑ history` because pressing up is how a person finds the
  *  history by accident, and nothing finds ctrl+r by accident. */
-export function idleHint(room) {
+export function idleHint(room, expand = null) {
     // The third rung is today's hint, kept so that NO width loses
     // something that used to fit: without it, a room of 24-30 columns
     // fell all the way to `/ commands` even though the old form fitted.
     // So the ladder is not a strict ranking of the three affordances —
     // it is the widest honest form at each room, and ctrl+r is on the
     // first two rungs rather than on all of them.
-    for (const form of [" / commands · ↑ history · ctrl+r transcript", " / commands · ctrl+r transcript", " / commands · ↑ history", " / commands"]) {
+    //
+    // D-S2-1 (owner-ruled 2026-09-06): the ctrl+o SWITCH is named on the
+    // two widest rungs, beside ctrl+r, and only while a card on screen
+    // has something behind the key — the caller passes null otherwise,
+    // and the ladder is then exactly the one above. It replaced the
+    // per-card bright token (TUI2-R2 ⑤): a global switch has no single
+    // target to mark.
+    const switchRungs = expand === null ? [] : [` / commands · ↑ history · ctrl+o ${expand} · ctrl+r transcript`, ` / commands · ctrl+o ${expand} · ctrl+r transcript`];
+    for (const form of [...switchRungs, " / commands · ↑ history · ctrl+r transcript", " / commands · ctrl+r transcript", " / commands · ↑ history", " / commands"]) {
         if (visibleWidth(form) <= room)
             return form;
     }
     return "";
 }
-export function statusLine(status, tail, W, hint) {
+export function statusLine(status, tail, W, hint, expand = null) {
     const p = palette();
     const text = `${status}${tail === "" ? "" : ` · ${tail}`}`;
     // W18: the hint is a parameter — the compacting row right-aligns its
@@ -2306,25 +1898,12 @@ export function statusLine(status, tail, W, hint) {
     if (statusW > W) {
         return `${p.dim}${widthCut(text, W - 1)}…${p.reset}`;
     }
-    const hintText = hint ?? idleHint(Math.max(0, W - statusW));
+    const hintText = hint ?? idleHint(Math.max(0, W - statusW), expand);
     const hintW = visibleWidth(hintText);
     if (hintW === 0 || statusW + hintW > W)
         return `${p.dim}${text}${p.reset}`;
     return `${p.dim}${text}${" ".repeat(Math.max(0, W - statusW - hintW))}${hintText}${p.reset}`;
 }
-/** The display-width prefix of a plain (SGR-free) text. W21: exported
- *  for the approval panel's option-2 rule-name cut. */
-export function widthCut(text, max) {
-    let w = 0;
-    let i = 0;
-    for (; i < text.length; i += 1) {
-        const cw = displayWidth(text[i]);
-        if (w + cw > max)
-            break;
-        w += cw;
-    }
-    return text.slice(0, i);
-}
 /**
  * TUI2-R3v2 ① — THE selection bar. One engine, every selection surface.
  *