@vincemakes/kiso-tui 0.1.36 → 0.1.38

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, cellComponent, foldLine, footerLine, statusLine, visibleWidth, } from "./components.js";
-import { 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 todo block only
+ *  redraws when the items actually changed (the todo extension's
+ *  idempotent shape — an unchanged replace is a no-op, no frame). */
+function sameTodo(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,10 +81,24 @@ 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)
     #status = "";
+    #statusHint = null;
     #tail = "";
     #question = null;
     #inputState = () => ({ line: "", cursor: 0 });
@@ -118,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) {
@@ -131,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();
     }
@@ -154,8 +178,30 @@ export class Body {
             this.#write(`→ ${escapeTerminal(name)}(${escapeTerminal(JSON.stringify(input).slice(0, 200))})\n`);
             return;
         }
+        // W12: the cell carries the delegate's child roles from the FULL
+        // input — the display summary is sliced at 60 chars (unparseable);
+        // the roles are the only running-state data the parent holds (there
+        // is no live channel to a running child session).
+        const childRoles = [];
+        for (const t of Array.isArray(input.tasks) ? input.tasks : []) {
+            if (typeof t === "object" && t !== null && typeof t.role === "string") {
+                childRoles.push(t.role);
+            }
+        }
         this.#toolCells.set(callId, this.#cells.length);
-        this.#cells.push({ kind: "tool", name, input: summary, 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) {
@@ -202,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;
         }
@@ -213,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;
         }
@@ -225,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;
@@ -246,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 todo block settles HERE — the ONE recap
+        // block for the turn (`todo 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();
@@ -270,6 +371,17 @@ export class Body {
         this.#cells.push({ kind: "notice", text, done: true });
         this.#mark();
     }
+    /** W20 — the todo 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 todo 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();
@@ -283,7 +395,49 @@ 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 (!sameTodo(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
+     *  frame (bannerLines with the CURRENT W and H), so a resize re-tiers
+     *  the art instead of re-folding frozen rows (a window below 40 cols
+     *  never paints the logo). W5: the resume metas ride the cell — the
+     *  list re-gates with the tier (BIG only) and re-times with the
+     *  frame. The inactive path keeps the historical bytes (no resume —
+     *  the pipe contract). */
+    banner(version, extensionsText, resume = []) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            this.#closeOpenText();
+            const W = this.#opts.width() || 80; // a 0-size pty falls back
+            const H = this.#opts.height();
+            const p = palette();
+            for (const r of bannerLines(W, H, version, extensionsText))
+                this.#write(`${p.dim}${r}${p.reset}\n`);
+            this.#write("\n");
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        this.#cells.push({ kind: "banner", version, extensionsText, resume, done: true });
         this.#mark();
     }
     raw(lines) {
@@ -307,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 todo 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() {
@@ -360,8 +585,12 @@ export class Body {
         this.#dirty = true;
         this.render(); // the immediate redraw at the NEW geometry
     }
-    setStatus(text) {
+    /** W18: the status row's right-aligned hint is part of the status
+     *  state — the compacting row passes "esc to cancel" (the affordance
+     *  must survive repaints). */
+    setStatus(text, hint = null) {
         this.#status = text;
+        this.#statusHint = hint;
         this.redraw();
     }
     setTail(tail) {
@@ -392,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). */
@@ -452,19 +682,29 @@ export class Body {
     }
     // ---- the one writer ----
     /** The live region's scalar — the unit tests assert the cap directly
-     *  (the e2e gate pins the screen consequence). */
+     *  (the e2e gate pins the screen consequence). W11: the formula's
+     *  blanks are join artifacts — the count includes them (they are real
+     *  screen rows), threaded against the previous sibling's OWN rows. */
     liveCount() {
         const live = this.#cells.slice(this.#committed);
-        const ctx = { spinnerI: this.#spinnerI, now: Date.now() };
+        const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: this.#opts.height() };
         const W = this.#opts.width();
         let lines = 0;
-        for (const cell of live)
-            lines += cellComponent(cell).render(W, ctx).length;
+        let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
+        for (const cell of live) {
+            const rows = cellComponent(cell).render(W, ctx);
+            lines += bodySpacing(prev, rows).length;
+            prev = rows;
+        }
         return lines + CHROME_ROWS + this.#menuRows(W).length;
     }
     /** The lines committed THIS frame — the writes land in the frame's
      *  committed section (the rows just above the live region). */
     #committedLinesThisFrame = [];
+    // the CELL count when the frame began — the drawFull frozen bound's
+    // unit (the cells committed BEFORE this frame; a force-commit frame's
+    // placed LINES outnumber its cells)
+    #committedAtFrameStart = 0;
     render() {
         if (!this.#isActive())
             return;
@@ -473,7 +713,7 @@ export class Body {
         if (H < 4)
             return;
         this.#lastH = H;
-        const ctx = { spinnerI: this.#spinnerI, now: Date.now() };
+        const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: H };
         // V6-1 (the screen-state == frame-state rule): the resize's first
         // frame — the terminal's reflow re-wrapped the committed content at
         // the NEW width, so the cached folds are stale. Re-fold the
@@ -485,8 +725,8 @@ export class Body {
             for (let i = 0; i < this.#committed; i += 1) {
                 const cell = this.#cells[i];
                 const lines = cellComponent(cell).render(W, ctx);
-                this.#lineCache[i] = lines;
-                this.#committedLines += lines.length;
+                this.#lineCache[i] = lines; // the cell's OWN rows — the cache stays raw
+                this.#committedLines += bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, lines).length;
             }
         }
         // 1. the natural commits — the leading DONE cells freeze: their
@@ -495,16 +735,30 @@ export class Body {
         //    short sessions included — the frame coalescing keeps a
         //    cell's first frame its freeze frame, so the frozen bytes
         //    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.
+        //    W11: the formula's blank above the first live cell hangs off
+        //    the last COMMITTED sibling (the join spans the boundary).
         const menuRows = this.#menuRows(W);
         const chromeRows = CHROME_ROWS + menuRows.length;
         let liveLines = [];
-        for (const cell of this.#cells.slice(this.#committed)) {
-            liveLines.push(...cellComponent(cell).render(W, ctx));
+        {
+            let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
+            for (const cell of this.#cells.slice(this.#committed)) {
+                const rows = cellComponent(cell).render(W, ctx);
+                liveLines.push(...bodySpacing(prev, rows));
+                prev = rows;
+            }
         }
         // 3. the FORCE commits — the live region's hard cap H−1: overflow
         //    commits the oldest live cell UNCONDITIONALLY (the one sharp
@@ -512,8 +766,13 @@ export class Body {
         while (liveLines.length > H - 4 && this.#committed < this.#cells.length) { // V6-3: the content cap H−4
             this.#commitCell(this.#committed, W, ctx);
             liveLines = [];
-            for (const cell of this.#cells.slice(this.#committed)) {
-                liveLines.push(...cellComponent(cell).render(W, ctx));
+            {
+                let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
+                for (const cell of this.#cells.slice(this.#committed)) {
+                    const rows = cellComponent(cell).render(W, ctx);
+                    liveLines.push(...bodySpacing(prev, rows));
+                    prev = rows;
+                }
             }
         }
         // 4. the geometry — the live region's first row:
@@ -539,14 +798,142 @@ export class Body {
     /** Commit the cell at index i: render + cache its lines (immutable —
      *  the force-committed form freezes at the current render), advance
      *  the bookkeeping — and collect the lines for this frame's writes.
-     *  Pure accounting + the write list; the BYTES emit in the frame. */
+     *  Pure accounting + the write list; the BYTES emit in the frame.
+     *  W11: the formula's blank above the cell (when one belongs) rides
+     *  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 += lines.length;
-        this.#committedLinesThisFrame.push(...lines);
+        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
@@ -570,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;
@@ -588,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) {
@@ -606,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;
@@ -614,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
@@ -633,20 +1045,24 @@ export class Body {
         const committed = this.#committedLinesThisFrame;
         // 0. the FROZEN rows — the re-folded committed content (re-flowed
         //    at the new width by the terminal): re-painted at [1..frozen],
-        //    so the reflow's shifted copies can never ghost.
-        const frozen = this.#lineCache.slice(0, this.#committed - committed.length).flat().filter((l) => l !== null);
-        let r = 1;
-        for (const line of frozen) {
-            out.push(`\x1b[${r};1H\x1b[0K${this.#checked(line, W)}`);
-            r += 1;
+        //    so the reflow's shifted copies can never ghost. W11: the
+        //    formula's blanks between the cells are re-inserted here — the
+        //    cache holds each cell's OWN rows; a missing blank would paint
+        //    every row below it one row too high (the V6-1 idempotence
+        //    rule: this draw must reproduce the screen, row by row).
+        //    The bound is the CELL count at the frame's start — the force
+        //    commit's placed LINES can exceed the cell count, and the old
+        //    lines-bound went negative, skipping every previously-committed
+        //    cell (the V6-1 frozen-loop finding — the banner vanished).
+        const frozen = [];
+        for (let i = 0; i < this.#committedAtFrameStart; i += 1) {
+            frozen.push(...bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, this.#lineCache[i]));
         }
-        // 1. the committed lines (this frame's).
-        for (const line of committed) {
-            out.push(`\x1b[${r};1H\x1b[0K${this.#checked(line, W)}`);
-            r += 1;
-        }
-        // 2. the live lines.
-        for (const line of liveLines) {
+        let r = 1;
+        // one march — the frozen, the committed (this frame's), the live —
+        // in write order, r monotone (three byte-identical loops merged for
+        // the gate; the exact write sequence preserved)
+        for (const line of [...frozen, ...committed, ...liveLines]) {
             out.push(`\x1b[${r};1H\x1b[0K${this.#checked(line, W)}`);
             r += 1;
         }
@@ -658,13 +1074,13 @@ 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};1H\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W), 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");
         if (editor.afterW > 0)
@@ -687,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)
-        out.push(`\x1b[1G\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W), W)}`); // H — the status
-        out.push(`\x1b[1A\x1b[1G\x1b[0K${footerLine(W)}`); // H−1 — the lower ╌
+        // 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${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)}`);
         }
@@ -735,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
@@ -806,8 +1223,8 @@ export class Dock {
     onResize() {
         compositorRef?.onResize();
     }
-    setStatus(text) {
-        compositorRef?.setStatus(text);
+    setStatus(text, hint) {
+        compositorRef?.setStatus(text, hint ?? null);
     }
     setTail(tail) {
         compositorRef?.setTail(tail);