@vincemakes/kiso-tui 0.1.37 → 0.1.39

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 "task" 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 task 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_TASK_LIVE = 6;
+/** W20 — the settled block's duration, the `2h 14m` form (the task
+ *  narrative's long-horizon idiom): minutes+seconds under an hour,
+ *  hours+minutes past it. */
+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 = ["▖", "▘", "▝", "▗"];
 /**
@@ -167,19 +167,20 @@ export function cellComponent(cell) {
     }
 }
 /**
- * The user message — the left rail (bright-white BOLD ▍ per row, the
- * v4.1 design) + the W16 inset chip. The chip folds the text at W−6
- * (the rail + the indent + the side pads), then pads EVERY row to the
- * longest row's DISPLAY width + one space each side, indented two: the
- * block is only as wide as what was said (never the full-width band —
- * a short message like /think would paint a bar across the terminal).
- * The padding is by cells (charWidth is the width authority), so a CJK
- * row pads by width, never by chars, and the chip never overruns its
- * fold. SGR 7 closed with SGR 27 — never SGR 0, the chip composes
- * with a surrounding span — and NEVER dim: reverse video inverts the
- * CURRENT colours, so dimmed text would invert into a dimmed block
- * with no contrast. The ▍ rail stays: SGR is an emphasis on top, the
- * rail is the structural fallback that survives a pipe.
+ * The user message — the W16 inset chip ALONE (the 2026-08-09 ruling:
+ * the ▍ rail and the indent are retired — the rail's stated pipe
+ * fallback was theoretical redundancy: the CLI's pipe path is the
+ * line-mode "you>" form and never renders UserMessage). The chip folds
+ * the text at W−2 (the side pads), then pads EVERY row to the longest
+ * row's DISPLAY width + one space each side, flush left: the block is
+ * only as wide as what was said (never the full-width band — a short
+ * message like /think would paint a bar across the terminal). The
+ * padding is by cells (charWidth is the width authority), so a CJK row
+ * pads by width, never by chars, and the chip never overruns its fold.
+ * SGR 7 closed with SGR 27 — never SGR 0, the chip composes with a
+ * surrounding span — and NEVER dim: reverse video inverts the CURRENT
+ * colours, so dimmed text would invert into a dimmed block with no
+ * contrast.
  */
 class UserMessage {
     cell;
@@ -188,18 +189,17 @@ class UserMessage {
     }
     render(W, _ctx) {
         const p = palette();
-        const rail = `${p.bold}▍${p.reset} `;
-        const chipW = Math.max(1, W - 6);
+        const chipW = Math.max(1, W - 2);
         const rows = [];
         for (const para of this.cell.text.split("\n")) {
             const folded = foldLine(escapeTerminal(para), chipW);
             const inner = Math.max(...folded.map((r) => displayWidth(r)));
             for (const row of folded) {
                 const pad = inner - displayWidth(row);
-                rows.push(`${rail}  ${p.rv} ${row}${" ".repeat(pad)} ${p.rvEnd}`);
+                rows.push(`${p.rv} ${row}${" ".repeat(pad)} ${p.rvEnd}`);
             }
         }
-        return rows.length > 0 ? rows : [rail.trimEnd()];
+        return rows;
     }
 }
 /** The thinking fold — one dim line, width-capped so the /think suffix
@@ -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 task 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_TASK_LIVE = 6;
+/** W20 — the live block's fixed-window row cut: an SGR-aware ONE-ROW
+ *  truncation (foldLine wraps; a wrapped row would break the height
+ *  cap — every live row is exactly one screen row at every width).
+ *  A line that fits (≤ W) passes through whole; an overflow cuts the
+ *  content at W−1 — the ellipsis's slot — and the ellipsis rides AFTER
+ *  the reset (post-reset — the PTY needles' convention). The cut row
+ *  never exceeds W (invariant ①). */
+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 task
+ *  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 task 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 "task" 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 `task 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
+            ? `task done · ${plural(items.length, "item")} · ${formatDuration(durationSeconds)}`
+            : `task · ${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_TASK_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 task checklist as STATE, not events: the FIRST call of a
+     *  turn creates the ONE live block (done:false — the commit loop only
+     *  takes done cells, so it stays in the live region); later calls of
+     *  the SAME turn MUTATE that block in place — same position, same
+     *  height, zero committed rows (the W8 fixed-window rule generalised
+     *  to state). An unchanged whole-table replace (the task extension's
+     *  idempotent shape) is a no-op — no mark, no frame. The block commits
+     *  ONCE at the turn's end (endTurn); the next turn's first call starts
+     *  a fresh block — one settled block per turn that touched the list,
+     *  never one per update. The pipe path stays per-call (byte-linear —
+     *  every write is final; there is no in-place redraw in a pipe). */
     checklist(header: 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;