@vincemakes/kiso-tui 0.1.37 → 0.1.39

package/dist/compositor.js

@@ -35,22 +35,29 @@
  *    scheduler — a one-shot setTimeout re-armed only while a running
  *    tool exists (the #14/#15 zero-output contract is structural).
  *
- * Layout at H rows (V6-3 — the design §03 chrome): content rows
- * 1..H−4, upper ╌ H−3, editor (the slot) H−2, lower ╌ H−1, status H.
+ * Layout at H rows (V6-3 — the design §03 chrome; W6 — the box):
+ * content rows 1..H−4, box top H−3, editor (the slot) H−2, box
+ * bottom H−1, status H.
  * Pipes / NO_COLOR: the passthrough branches below keep the v2a/v2b
  * line-mode bytes byte-for-byte (the e2e guards them).
  */
 import { truncateDiff } from "./diff.js";
 import { displayWidth } from "./editor.js";
-import { Container, SPINNER, bodySpacing, cellComponent, foldLine, footerLine, statusLine, visibleWidth, } from "./components.js";
-import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary } from "./render.js";
+import { Container, ROLLUP_NOUN, SPINNER, bodySpacing, boxBottom, boxTop, cellComponent, foldLine, statusLine, turnFold, visibleWidth, } from "./components.js";
+import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, toolTarget } from "./render.js";
 /** The cursor marker — an APC private sequence the focus component
  *  embeds at the edit position; the compositor strips it and moves
  *  relatively (it never reaches the terminal). */
 export const CURSOR_MARKER = "\x1b_[kiso-cur]\x1b\\";
 const FRAME_MS = 16; // state changes coalesce to ≥16ms frames
 const SPINNER_MS = 200; // the spinner cadence — a ONE-SHOT re-armed on demand
-const CHROME_ROWS = 4; // upper ╌ + input + lower ╌ + status — the design §03 chrome (V6-3)
+const CHROME_ROWS = 4; // box top + input + box bottom + status — the design §03 chrome (V6-3; the box is W6)
+/** W20 — the whole-table-replace comparison: the live task block only
+ *  redraws when the items actually changed (the task extension's
+ *  idempotent shape — an unchanged replace is a no-op, no frame). */
+function sameTask(a, b) {
+    return a.length === b.length && a.every((x, i) => x.text === b[i].text && x.status === b[i].status);
+}
 /** The one compositor — implements the Body façade AND the Dock chrome
  *  API (see the class comments on each method group). */
 export class Body {
@@ -74,6 +81,19 @@ export class Body {
     #pendingCalls = new Map();
     #pipeBuf = ""; // the passthrough's thinking buffer
     #toolCells = new Map(); // callId → cell index (parallel tools)
+    // W15: the collapsed (cut) tool cells — committed cells whose last
+    // rendered row carried the "ctrl+r" affordance; the expand key's
+    // cycling pointer walks this list from the newest back.
+    #collapsed = [];
+    #expandPtr = 0;
+    // W14: the turn records — one per userLine, the fold-hold's state
+    // machine (ended / hasText / folded) plus the folded-turn line's
+    // counts (accumulated at toolStart). The cells carry the record's
+    // index as their turn boundary.
+    #turns = [];
+    // W13: the rolled-up run heads — the commit-time scan's verdict:
+    // the head's group summary renders, the members render [].
+    #rolledHeads = new Set();
     #write;
     #resizeHandler = null;
     // the chrome state (the Dock façade)
@@ -119,7 +139,10 @@ export class Body {
         }
         this.#closeOpenThinking();
         this.#closeOpenText();
-        this.#cells.push({ kind: "user", text, done: true });
+        // W14: the turn boundary — the record the fold-hold's release
+        // state machine reads; the cell carries the record's index.
+        this.#turns.push({ ended: false, hasText: false, thoughtSeconds: 0, reads: 0, edits: 0, others: new Map(), folded: false });
+        this.#cells.push({ kind: "user", text, done: true, turn: this.#turns.length - 1 });
         this.#mark();
     }
     thinkingAppend(text) {
@@ -132,7 +155,7 @@ export class Body {
             last.text += text;
         }
         else {
-            this.#cells.push({ kind: "thinking", text, done: false });
+            this.#cells.push({ kind: "thinking", text, done: false, turn: this.#turns.length - 1 });
         }
         this.#mark();
     }
@@ -166,7 +189,19 @@ export class Body {
             }
         }
         this.#toolCells.set(callId, this.#cells.length);
-        this.#cells.push({ kind: "tool", name, input: summary, childRoles, state: "pending", isError: false, resultText: "", diff: null, added: 0, removed: 0, startedAt: null, doneAt: null, done: false });
+        this.#cells.push({ kind: "tool", name, input: summary, inputFull: JSON.stringify(input, null, 2), childRoles, state: "pending", isError: false, resultText: "", diff: null, added: 0, removed: 0, startedAt: null, doneAt: null, done: false, expanded: false, turn: this.#turns.length - 1, rolled: null, reason: null });
+        // W14: the turn record's counts — the folded-turn line's terms
+        // (reads = read_file, edits = edit_file, the rest in first-call
+        // order). The CLI's recap counts the same way (edit_file).
+        const turn = this.#turns[this.#turns.length - 1];
+        if (turn !== undefined) {
+            if (name === "read_file")
+                turn.reads += 1;
+            else if (name === "edit_file")
+                turn.edits += 1;
+            else
+                turn.others.set(name, (turn.others.get(name) ?? 0) + 1);
+        }
         this.#mark();
     }
     toolApproval(callId, diff) {
@@ -213,8 +248,11 @@ export class Body {
             this.#pendingCalls.delete(callId);
         }
         if (!this.#isActive()) {
+            // W19: the pipe path renders the SAME pinned deny row (the
+            // reason in the W4 parentheses idiom), byte-clean — plus the
+            // folded [result ✗] body below (never hide information).
             const p = palette();
-            this.#write(`${renderToolSummary(call?.name ?? "?", call?.input ?? {}, result)}\n` +
+            this.#write(`${renderToolSummary(call?.name ?? "?", call?.input ?? {}, result, result.reason ?? null)}\n` +
                 `${p.dim}${result.isError ? p.red : p.dim}  [result${result.isError ? " ✗" : ""}] ${foldResult(result.content)}${p.reset}\n`);
             return;
         }
@@ -224,6 +262,7 @@ export class Body {
             cell.state = "done";
             cell.isError = result.isError;
             cell.resultText = result.content;
+            cell.reason = result.reason ?? null;
             cell.doneAt = Date.now();
             cell.done = true;
         }
@@ -236,6 +275,12 @@ export class Body {
             this.#write(escapeTerminal(text));
             return;
         }
+        // W14: the text's arrival RELEASES the fold-hold — the turn now
+        // has text, its held cells commit individually (with the W13
+        // rollups; the fold is only for the QUIET turn).
+        const turn = this.#turns[this.#turns.length - 1];
+        if (turn !== undefined)
+            turn.hasText = true;
         const last = this.#cells[this.#cells.length - 1];
         if (last !== undefined && last.kind === "text" && !last.done) {
             last.text += text;
@@ -257,6 +302,51 @@ export class Body {
             last.done = true;
         this.#mark();
     }
+    /** W14 — the turn boundary's END: the CLI calls this at the run's
+     *  terminal event, once per run, BEFORE the recap (so the fold line
+     *  commits before the recap in the cell order). `thoughtSeconds` is
+     *  the CLI's wall-clocked thinking window. The QUIET turn (ended, no
+     *  text) releases its held cells as the ONE fold line; a turn with
+     *  text releases them as individual commits (the W13 rollups). The
+     *  release is LAZY — the held cells commit at the next frame, when
+     *  the fold/rollup decision runs. */
+    endTurn(thoughtSeconds) {
+        if (!this.#isActive())
+            return;
+        const turn = this.#turns[this.#turns.length - 1];
+        if (turn === undefined || turn.ended)
+            return;
+        turn.ended = true;
+        turn.thoughtSeconds = thoughtSeconds;
+        // W20: the turn's live task block settles HERE — the ONE recap
+        // block for the turn ("`task done · N items · <duration>", the
+        // duration clocked compositor-side from the block's first call —
+        // the CLI stays unchanged). A turn that never touched the list has
+        // no live block — nothing settles. Newest-first: the live block is
+        // the newest cell of its turn.
+        for (let i = this.#cells.length - 1; i >= 0; i -= 1) {
+            const c = this.#cells[i];
+            if (c.kind === "checklist" && !c.done) {
+                c.done = true;
+                c.durationSeconds = Math.max(0, Math.round((Date.now() - c.startedAt) / 1000));
+                break;
+            }
+        }
+        // the QUIET turn: an open thinking cell closes at the boundary —
+        // its natural closer is the text's arrival (never comes here — the
+        // text-less turn), so without this the fold could never commit AT
+        // it (the commit loop only takes done cells — the fold would stall
+        // forever behind the live thinking).
+        for (let i = this.#cells.length - 1; i >= 0; i -= 1) {
+            const c = this.#cells[i];
+            if (c.kind === "thinking" && !c.done) {
+                c.done = true;
+                this.#lastThinking = c.text;
+                break;
+            }
+        }
+        this.#mark();
+    }
     terminal(label, statusLineText) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
@@ -281,6 +371,17 @@ export class Body {
         this.#cells.push({ kind: "notice", text, done: true });
         this.#mark();
     }
+    /** W20 — the task checklist as STATE, not events: the FIRST call of a
+     *  turn creates the ONE live block (done:false — the commit loop only
+     *  takes done cells, so it stays in the live region); later calls of
+     *  the SAME turn MUTATE that block in place — same position, same
+     *  height, zero committed rows (the W8 fixed-window rule generalised
+     *  to state). An unchanged whole-table replace (the task extension's
+     *  idempotent shape) is a no-op — no mark, no frame. The block commits
+     *  ONCE at the turn's end (endTurn); the next turn's first call starts
+     *  a fresh block — one settled block per turn that touched the list,
+     *  never one per update. The pipe path stays per-call (byte-linear —
+     *  every write is final; there is no in-place redraw in a pipe). */
     checklist(header, items) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
@@ -294,7 +395,25 @@ export class Body {
         }
         this.#closeOpenThinking();
         this.#closeOpenText();
-        this.#cells.push({ kind: "checklist", header, items, done: true });
+        const turn = this.#turns.length - 1;
+        const last = this.#cells[this.#cells.length - 1];
+        if (last !== undefined && last.kind === "checklist" && !last.done && last.turn === turn) {
+            if (!sameTask(last.items, items)) {
+                Object.assign(last, { header, items });
+                this.#mark();
+            }
+            return;
+        }
+        this.#cells.push({
+            kind: "checklist",
+            header,
+            items,
+            done: false,
+            expanded: false,
+            startedAt: Date.now(),
+            durationSeconds: 0,
+            turn,
+        });
         this.#mark();
     }
     /** The startup banner (W1): a LIVE cell — the tier re-derives per
@@ -342,6 +461,77 @@ export class Body {
     lastTool() {
         return this.#lastTool;
     }
+    /** W15 — the expand key's target (ctrl+r). A cell still in the LIVE
+     *  region (the newest live tool) TOGGLES in place — the compositor
+     *  owns those rows and redraws them (the body flips to the full
+     *  form, no cap). A committed cell can never toggle — history is
+     *  never rewritten (ADR-0046) — so the key APPENDS a fresh expanded
+     *  block at the bottom instead, the /last idiom aimed at a chosen
+     *  cell: the pointer cycles the collapsed history, newest first, and
+     *  the header names the target ("N turns back" — the user cells
+     *  after it), so every press tells the user what they got. */
+    expandNext() {
+        for (let i = this.#cells.length - 1; i >= this.#committed; i -= 1) {
+            const cell = this.#cells[i];
+            if (cell.kind === "tool" && cell.state !== "pending") {
+                cell.expanded = !cell.expanded;
+                this.#mark();
+                return { kind: "toggled" };
+            }
+            // W20: the LIVE task block toggles in place too — the capped
+            // form flips to the full list (the "done-collapse expands
+            // under ctrl+r" claim). The SETTLED block is already full —
+            // no toggle, and its rows carry no affordance, so it never
+            // joins #collapsed (the committed /last append is moot).
+            if (cell.kind === "checklist" && !cell.done) {
+                cell.expanded = !cell.expanded;
+                this.#mark();
+                return { kind: "toggled" };
+            }
+        }
+        if (this.#collapsed.length === 0)
+            return { kind: "none" };
+        const idx = this.#collapsed[this.#expandPtr % this.#collapsed.length];
+        this.#expandPtr += 1;
+        const cell = this.#cells[idx];
+        if (cell.kind !== "tool")
+            return { kind: "none" };
+        if (cell.rolled !== null) {
+            // W13: a rolled-up head expands to the FULL per-call children —
+            // the rollup showed the first 3 + the overflow; the expand shows
+            // every target, one └ row each (the /last idiom — the children
+            // land as NEW content, history is never rewritten, ADR-0046).
+            const turnsBack = this.#cells.slice(idx + 1).filter((c) => c.kind === "user").length;
+            const p = palette();
+            const noun = ROLLUP_NOUN[cell.name] ?? "calls";
+            const header = `${p.bold}▞${p.reset} expanded · ${escapeTerminal(`${cell.name.replace("_file", "")} ${cell.rolled.count} ${noun}`)} · ${turnsBack} ${turnsBack === 1 ? "turn" : "turns"} back`;
+            return {
+                kind: "appended",
+                lines: [header, ...cell.rolled.targets.map((t) => `  ${p.dim}└ ${escapeTerminal(t)}${p.reset}`)],
+            };
+        }
+        let input = {};
+        try {
+            input = JSON.parse(cell.inputFull);
+        }
+        catch {
+            // the full JSON is always parseable (it was stringified at
+            // toolStart) — the empty fallback never fires
+        }
+        const turnsBack = this.#cells.slice(idx + 1).filter((c) => c.kind === "user").length;
+        const p = palette();
+        const header = `${p.bold}▞${p.reset} expanded · ${escapeTerminal(`${cell.name.replace("_file", "")} ${toolTarget(cell.name, input)}`)} · ${turnsBack} ${turnsBack === 1 ? "turn" : "turns"} back`;
+        return {
+            kind: "appended",
+            lines: [
+                header,
+                `--- ${cell.name} input ---`,
+                cell.inputFull,
+                `--- ${cell.name} output${cell.isError ? " (error)" : ""} ---`,
+                cell.resultText,
+            ],
+        };
+    }
     // ---- the Dock façade (the CLI's chrome API — same shape as the old dock) ----
     /** Docked = the chrome is live (a color TTY with a real size). */
     get active() {
@@ -431,7 +621,8 @@ export class Body {
      *  reads it — the marker math never desyncs by construction). */
     editCol() {
         const inp = this.#inputState();
-        return displayWidth(this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, "")) + inp.cursor + 1;
+        // W6: the box's left wall (2 cols) prefixes the prompt
+        return 2 + displayWidth(this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, "")) + inp.cursor + 1;
     }
     /** The old dock's redraw — the editor's onRender target: mark + the
      *  scheduler (16ms coalescing — the old sync draw coalesces the same). */
@@ -546,7 +737,13 @@ export class Body {
         //    emit exactly once).
         this.#committedAtFrameStart = this.#committed;
         this.#committedLinesThisFrame = [];
-        while (this.#committed < this.#cells.length && this.#cells[this.#committed].done) {
+        // W14: the natural loop HONORS the fold-hold — a thinking/tool
+        // cell of the OPEN quiet turn (no text yet) does not commit: its
+        // committed form is decided at the release (the turn's text →
+        // individual commits with the W13 rollups; the turn's end → the
+        // fold). The FORCE-commit path below bypasses the hold — the
+        // screen never sticks, the rollup degrades to individuals.
+        while (this.#committed < this.#cells.length && this.#cells[this.#committed].done && !this.#held(this.#committed)) {
             this.#commitCell(this.#committed, W, ctx);
         }
         // 2. the live lines — the unfinished cells (the tail) + the chrome.
@@ -606,13 +803,138 @@ export class Body {
      *  this cell's commit — the cache stays raw, the placed rows count. */
     #commitCell(i, W, ctx) {
         const cell = this.#cells[i];
-        const lines = cellComponent(cell).render(W, ctx);
+        const lines = this.#foldOrRollup(cell, i, W, ctx);
+        // W15: a tool cell whose last committed row carried the "ctrl+r"
+        // affordance (the renderer cut "└ … ctrl+r") joins the expand
+        // history — the detection is the renderer's OWN output, so the
+        // read's "/last"-only cut note never lands here.
+        // unshift: the cells commit oldest-first, so the NEWEST cut lands
+        // at the front — the expand pointer's "newest back" walk starts
+        // where the user's last key press would aim.
+        if (cell.kind === "tool" && /└ .*ctrl\+r/.test(lines[lines.length - 1] ?? ""))
+            this.#collapsed.unshift(i);
         this.#lineCache[i] = lines;
         const placed = bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, lines);
         this.#committed += 1;
         this.#committedLines += placed.length;
         this.#committedLinesThisFrame.push(...placed);
     }
+    /** W14 — the fold-hold: a thinking/tool cell of the OPEN quiet turn
+     *  (no text yet) does not commit — its committed form is decided at
+     *  the release. The cell's OWN turn must be the CURRENT one (a cell
+     *  of a released turn commits normally). The force-commit path never
+     *  consults this — the screen's hard cap wins over the hold. */
+    #held(i) {
+        const cell = this.#cells[i];
+        if (cell.kind !== "thinking" && cell.kind !== "tool")
+            return false;
+        const turn = cell.turn >= 0 ? this.#turns[cell.turn] : undefined;
+        if (turn === undefined || turn !== this.#turns[this.#turns.length - 1])
+            return false;
+        return !turn.ended && !turn.hasText;
+    }
+    /** W14/W13 — the release-time decision at a commit, BEFORE the cell's
+     *  own render: the folded-turn fold first (a QUIET turn — ended, no
+     *  text — becomes the ONE fold line; the rest of its thinking/tool
+     *  cells render [] after the fold), then the W13 rollup (a text
+     *  turn's N > 2 same-tool run: the HEAD renders the group summary,
+     *  the members render [] — the scan is the work order's "group key",
+     *  derived at commit time, never pre-stored). */
+    #foldOrRollup(cell, i, W, ctx) {
+        if (cell.kind === "thinking" || cell.kind === "tool") {
+            const turn = cell.turn >= 0 ? this.#turns[cell.turn] : undefined;
+            if (turn !== undefined && turn.ended && !turn.hasText) {
+                if (!turn.folded) {
+                    turn.folded = true;
+                    return turnFold({
+                        thoughtSeconds: turn.thoughtSeconds,
+                        reads: turn.reads,
+                        edits: turn.edits,
+                        others: [...turn.others],
+                    });
+                }
+                return [];
+            }
+        }
+        if (cell.kind !== "tool" || ROLLUP_NOUN[cell.name] === undefined)
+            return cellComponent(cell).render(W, ctx);
+        // the maximal same-name run around i — forward/backward scans over
+        // the cells. The turn-less noise cells (the permission raws, the ⚠
+        // notices) are TRANSPARENT: the streaming execution (loop.ts launch)
+        // interleaves them BETWEEN the calls of one burst, so the run must
+        // see through them. It never crosses a user/text/thinking cell —
+        // those separate turns and contexts.
+        let s = i;
+        let head = i;
+        while (s > 0) {
+            const prev = this.#cells[s - 1];
+            if (prev.kind === "raw" || prev.kind === "notice") {
+                s -= 1;
+                continue;
+            }
+            if (prev.kind !== "tool" || prev.name !== cell.name)
+                break;
+            s -= 1;
+            head = s; // a same-name tool precedes — it is the group's head
+        }
+        let e = i;
+        while (e + 1 < this.#cells.length) {
+            const next = this.#cells[e + 1];
+            if (next.kind === "raw" || next.kind === "notice") {
+                e += 1;
+                continue;
+            }
+            if (next.kind !== "tool" || next.name !== cell.name)
+                break;
+            e += 1;
+        }
+        // the run counts the TOOL cells only — the span's raws are noise.
+        const members = this.#cells.slice(s, e + 1).filter((c) => c.kind === "tool");
+        if (members.length <= 2)
+            return cellComponent(cell).render(W, ctx);
+        if (head === i) {
+            // the HEAD — the rollup only when EVERY member is done (at the
+            // text's release they are — the natural loop commits the run in
+            // one frame; the force-commit's early commits degrade to the
+            // individual rows, the members render normally after).
+            if (!members.every((c) => c.done))
+                return cellComponent(cell).render(W, ctx);
+            this.#rolledHeads.add(head);
+            let total = 0;
+            const targets = [];
+            for (const m of members) {
+                // the lines count, excluding the tool's OWN truncation note
+                // (read_file's "… N more lines") — the per-cell meta's rule
+                const noteAt = m.resultText.lastIndexOf("\n… ");
+                const shown = noteAt >= 0 ? m.resultText.slice(0, noteAt) : m.resultText;
+                const parts = shown.split("\n");
+                total += parts[parts.length - 1] === "" ? parts.length - 1 : parts.length;
+                let input = {};
+                try {
+                    input = JSON.parse(m.inputFull);
+                }
+                catch {
+                    // the full JSON is always parseable (stringified at
+                    // toolStart) — the empty fallback never fires
+                }
+                const target = toolTarget(m.name, input);
+                targets.push(target.split("/").pop() ?? target);
+            }
+            const first = members[0];
+            const last = members[members.length - 1];
+            const elapsed = first.startedAt !== null && last.doneAt !== null ? ((last.doneAt - first.startedAt) / 1000).toFixed(1) : "?";
+            cell.rolled = { count: members.length, lines: total, elapsed, targets };
+            return cellComponent(cell).render(W, ctx);
+        }
+        // a MEMBER of an already-rolled run → [] (its rows live in the
+        // head's summary). A member of a run whose head committed
+        // INDIVIDUALLY (the force-commit's degradation) renders normally —
+        // the head is not in #rolledHeads, the run never rolls after the
+        // head's individual commit.
+        if (this.#rolledHeads.has(head))
+            return [];
+        return cellComponent(cell).render(W, ctx);
+    }
     /** The slot occupant's extra rows — the slash-command menu (above the
      *  status, in the rhythm gap + the content's spare rows — the old
      *  menu's position, slot-shaped). */
@@ -635,7 +957,14 @@ export class Body {
      *  cursor's display column WITHIN THE ROW (the brick/question lead
      *  included), the question/editor/menu variants. The compositor
      *  strips the marker and moves LEFT by the trailing width — the
-     *  cursor derives from the frame, never from side-channel math. */
+     *  cursor derives from the frame, never from side-channel math.
+     *
+     *  W6: the row lives INSIDE the box — the walls are a prefix/suffix
+     *  width only, composed AFTER the marker embed (the marker math is
+     *  untouched; the marker's row column = the wall + the lead + the
+     *  cursor). The content caps at W−4 (the walls' columns) and the
+     *  pad completes the row to EXACTLY W — invariant ① throws on
+     *  overflow, so the box row is built full-width, never truncated. */
     #inputRow(W, _ctx) {
         const st = this.#inputState();
         let row;
@@ -653,8 +982,8 @@ export class Body {
         const leadW = visibleWidth(row.slice(0, row.length - st.line.length));
         // embed the marker at the cursor's display column
         let markerLine = "";
+        let w = 0;
         {
-            let w = 0;
             let inserted = false;
             let i = 0;
             while (i < row.length) {
@@ -671,6 +1000,8 @@ export class Body {
                     inserted = true;
                 }
                 const cw = displayWidth(row[i]);
+                if (w + cw > W - 4)
+                    break; // the cap — the two walls' columns
                 markerLine += row[i];
                 w += cw;
                 i += 1;
@@ -679,8 +1010,24 @@ export class Body {
                 markerLine += CURSOR_MARKER;
             }
         }
-        const stripped = markerLine.replace(CURSOR_MARKER, "");
-        const afterW = visibleWidth(markerLine.slice(markerLine.indexOf(CURSOR_MARKER) + CURSOR_MARKER.length));
+        const stripped0 = markerLine.replace(CURSOR_MARKER, "");
+        const tailW = visibleWidth(markerLine.slice(markerLine.indexOf(CURSOR_MARKER) + CURSOR_MARKER.length));
+        if (W < 4) {
+            // the degenerate screen: the box cannot hold its walls — the
+            // bare row (the pre-W6 bytes; the fold probe's pass-through
+            // line still crashes invariant ① downstream, as before)
+            return { stripped: stripped0, afterW: tailW };
+        }
+        // the pad completes the row to W — the content stopped at W−4,
+        // so the pad is ≥ 1
+        const padW = W - 3 - w;
+        const stripped = `\x1b[2m│ \x1b[0m${stripped0}\x1b[2m${" ".repeat(padW)}│\x1b[0m`;
+        // the LEFT move = the width AFTER the cursor-rest cell — the
+        // full-width row parks the terminal cursor at the LAST cell (not
+        // one past the end), so the rest cell IS the first tail cell and
+        // the move = the tail + the pad (the right wall rides inside the
+        // pad's tail)
+        const afterW = tailW + padW;
         return { stripped, afterW };
     }
     /** The full-redraw path (the first frame, the resize repaint) — CUP
@@ -727,12 +1074,12 @@ export class Body {
         for (let i = 0; i < menuRows.length; i += 1) {
             out.push(`\x1b[${menuTop + i};1H\x1b[0K${this.#checked(menuRows[i], W)}`);
         }
-        // V6-3: the design §03 chrome — upper ╌ (H−3), input (H−2),
-        // lower ╌ (H−1), status (H).
-        out.push(`\x1b[${H - 3};1H\x1b[0K${footerLine(W)}`);
+        // V6-3 + W6: the design §03 chrome — box top (H−3), input
+        // (H−2), box bottom (H−1), status (H) — the box's four rows.
+        out.push(`\x1b[${H - 3};1H\x1b[0K${boxTop(W)}`);
         const editor = this.#inputRow(W, ctx);
         out.push(`\x1b[${H - 2};1H\x1b[0K${this.#checked(editor.stripped, W)}`);
-        out.push(`\x1b[${H - 1};1H\x1b[0K${footerLine(W)}`);
+        out.push(`\x1b[${H - 1};1H\x1b[0K${boxBottom(W)}`);
         out.push(`\x1b[${H};1H\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W, this.#statusHint ?? undefined), W)}`);
         // the cursor: up two (the input row at H−2) + left to the marker
         out.push("\x1b[2A");
@@ -756,12 +1103,13 @@ export class Body {
         out.push("\x1b[2B");
         for (let i = 0; i < committed.length; i += 1)
             out.push("\n");
-        // the bottom-up repaint, from the last row up — V6-3: the design
-        // §03 chrome: status (H), lower ╌ (H−1), input (H−2), upper ╌ (H−3)
+        // the bottom-up repaint, from the last row up — V6-3 + W6: the
+        // design §03 chrome: status (H), box bottom (H−1), input (H−2),
+        // box top (H−3)
         out.push(`\x1b[1G\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W, this.#statusHint ?? undefined), W)}`); // H — the status
-        out.push(`\x1b[1A\x1b[1G\x1b[0K${footerLine(W)}`); // H−1 — the lower ╌
+        out.push(`\x1b[1A\x1b[1G\x1b[0K${boxBottom(W)}`); // H−1 — the box bottom
         out.push(`\x1b[1A\x1b[1G\x1b[0K${this.#checked(editor.stripped, W)}`); // H−2 — the input
-        out.push(`\x1b[1A\x1b[1G\x1b[0K${footerLine(W)}`); // H−3 — the upper ╌
+        out.push(`\x1b[1A\x1b[1G\x1b[0K${boxTop(W)}`); // H−3 — the box top
         for (let i = menuRows.length - 1; i >= 0; i -= 1) {
             out.push(`\x1b[1A\x1b[1G\x1b[0K${this.#checked(menuRows[i], W)}`);
         }
@@ -804,7 +1152,7 @@ export class Body {
         // the down-distance from the LAST written row, in byte order: the
         // committed band's bottom, then the stale ELs' bottom, then the gap
         // ELs' bottom, then the live lines' bottom, then the menu's top
-        // (its last marched row), else the chrome's upper ╌.
+        // (its last marched row), else the chrome's box top.
         const lastRow = committed.length > 0
             ? Math.max(1, liveTop - 1)
             : staleFrom < liveTop

package/dist/editor.d.ts

@@ -41,6 +41,7 @@ export declare class Editor {
     onSigint(cb: () => void): void;
     onEot(cb: () => void): void;
     onEscape(cb: () => void): void;
+    onExpand(cb: () => void): void;
     /** The whole buffer as text (the CLI's line()/clearLine()). */
     line(): string;
     clearLine(): void;

package/dist/editor.js

@@ -56,6 +56,11 @@ export class Editor {
     // (dispatch) coexist; a listener removes itself via an unarmed guard
     // (the compact's handler no-ops after its abort has fired).
     #escapeCbs = [];
+    // W15: the expand-key list (ctrl+r) — the CLI's dispatch decides the
+    // target (a live cell toggles in place; a committed cell appends the
+    // expanded block). Mirrors the escape list: multiple listeners can
+    // coexist; the editor never interprets the key itself.
+    #expandCbs = [];
     #onRender;
     #menuOpen = false; // v3 §04: the slash-command menu
     #menuSel = 0;
@@ -95,6 +100,9 @@ export class Editor {
     onEscape(cb) {
         this.#escapeCbs.push(cb);
     }
+    onExpand(cb) {
+        this.#expandCbs.push(cb);
+    }
     /** The whole buffer as text (the CLI's line()/clearLine()). */
     line() {
         return String.fromCodePoint(...this.#chars);
@@ -272,6 +280,13 @@ export class Editor {
                 }
                 i += 1;
             }
+            else if (c === "\x12") {
+                // W15: the expand key (ctrl+r) — rides the chain like a
+                // command, the editor just forwards it.
+                for (const cb of [...this.#expandCbs])
+                    cb();
+                i += 1;
+            }
             else if (c !== undefined && c < " ") {
                 i += 1; // other control — ignored
             }
@@ -455,7 +470,7 @@ export class Editor {
     // ---- width-based horizontal scroll ----
     #reflow() {
         const W = (process.stdout.columns ?? 0) || 80; // degenerate 0 falls back to 80
-        const maxW = Math.max(1, W - PROMPT_WIDTH - 1); // 1 col for the "…"
+        const maxW = Math.max(1, W - PROMPT_WIDTH - 4); // W6: the box's walls (2+2) — the visible line fits the box's inner width; the "…" rides inside
         const curCol = widthOf(this.#chars.slice(0, this.#cursor));
         const scrolledW = widthOf(this.#chars.slice(0, this.#scroll));
         if (curCol < scrolledW) {

package/dist/render.d.ts

@@ -11,8 +11,9 @@
  * v2a — the palette, centralized (no hard-coded codes elsewhere); v5
  * (TUI v5 #16e, the v4.1 design): the decorative blue (38;5;75) is
  * RETIRED — the identity accents (the you> prompt, the banner tagline,
- * ✓ marks, slash-command names, the ▍ user rail, the input brick) are
- * bright-white BOLD (SGR 1); `code` is the content semantic tint for
+ * ✓ marks, slash-command names, the input brick) are bright-white BOLD
+ * (SGR 1); the user message is the SGR-7 chip (the 2026-08-09 ruling
+ * retired the ▍ rail); `code` is the content semantic tint for
  * inline code spans in assistant text (256-color 110 — the cube color
  * nearest the design's #8fb4d8); red for errors, dim for metadata,
  * green for the diff additions. NO_COLOR set, or a non-TTY output →
@@ -177,7 +178,12 @@ export declare function renderEvent(ev: RenderInput, prevThinking?: boolean, res
 export declare function renderToolSummary(name: string, input: Record<string, unknown>, result: {
     content: string;
     isError: boolean;
-}): string;
+}, reason?: string | null): string;
+/** W15 — the expand header's target: the tool call's subject (the path
+ *  for the *_file tools, the command for shell) — the same extraction
+ *  the summary detail uses, WITHOUT the counts (the header names what
+ *  was expanded, not its size). */
+export declare function toolTarget(name: string, input: Record<string, unknown>): string;
 /** k-units for the status line: 12345 → 12.3k, 800 → 800, null → ?. */
 export declare function kUnit(value: number | null): string;
 /** B area: usage data gathered from the run's usage events. */
@@ -242,6 +248,11 @@ export interface RecapStats {
     readonly edits: number;
     readonly usage: RunUsage;
     readonly ctxLeftPct: number | null;
+    /** W19 — the mode the turn ran under. Under "plan" the recap becomes
+     *  the way-forward row (the claimed shape): a plan turn's currency is
+     *  the plan, not the tool count — the timing and tool-count parts
+     *  drop, and the two /mode hints replace them. */
+    readonly mode?: string;
 }
 export declare function renderRecap(s: RecapStats): string;
 /** One-line summary of a session, for `kiso sessions`. */