@vincemakes/kiso-tui 0.1.35 → 0.1.36

package/dist/components.js

@@ -188,8 +188,14 @@ class ThinkingFold {
         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) {
@@ -205,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

package/package.json

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