@vincemakes/kiso-tui 0.1.37 → 0.1.38

package/dist/components.d.ts

@@ -69,14 +69,20 @@ export type BodyCell = {
     kind: "user";
     text: string;
     done: true;
+    turn: number;
 } | {
     kind: "thinking";
     text: string;
     done: boolean;
+    turn: number;
 } | {
     kind: "tool";
     name: string;
     input: string;
+    /** W15: the FULL input JSON (pretty-printed) — the display
+     *  summary above is sliced at 60 chars; the expanded block's
+     *  "--- input ---" section mirrors /last and needs it all. */
+    inputFull: string;
     childRoles: string[];
     state: "pending" | "approval" | "running" | "done";
     isError: boolean;
@@ -87,6 +93,32 @@ export type BodyCell = {
     startedAt: number | null;
     doneAt: number | null;
     done: boolean;
+    /** W15: the live-region expand toggle — while the cell is live
+     *  the FULL body renders in place (the compositor owns those
+     *  rows and redraws them); a committed cell can never toggle
+     *  (history is never rewritten — ADR-0046). */
+    expanded: boolean;
+    /** W14: the turn boundary — the index of the turn record that
+     *  created this cell (the fold-hold's owner; −1 when no turn
+     *  exists yet — the pre-turn cells never hold). */
+    turn: number;
+    /** W13: the rolled-up group summary — set at COMMIT time when
+     *  the head of an N > 2 same-tool run renders the group (the
+     *  work order's claimed shape: "✓ read  5 files (2.4k lines,
+     *  1.1s)" + the target children). The members carry null — the
+     *  compositor's rolled-heads bookkeeping renders them []. */
+    rolled: null | {
+        count: number;
+        lines: number;
+        elapsed: string;
+        targets: string[];
+    };
+    /** W19: a DENIED call's reason (the CLI extracted it from the
+     *  result's "[Permission denied] " prefix, keyed on the "denied"
+     *  tag). Non-null renders the pinned row — the full call name,
+     *  the target, the reason in the W4 parentheses idiom, NO timing
+     *  metadata (the call never ran). */
+    reason: string | null;
 } | {
     kind: "text";
     text: string;
@@ -112,26 +144,77 @@ export type BodyCell = {
     done: true;
 } | {
     kind: "checklist";
+    /** the model-authored header tail (parseChecklist's count line —
+     *  chat.ts). The compositor's fixed "todo" prefix rides BEFORE it
+     *  (W20 naming ruling: never model-controlled). */
     header: string;
     items: {
         text: string;
         status: "pending" | "active" | "done";
     }[];
-    done: true;
+    /** W20: false while LIVE — the current turn's ONE in-place block
+     *  (the commit loop only takes done cells, so it stays in the
+     *  live region); true once SETTLED — endTurn committed it as the
+     *  turn's one recap block. */
+    done: boolean;
+    /** W20: the LIVE block's ctrl+r toggle (W15) — the capped form
+     *  flips to the full list in place. The settled render ignores
+     *  it (already full). */
+    expanded: boolean;
+    /** W20: the wall clock of the block's FIRST call — the settled
+     *  header's duration is clocked from here, compositor-side (the
+     *  CLI stays unchanged). */
+    startedAt: number;
+    /** W20: the run's duration at the settle — the `2h 14m` form. */
+    durationSeconds: number;
+    turn: number;
 };
 declare const TOOL_SUMMARY_MAX = 60;
 /** The component for one cell — the mapping table lives here so the
  *  compositor stays a pure writer. */
 export declare function cellComponent(cell: BodyCell): Component;
+/** 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 declare const ROLLUP_NOUN: Readonly<Record<string, string>>;
+/** 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). */
+export declare function turnFold(t: {
+    thoughtSeconds: number;
+    reads: number;
+    edits: number;
+    others: [string, number][];
+}): string[];
+/** W20 — the todo block's fixed-window height: the whole live block
+ *  (header + rows) in POST-FOLD screen rows at EVERY width: the header,
+ *  the active row, up to 2 pending, the overflow-pending fold, the
+ *  done-collapse. Every live row CUTS at W (never folds) — the block's
+ *  height is its row count. */
+export declare const CAP_TODO_LIVE = 6;
+/** W20 — the settled block's duration, the `2h 14m` form (the todo
+ *  narrative's long-horizon idiom): minutes+seconds under an hour,
+ *  hours+minutes past it. */
+export declare function formatDuration(totalSeconds: number): string;
 /** 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
  *  the STATUS ITSELF cannot fit, it cuts with a "…" — the last resort,
  *  enforced by invariant ① (the old code let the status soft-wrap). */
 export declare function statusLine(status: string, tail: string, question: boolean, W: number, hint?: string): string;
-/** The footer — the ONE dotted row (the old two-row chrome is gone;
- *  the wall cannot return by construction). */
-export declare function footerLine(W: number): string;
+/** W6 — the box: the chrome's top rail. The two ╌ dotted rows become
+ *  a rounded box (the box already says "input lives here"); the rails
+ *  stay dim, the width is still the full W (the box is a rail with
+ *  corners — the menu/gap rows above and the status below are
+ *  untouched). */
+export declare function boxTop(W: number): string;
+/** W6 — the box: the chrome's bottom rail. */
+export declare function boxBottom(W: number): string;
 /** The terminal label + rhythm gap (the pipe path's v2c bytes — the
  *  exact render the passthrough needs). */
 export declare function terminalPipe(label: string, statusLineText: string): string;

package/dist/components.js

@@ -16,7 +16,7 @@
  * tint, fold wording).
  */
 import { displayWidth } from "./editor.js";
-import { bannerLines, escapeTerminal, foldThinking, foldResult, colorInlineCode, renderTerminalGap, renderToolSummary, palette, } from "./render.js";
+import { bannerLines, escapeTerminal, foldThinking, foldResult, colorInlineCode, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, } from "./render.js";
 /** The spinner glyphs, cycled by the compositor's on-demand tick. */
 export const SPINNER = ["▖", "▘", "▝", "▗"];
 /**
@@ -328,7 +328,43 @@ class ToolExecution {
         const verb = escapeTerminal(c.name.replace("_file", ""));
         const verbCol = verb.length < 5 ? `${verb}${" ".repeat(5 - verb.length)}` : verb;
         const summary = escapeTerminal(c.input);
+        if (c.rolled !== null) {
+            // W13 — the rolled-up group's ONE row + the target children:
+            // the work order's claimed shape, verbatim — the verbCol's
+            // 5-char pad reproduces the "read  5 files" double space, the
+            // children are the first 3 basename targets, the overflow row
+            // carries the ctrl+r affordance (its "└ … ctrl+r" joins the
+            // W15 expand history — the head's commit captures it).
+            const r = c.rolled;
+            const noun = ROLLUP_NOUN[c.name] ?? "calls";
+            const out = gutterFold(`${p.bold}✓${p.reset} `, `${verbCol} ${r.count} ${noun} (${kUnit(r.lines)} lines, ${r.elapsed}s)`, W);
+            const shown = r.targets.slice(0, 3);
+            if (shown.length > 0)
+                out.push(`  ${p.dim}${CUT_ROW}${escapeTerminal(shown.join(" · "))}${p.reset}`);
+            if (r.targets.length > 3)
+                out.push(`  ${p.dim}${CUT_ROW}+${r.targets.length - 3} more — ctrl+r expands${p.reset}`);
+            return out;
+        }
         if (c.state === "done") {
+            // W19: the pinned deny — the claimed shape verbatim: the FULL
+            // call name (the denial names the call), the target, the reason
+            // in the W4 parentheses idiom, no timing (the call never ran).
+            // The same ✗ family as any failure; the [result ✗] body still
+            // rides below (never hide information).
+            if (c.reason !== null) {
+                let input = {};
+                try {
+                    input = JSON.parse(c.inputFull);
+                }
+                catch {
+                    // the full JSON is always parseable (stringified at
+                    // toolStart) — the empty fallback never fires
+                }
+                const target = toolTarget(c.name, input);
+                const out = gutterFold(`${p.red}✗${p.reset} `, `${p.red}${escapeTerminal(`${c.name} ${target}`)} (${escapeTerminal(c.reason)})${p.reset}`, W);
+                out.push(...toolBlockBody(c, W));
+                return out;
+            }
             const elapsed = c.startedAt !== null && c.doneAt !== null ? ((c.doneAt - c.startedAt) / 1000).toFixed(1) : "?";
             const meta = escapeTerminal(settledMeta(c));
             const out = c.isError
@@ -357,6 +393,47 @@ class ToolExecution {
         return gutterFold(`${p.dim}◦${p.reset} `, `${verbCol} ${summary}`, W);
     }
 }
+/** 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",
+};
+/** The count term with the singular/plural forms — "no reads", "1 read",
+ *  "5 reads". The noun's singular drops the plural suffix ("dirs" → "dir",
+ *  "matches" → "match"). */
+function countTerm(n, singular, plural) {
+    if (n === 0)
+        return `no ${plural}`;
+    if (n === 1)
+        return `1 ${singular}`;
+    return `${n} ${plural}`;
+}
+/** W14 — the folded-turn line: a whole QUIET turn (no text), once it is
+ *  scrollback, becomes ONE line — the work order's claimed shape
+ *  (`▞ thought 19s · 5 reads · no edits`), the counts accumulated at
+ *  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). */
+export function turnFold(t) {
+    const p = palette();
+    const parts = [`thought ${t.thoughtSeconds}s`, countTerm(t.reads, "read", "reads"), countTerm(t.edits, "edit", "edits")];
+    for (const [name, n] of t.others) {
+        const noun = ROLLUP_NOUN[name];
+        if (noun !== undefined) {
+            parts.push(countTerm(n, noun.endsWith("es") ? noun.slice(0, -2) : noun.slice(0, -1), noun));
+        }
+        else {
+            const verb = name.replace("_file", "");
+            parts.push(countTerm(n, verb, `${verb}s`));
+        }
+    }
+    return [`${p.bold}▞${p.reset} ${parts.join(" · ")}`];
+}
 // ---- 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. */
@@ -374,27 +451,39 @@ const blockMemo = new WeakMap();
 /** The block's body rows below the header (memoized, W9). */
 function toolBlockBody(c, W) {
     const memo = blockMemo.get(c);
-    const state = `${c.state}:${c.isError}:${c.name}`;
+    const state = `${c.state}:${c.isError}:${c.name}:${c.expanded ? "x" : ""}`;
     const content = c.state === "approval" ? (c.diff ?? null) : c.resultText;
     if (memo !== undefined && memo.width === W && memo.state === state && memo.content === content)
         return memo.rows;
     const p = palette();
-    const rows = c.state === "done"
-        ? c.isError
-            ? errorBody(c, W)
-            : c.name === "delegate"
-                ? delegateSettled(c, W)
-                : c.name.startsWith("shell")
-                    ? shellTail(c.resultText, W)
-                    : []
-        : c.state === "running"
-            ? c.name === "delegate"
-                ? delegateRunning(c, W)
-                : liveWindow(c.resultText, W)
-            : c.state === "approval"
-                ? diffBody(c.diff, W)
-                : [];
-    const note = toolCutNote(c.name, c.resultText);
+    const rows = c.expanded
+        ? // W15: the toggle's full form — the WHOLE body, no cap, no
+            // cut note (nothing is cut; the width fold still holds — the
+            // height may change while live, the user asked for it). The
+            // delegate has no body — its rows are unchanged.
+            c.state === "approval"
+                ? diffBody(c.diff, W, true)
+                : c.name === "delegate"
+                    ? c.state === "running"
+                        ? delegateRunning(c, W)
+                        : delegateSettled(c, W)
+                    : blockRows(c.resultText, W)
+        : c.state === "done"
+            ? c.isError
+                ? errorBody(c, W)
+                : c.name === "delegate"
+                    ? delegateSettled(c, W)
+                    : c.name.startsWith("shell")
+                        ? shellTail(c.resultText, W)
+                        : []
+            : c.state === "running"
+                ? c.name === "delegate"
+                    ? delegateRunning(c, W)
+                    : liveWindow(c.resultText, W)
+                : c.state === "approval"
+                    ? diffBody(c.diff, W)
+                    : [];
+    const note = c.expanded ? null : toolCutNote(c.name, c.resultText);
     if (note !== null)
         rows.push(...foldLine(`${p.dim}${CUT_ROW}${note}${p.reset}`, W));
     blockMemo.set(c, { width: W, state, content, rows });
@@ -436,7 +525,11 @@ function errorBody(c, W) {
     // rides the header — the parsed code does — so the body keeps the
     // FULL text. Any other error keeps the pre-W4 split: line 0 is the
     // header's metadata, the body shows the rest.
-    const skipFirst = c.name === "shell" && /^exit \d+/.test(c.resultText) ? 0 : 1;
+    // W19: a DENIED call's header meta is the PARSED reason (from the
+    // denied tag), decoupled from the result text — the body keeps the
+    // FULL content including the "[Permission denied] " prefix (never
+    // hide information — the folded body rides the pinned row).
+    const skipFirst = c.name === "shell" && /^exit \d+/.test(c.resultText) ? 0 : c.reason !== null && c.reason !== undefined ? 0 : 1;
     const rows = blockRows(c.resultText.split("\n").slice(skipFirst).join("\n"), W);
     if (rows.length <= CAP_ERROR)
         return rows;
@@ -507,7 +600,7 @@ function oneLineRow(p, text, W) {
  *  a floor of 3 SOURCE lines visible the head/tail pair is noise (each
  *  fragment a sliver of a long line): drop to the head only — the head
  *  takes the whole budget — and the └ row carries the rest. */
-function diffBody(diff, W) {
+function diffBody(diff, W, expanded = false) {
     const p = palette();
     if (diff === null)
         return [];
@@ -527,7 +620,7 @@ function diffBody(diff, W) {
         rows.push(...gutterFold(`${p.dim}│${p.reset} `, body, W));
         starts.push(rows.length);
     }
-    if (rows.length <= CAP_DIFF)
+    if (expanded || rows.length <= CAP_DIFF)
         return rows;
     const head = Math.floor((CAP_DIFF - 1) / 2);
     const tail = CAP_DIFF - 1 - head;
@@ -625,7 +718,64 @@ class Banner {
         return rows.map((r) => `${p.dim}${r}${p.reset}`);
     }
 }
-/** The durable checklist — the ▞ header + one brick-glyph row per item. */
+/** W20 — the todo block's fixed-window height: the whole live block
+ *  (header + rows) in POST-FOLD screen rows at EVERY width: the header,
+ *  the active row, up to 2 pending, the overflow-pending fold, the
+ *  done-collapse. Every live row CUTS at W (never folds) — the block's
+ *  height is its row count. */
+export const CAP_TODO_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 ①). */
+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") {
+            const m = /^\x1b\[[0-9;]*m/.exec(line.slice(i)) ?? 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;
+    }
+    return `${out}\x1b[0m…`;
+}
+/** W20 — the settled block's duration, the `2h 14m` form (the todo
+ *  narrative's long-horizon idiom): minutes+seconds under an hour,
+ *  hours+minutes past it. */
+export function formatDuration(totalSeconds) {
+    const s = Math.max(0, Math.round(totalSeconds));
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    return m < 60 ? `${m}m ${s % 60}s` : `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+/**
+ * W20 — the todo checklist as STATE: ONE live block that redraws in
+ * place (the current turn's in-place updates), settling at the turn's
+ * end as ONE recap block. LIVE (done:false): the fixed "todo" prefix +
+ * the compositor-derived counts (the model tail rides AFTER — never
+ * model-controlled), the active item first with ▸ (the menu's "the
+ * current one"), pending next (≤2), the done items COLLAPSED behind the
+ * W10 cut family `└ +N done · ctrl+r`, overflow pending behind
+ * `└ +N more · ctrl+r` — every row cut at W so the cap holds at every
+ * width. ctrl+r (W15) toggles the full list in place (expanded). SETTLED
+ * (done:true): the recap idiom `todo done · N items · <duration>` + the
+ * FULL final item list in the checklist's existing shape (▖/□/▣ —
+ * indented two, the glyph leads, no │ gutter).
+ */
 class Checklist {
     cell;
     constructor(cell) {
@@ -633,12 +783,47 @@ class Checklist {
     }
     render(W, _ctx) {
         const p = palette();
-        const glyphOf = (status) => (status === "pending" ? "□" : status === "active" ? "▖" : "▣");
-        const rows = foldLine(`${p.bold}▞${p.reset} ${escapeTerminal(this.cell.header)}`, W);
-        for (const item of this.cell.items) {
-            rows.push(...foldLine(`  ${glyphOf(item.status)} ${escapeTerminal(item.text)}`, W));
+        const { items, done, expanded, durationSeconds } = this.cell;
+        const active = items.filter((i) => i.status === "active");
+        const pending = items.filter((i) => i.status === "pending");
+        const doneCount = items.length - active.length - pending.length;
+        const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+        const tail = this.cell.header === "" ? "" : ` · ${this.cell.header}`;
+        const fixed = done
+            ? `todo done · ${plural(items.length, "item")} · ${formatDuration(durationSeconds)}`
+            : `todo · ${plural(items.length, "item")} · ${active.length} active · ${doneCount} done`;
+        const header = `${p.bold}▞${p.reset} ${escapeTerminal(fixed + tail)}`;
+        // the FULL-list forms: SETTLED — the durable record (the fold is
+        // fine — committed content wraps naturally) — and the LIVE ctrl+r
+        // toggle (the header CUTS — the block stays one window high; the
+        // expanded rows show the ▣ the collapse hid). The live flag picks
+        // the glyphs: the settled list keeps the durable ▖, the expanded
+        // live list the ▸.
+        const glyph = (status, live) => {
+            const g = status === "pending" ? "□" : status === "active" ? (live ? "▸" : "▖") : "▣";
+            return g === "▸" ? `${p.bold}▸${p.reset}` : g;
+        };
+        if (done || expanded) {
+            const rows = done ? foldLine(header, W) : [cutLine(header, W)];
+            for (const item of items)
+                rows.push(...foldLine(`  ${glyph(item.status, !done)} ${escapeTerminal(item.text)}`, W));
+            return rows;
         }
-        return rows;
+        // LIVE — the fixed window: the header + the item rows CUT at W
+        // (one screen row each — the block's height is its row count,
+        // CAP_TODO_LIVE, at every width). The cut is the momentary view;
+        // the settle (and the ctrl+r toggle) show everything.
+        const itemRows = [];
+        if (active.length > 0)
+            itemRows.push(`  ${p.bold}▸${p.reset} ${escapeTerminal(active[0].text)}`);
+        for (const item of pending.slice(0, 2))
+            itemRows.push(`  □ ${escapeTerminal(item.text)}`);
+        const more = pending.length - 2;
+        if (more > 0)
+            itemRows.push(`  ${p.dim}└ +${more} more · ctrl+r${p.reset}`);
+        if (doneCount > 0)
+            itemRows.push(`  ${p.dim}└ +${doneCount} done · ctrl+r${p.reset}`);
+        return [cutLine(header, W), ...itemRows.map((r) => cutLine(r, W))];
     }
 }
 // ---- the chrome components (the status container, the slot, the footer) ----
@@ -678,10 +863,17 @@ function widthCut(text, max) {
     }
     return text.slice(0, i);
 }
-/** The footer — the ONE dotted row (the old two-row chrome is gone;
- *  the wall cannot return by construction). */
-export function footerLine(W) {
-    return `\x1b[2m${"╌".repeat(W)}\x1b[0m`;
+/** W6 — the box: the chrome's top rail. The two ╌ dotted rows become
+ *  a rounded box (the box already says "input lives here"); the rails
+ *  stay dim, the width is still the full W (the box is a rail with
+ *  corners — the menu/gap rows above and the status below are
+ *  untouched). */
+export function boxTop(W) {
+    return `\x1b[2m╭${"─".repeat(Math.max(0, W - 2))}╮\x1b[0m`;
+}
+/** W6 — the box: the chrome's bottom rail. */
+export function boxBottom(W) {
+    return `\x1b[2m╰${"─".repeat(Math.max(0, W - 2))}╯\x1b[0m`;
 }
 /** The terminal label + rhythm gap (the pipe path's v2c bytes — the
  *  exact render the passthrough needs). */

package/dist/compositor.d.ts

@@ -35,8 +35,9 @@
  *    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).
  */
@@ -78,11 +79,32 @@ export declare class Body {
     toolResult(callId: string, result: {
         content: string;
         isError: boolean;
+        reason?: string | null;
     }): void;
     textAppend(text: string): void;
     textEnd(): void;
+    /** 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: number): void;
     terminal(label: string, statusLineText: string): void;
     notice(text: string): void;
+    /** 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: string, items: {
         text: string;
         status: "pending" | "active" | "done";
@@ -107,6 +129,23 @@ export declare class Body {
             isError: boolean;
         };
     } | null;
+    /** 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(): {
+        kind: "toggled";
+    } | {
+        kind: "appended";
+        lines: string[];
+    } | {
+        kind: "none";
+    };
     /** Docked = the chrome is live (a color TTY with a real size). */
     get active(): boolean;
     enter(): void;

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 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,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 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();
@@ -281,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();
@@ -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 (!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
@@ -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 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() {
@@ -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

@@ -177,7 +177,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 +247,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`. */

package/dist/render.js

@@ -189,9 +189,16 @@ function approvalDetail(name, input, resolvePath) {
  * edit/write show +/- line counts, read shows lines, shell shows the exit
  * code; failures (isError) are ✗. Pure and deterministic.
  */
-export function renderToolSummary(name, input, result) {
+export function renderToolSummary(name, input, result, reason = null) {
     // v2a/v5: ✓ is a bold identity accent; ✗ stays red.
     const p = palette();
+    // W19: a DENIED call (the "denied" tag) renders the pinned row — the
+    // FULL call name, the target, the reason in the W4 parentheses idiom,
+    // and NO timing metadata (the call never ran — (0.0s) would be noise).
+    // The same row in the interactive and pipe paths, byte-clean on a pipe.
+    if (reason !== null) {
+        return `${p.red}✗${p.reset} ${escapeTerminal(`${name} ${toolTarget(name, input)} (${reason})`)}`;
+    }
     const mark = result.isError ? `${p.red}✗${p.reset}` : `${p.bold}✓${p.reset}`;
     const shortName = name.replace("_file", "");
     const detail = toolSummaryDetail(name, input, result);
@@ -233,6 +240,24 @@ function toolSummaryDetail(name, input, result) {
             return String(input.path ?? input.command ?? "");
     }
 }
+/** 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 function toolTarget(name, input) {
+    switch (name) {
+        case "read_file":
+        case "write_file":
+        case "edit_file":
+            return String(input.path ?? "?");
+        case "shell":
+            return String(input.command ?? "?");
+        case "list_dir":
+            return String(input.path ?? "(root)");
+        default:
+            return String(input.path ?? input.command ?? "");
+    }
+}
 /** The exit code of a shell result: parsed from the failure text, 0 on success. */
 function exitCodeOf(result) {
     if (!result.isError)
@@ -373,6 +398,15 @@ export function bannerLines(W, H, version, extensionsText, resume = [], now = Da
 }
 export function renderRecap(s) {
     const p = palette();
+    // W19: under plan the recap is the way out of the mode — the header
+    // names the mode's posture, the hints name the exits (the ONLY
+    // controls — /mode is the only way to leave plan mode).
+    if (s.mode === "plan") {
+        const parts = ["plan ready", "/mode default executes", "/mode accept-edits auto-approves edits"];
+        if (s.ctxLeftPct !== null)
+            parts.push(`ctx left ~${Math.round(s.ctxLeftPct)}%`);
+        return `${p.bold}▞${p.reset} ${parts.join(" · ")}\n`;
+    }
     const parts = [`${s.seconds}s`, `${s.tools} tool${s.tools === 1 ? "" : "s"}${s.edits > 0 ? ` (${s.edits} edit${s.edits === 1 ? "" : "s"})` : ""}`];
     if (s.usage.known) {
         const seg = `${s.usage.in !== null ? `in ${kUnit(s.usage.in)}` : ""}${s.usage.in !== null && s.usage.out !== null ? " " : ""}${s.usage.out !== null ? `out ${kUnit(s.usage.out)}` : ""}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "description": "kiso tui — the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
   "type": "module",
   "license": "MIT",