@vincemakes/kiso-tui 0.1.34 → 0.1.36

package/dist/components.js

@@ -177,15 +177,25 @@ class ThinkingFold {
     render(W, _ctx) {
         const block = this.cell.text;
         const trimmed = escapeTerminal(block.trim());
+        // the SHORT branch is width-aware TOO: the ≤100 short-circuit was
+        // W-blind — a short block at a narrow width returned the line
+        // UNFOLDED and tripped invariant ① (the crash class still live on
+        // npm for short /think blocks after a resize).
         if (trimmed.length <= 100)
-            return [`${palette().dim}…${trimmed}${palette().reset}`];
+            return [`${palette().dim}…${widthCut(trimmed, Math.max(1, W - 1))}${palette().reset}`];
         const suffix = ` (${block.length} chars · /think)`;
         const slice = Math.max(1, W - 1 - suffix.length);
         return [`${palette().dim}…${widthCut(trimmed, slice)}${suffix}${palette().reset}`];
     }
 }
-/** The tool execution line + the approval mini-diff — every state is
- *  its own render; the lines fold (the summary gives way first). */
+/** The tool execution line + the bounded block — every state is its
+ *  own render; the lines fold (the summary gives way first). W7 (the
+ *  flow contract): the block's BODY (the rows below the header) is
+ *  capped in SCREEN rows AFTER the fold, at the current width — the
+ *  renderer-cut row (`└ +N … · ctrl+r`) sits INSIDE the cap (a
+ *  truncated block is cap−1 output rows + the cut row); the TOOL-cut
+ *  row (`└ capped by …` — the tool's OWN truncation note, W10) is a
+ *  DIFFERENT fact, never counted in the output cap. */
 class ToolExecution {
     cell;
     constructor(cell) {
@@ -201,29 +211,162 @@ class ToolExecution {
             const line = c.isError
                 ? `${p.red}✗ ${name} (${escapeTerminal(c.resultText.split("\n")[0].slice(0, 60))}, ${elapsed}s)${p.reset}`
                 : `${p.bold}✓ ${name}${p.reset} (${summary}${c.added + c.removed > 0 ? `, +${c.added} -${c.removed}` : ""}, ${elapsed}s)`;
-            return foldLine(line, W);
+            const out = foldLine(line, W);
+            out.push(...toolBlockBody(c, W));
+            return out;
         }
         if (c.state === "approval") {
-            const lines = foldLine(`→ ${name} ${summary} ${p.bold}⏸${p.reset}`, W);
-            if (c.diff !== null) {
-                for (const d of c.diff) {
-                    const body = d.kind === "-"
-                        ? `${p.red}- ${escapeTerminal(d.text)}${p.reset}`
-                        : d.kind === "+"
-                            ? `${p.green}+ ${escapeTerminal(d.text)}${p.reset}`
-                            : `${p.dim}  ${escapeTerminal(d.text)}${p.reset}`;
-                    lines.push(...foldLine(`${p.bold}▎${p.reset}${body}`, W));
-                }
-            }
-            return lines;
+            const out = foldLine(`→ ${name} ${summary} ${p.bold}⏸${p.reset}`, W);
+            out.push(...toolBlockBody(c, W));
+            return out;
         }
         if (c.state === "running") {
             const elapsed = c.startedAt !== null ? Math.max(1, Math.round((ctx.now - c.startedAt) / 1000)) : 1;
-            return foldLine(`→ ${name} ${summary} ${p.bold}${SPINNER[ctx.spinnerI % SPINNER.length]}${p.reset} ${elapsed}s`, W);
+            const out = foldLine(`→ ${name} ${summary} ${p.bold}${SPINNER[ctx.spinnerI % SPINNER.length]}${p.reset} ${elapsed}s`, W);
+            out.push(...toolBlockBody(c, W));
+            return out;
         }
         return foldLine(`→ ${name} ${summary}`, W);
     }
 }
+// ---- 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. */
+const CAP_SHELL_SETTLED = 5; // the shell output tail, settled
+const CAP_LIVE_WINDOW = 3; // the running tool's FIXED window (W8)
+const CAP_DIFF = 12; // the approval diff: head + the named middle + tail
+const CAP_ERROR = 3; // the error text head
+/** The block body rows' prefixes (W2's gutter table): │ a bounded
+ *  block's body, └ the block's last row — what was cut, where the rest
+ *  is. Structural (constraint 1) — they survive a pipe. */
+const BODY_ROW = "  │ ";
+const CUT_ROW = "  └ ";
+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 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.resultText, W)
+            : c.name.startsWith("shell")
+                ? shellTail(c.resultText, W)
+                : []
+        : c.state === "running"
+            ? liveWindow(c.resultText, W)
+            : c.state === "approval"
+                ? diffBody(c.diff, W)
+                : [];
+    const note = 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 });
+    return rows;
+}
+/** Fold result text into dim body rows (the BODY_ROW prefix): escape,
+ *  split, fold each line at W−prefix; trailing empty rows (the result's
+ *  final newline) drop. */
+function blockRows(text, W) {
+    const p = palette();
+    const textW = Math.max(1, W - visibleWidth(BODY_ROW));
+    const rows = [];
+    for (const raw of escapeTerminal(text).split("\n")) {
+        for (const row of foldLine(raw, textW))
+            rows.push(`${p.dim}${BODY_ROW}${row}${p.reset}`);
+    }
+    while (rows.length > 0 && visibleWidth(rows[rows.length - 1]) === visibleWidth(BODY_ROW))
+        rows.pop();
+    return rows;
+}
+/** The shell output tail, settled: the LAST rows, capped at 5 — the
+ *  renderer cut at the block's bottom ("earlier rows" — the conclusion
+ *  is at the end, pi's truncateToVisualLines direction). */
+function shellTail(text, W) {
+    const p = palette();
+    const rows = blockRows(text, W);
+    if (rows.length <= CAP_SHELL_SETTLED)
+        return rows;
+    const kept = CAP_SHELL_SETTLED - 1;
+    const cut = foldLine(`${p.dim}${CUT_ROW}+${rows.length - kept} earlier rows · ctrl+r${p.reset}`, W);
+    return [...rows.slice(rows.length - kept), ...cut];
+}
+/** The error text head: the FIRST rows, capped at 3 — the answer is at
+ *  the start (opencode's collapseToolOutput direction). The header row
+ *  already summarizes the first line, so the body starts at line 2. */
+function errorBody(text, W) {
+    const p = palette();
+    const rows = blockRows(text.split("\n").slice(1).join("\n"), W);
+    if (rows.length <= CAP_ERROR)
+        return rows;
+    const cut = foldLine(`${p.dim}${CUT_ROW}+${rows.length - (CAP_ERROR - 1)} more · ctrl+r${p.reset}`, W);
+    return [...rows.slice(0, CAP_ERROR - 1), ...cut];
+}
+/** The running tool's FIXED-height window (W8): exactly 3 rows from
+ *  the FIRST frame — blank-padded before output arrives, the renderer
+ *  cut inside the window. The height changes exactly once, at settle —
+ *  a cell that grows mid-list would shift every row after it on every
+ *  delta (the parallel-tools jitter). */
+function liveWindow(text, W) {
+    const p = palette();
+    if (text === "") {
+        return [`${p.dim}${BODY_ROW}${p.reset}`, `${p.dim}${BODY_ROW}${p.reset}`, `${p.dim}${CUT_ROW}waiting for output${p.reset}`];
+    }
+    const rows = blockRows(text, W);
+    if (rows.length <= CAP_LIVE_WINDOW) {
+        while (rows.length < CAP_LIVE_WINDOW)
+            rows.push(`${p.dim}${BODY_ROW}${p.reset}`);
+        return rows;
+    }
+    const cut = foldLine(`${p.dim}${CUT_ROW}+${rows.length - (CAP_LIVE_WINDOW - 1)} earlier rows · ctrl+r${p.reset}`, W);
+    return [...rows.slice(rows.length - (CAP_LIVE_WINDOW - 1)), ...cut];
+}
+/** The approval mini-diff (W7): capped at 12 folded rows — the head +
+ *  the named middle (the renderer cut — what was cut, how to expand) +
+ *  the tail. The rows are folded at the current width BEFORE the cap —
+ *  the R1 measured bug: truncateDiff capped at 40 ENTRIES while the
+ *  fold turned them into 73 SCREEN rows at W≤80 (a 44-row terminal's
+ *  content cap is H−4 = 40 — the approval force-committed a third of
+ *  the screen into scrollback inside one frame). */
+function diffBody(diff, W) {
+    const p = palette();
+    if (diff === null)
+        return [];
+    const rows = [];
+    for (const d of diff) {
+        const body = d.kind === "-"
+            ? `${p.red}- ${escapeTerminal(d.text)}${p.reset}`
+            : d.kind === "+"
+                ? `${p.green}+ ${escapeTerminal(d.text)}${p.reset}`
+                : `${p.dim}  ${escapeTerminal(d.text)}${p.reset}`;
+        rows.push(...foldLine(`${p.bold}▎${p.reset}${body}`, W));
+    }
+    if (rows.length <= CAP_DIFF)
+        return rows;
+    const head = Math.floor((CAP_DIFF - 1) / 2);
+    const tail = CAP_DIFF - 1 - head;
+    const cut = foldLine(`${p.dim}${CUT_ROW}+${rows.length - head - tail} rows · ctrl+r to expand · /last for the full diff${p.reset}`, W);
+    return [...rows.slice(0, head), ...cut, ...rows.slice(rows.length - tail)];
+}
+/** The TOOL's OWN truncation note (W10) — a different fact from the
+ *  renderer's cut: the tools truncate and append a continuation note
+ *  (packages/tools-node/src/index.ts — read_file's "call again with
+ *  offset=N", the output cap, list_dir's entry cap). The note reaches
+ *  the MODEL and never the human — this row surfaces it. Detected in
+ *  the result's TAIL (the note is appended at the end); returns null
+ *  when the tool did not truncate. */
+function toolCutNote(name, resultText) {
+    const tail = resultText.slice(-300);
+    const m = /offset=(\d+)/.exec(tail);
+    if (m !== null)
+        return `capped by ${escapeTerminal(name)} · offset=${m[1]} for the rest`;
+    if (/…\[truncated\]/.test(tail) || /… \+?\d+ more (?:lines|entries)/.test(tail))
+        return `capped by ${escapeTerminal(name)} · /last for the rest`;
+    return null;
+}
 /** The assistant body text — wrapped at W, the inline-code tint per
  *  row (the #16e rule: a span never matches across rows). */
 class AssistantMessage {

package/dist/compositor.d.ts

@@ -20,10 +20,13 @@
  *    sharp edge (asserted by the VT-emulator gate);
  *  - two crash invariants: ① every emitted line's visible width ≤ W
  *    (components fold; a violation THROWS with diagnostics — pi
- *    tui-main-screen.ts:447-473, no silent truncate); ② within the
- *    live region only RELATIVE cursor moves (vertical A/B, horizontal
- *    G/D) — CUP exists only in the full-redraw path (the first frame,
- *    the resize repaint);
+ *    tui-main-screen.ts:447-473, no silent truncate); ② every steady-
+ *    frame CUP lands in the CONTENT area (rows ≤ H−4−menu — the
+ *    committed band, the stale/gap ELs, and the LIVE lines at their
+ *    model rows; fix C's sanctioned reinterpretation, ADR-0046) — the
+ *    CHROME rows (H−3..H) are RELATIVE-only (vertical A/B, horizontal
+ *    G/D); CUP over the whole screen exists only in the full-redraw
+ *    path (the first frame, the resize repaint);
  *  - the cursor DERIVES from the frame: the focus component embeds the
  *    APC marker in its rendered line; the compositor locates, strips,
  *    and relatively positions from the frame — no side-channel cursor

package/dist/compositor.js

@@ -20,10 +20,13 @@
  *    sharp edge (asserted by the VT-emulator gate);
  *  - two crash invariants: ① every emitted line's visible width ≤ W
  *    (components fold; a violation THROWS with diagnostics — pi
- *    tui-main-screen.ts:447-473, no silent truncate); ② within the
- *    live region only RELATIVE cursor moves (vertical A/B, horizontal
- *    G/D) — CUP exists only in the full-redraw path (the first frame,
- *    the resize repaint);
+ *    tui-main-screen.ts:447-473, no silent truncate); ② every steady-
+ *    frame CUP lands in the CONTENT area (rows ≤ H−4−menu — the
+ *    committed band, the stale/gap ELs, and the LIVE lines at their
+ *    model rows; fix C's sanctioned reinterpretation, ADR-0046) — the
+ *    CHROME rows (H−3..H) are RELATIVE-only (vertical A/B, horizontal
+ *    G/D); CUP over the whole screen exists only in the full-redraw
+ *    path (the first frame, the resize repaint);
  *  - the cursor DERIVES from the frame: the focus component embeds the
  *    APC marker in its rendered line; the compositor locates, strips,
  *    and relatively positions from the frame — no side-channel cursor
@@ -674,17 +677,16 @@ export class Body {
     #drawSteady(out, W, H, liveTop, liveLines, menuRows, ctx) {
         const editor = this.#inputRow(W, ctx); // derived from the frame — the marker
         const committed = this.#committedLinesThisFrame;
-        // the commits' scrolls — from the anchor (H−1) down to H, then LF
-        if (committed.length > 0) {
-            out.push("\x1b[1B");
-            for (let i = 0; i < committed.length; i += 1)
-                out.push("\n");
-        }
-        else {
-            // no commits — jump from the anchor (H−2) straight to the
-            // bottom row H (the commit path's LFs left the cursor there)
-            out.push("\x1b[2B");
-        }
+        // the jump from the anchor (H−2) straight to the bottom row H,
+        // then N real LFs scroll the screen exactly N rows — ONE per
+        // committed line (the bookkeeping; the stale 1B anchor jumped to
+        // H−1 and the N LFs scrolled only N−1 — the committed section sat
+        // one row short in the scrollback). The bottom-up repaint below
+        // overwrites the scrolled-in rows (the scroll count is screen-
+        // neutral — proven by the emulator probe).
+        out.push("\x1b[2B");
+        for (let i = 0; i < committed.length; i += 1)
+            out.push("\n");
         // the bottom-up repaint, from the last row up — V6-3: the design
         // §03 chrome: status (H), lower ╌ (H−1), input (H−2), upper ╌ (H−3)
         out.push(`\x1b[1G\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W), W)}`); // H — the status
@@ -694,17 +696,26 @@ export class Body {
         for (let i = menuRows.length - 1; i >= 0; i -= 1) {
             out.push(`\x1b[1A\x1b[1G\x1b[0K${this.#checked(menuRows[i], W)}`);
         }
-        for (let i = liveLines.length - 1; i >= 0; i -= 1) {
-            out.push(`\x1b[1A\x1b[1G\x1b[0K${this.#checked(liveLines[i], W)}`);
+        // the LIVE lines at their MODEL rows — CUP, never the relative
+        // march: the march drew them adjacent to the chrome (rows
+        // H−3−n..H−3) while the model placed them at [liveTop..liveTop+n−1]
+        // — in the unclamped geometry the gap ELs below erased the march's
+        // copy and the streamed text was INVISIBLE until the commit frame.
+        // The CUP rows land in the content area (≤ H−4−menu ≤ 21), inside
+        // the frozen CUP budget of invariant ②.
+        for (let i = 0; i < liveLines.length; i += 1) {
+            out.push(`\x1b[${liveTop + i};1H\x1b[0K${this.#checked(liveLines[i], W)}`);
         }
         // the FROZEN area — CUP (absolute rows; this is the FREEZE path —
-        // the old code's frozen writes were CUP too. The live region above
-        // keeps the relative-only rule; the frozen rows are computed from
-        // the current geometry, so external writes (the CLI's console.error
-        // CRLF) cannot misplace them the way a relative march could).
+        // the old code's frozen writes were CUP too. The frozen rows are
+        // computed from the current geometry, so external writes (the CLI's
+        // console.error CRLF) cannot misplace them the way a relative march
+        // could).
         // 1. the GAP rows (between the live content and the chrome) — EL'd
-        //    so the old content there cannot ghost.
-        for (let r = liveTop + liveLines.length; r <= H - 4; r += 1) {
+        //    so the old content there cannot ghost; the range stops ABOVE
+        //    the menu (the menu's rows at [H−3−menu..H−4] are marched and
+        //    must survive — the unclamped geometry erased them).
+        for (let r = liveTop + liveLines.length; r <= H - 4 - menuRows.length; r += 1) {
             out.push(`\x1b[${r};1H\x1b[0K`);
         }
         // 2. the STALE rows above the committed section — the scrolled old
@@ -721,9 +732,21 @@ export class Body {
             out.push(`\x1b[${Math.max(1, liveTop - committed.length + i)};1H\x1b[0K${this.#checked(committed[i], W)}`);
         }
         // the cursor: down to the anchor (H−2, the input row) + left to the marker —
-        // the down-distance from the LAST written row (the committed bottom,
-        // the stale bottom, or the gap bottom when nothing else wrote).
-        const lastRow = committed.length > 0 ? liveTop - 1 : staleFrom < liveTop ? liveTop - 1 : H - 4;
+        // 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 ╌.
+        const lastRow = committed.length > 0
+            ? Math.max(1, liveTop - 1)
+            : staleFrom < liveTop
+                ? liveTop - 1
+                : liveTop + liveLines.length <= H - 4 - menuRows.length
+                    ? H - 4 - menuRows.length
+                    : liveLines.length > 0
+                        ? liveTop + liveLines.length - 1
+                        : menuRows.length > 0
+                            ? H - 3 - menuRows.length
+                            : H - 3;
         const down = H - 2 - lastRow; // the anchor: the input row (H−2)
         if (down > 0)
             out.push(`\x1b[${down}B`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "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",