@vincemakes/kiso-tui 0.14.0 → 0.15.1

package/dist/compositor.d.ts

@@ -74,6 +74,11 @@ export interface InputState {
     readonly cursorCol?: number;
 }
 export interface BodyOptions {
+    /** REL-0150-D1 test seam: overrides the TERM_PROGRAM detection for
+     *  the conservative frame mode — process.env is SHARED across
+     *  concurrently-running test files in one worker, so a test that
+     *  mutated the env would bleed 40ms frames into its neighbors. */
+    readonly termProgram?: string;
     /** Is the cell renderer live? A color TTY with a real size — checked
      *  per mutation (the TIOCSWINSZ can land after main constructs us). */
     active: () => boolean;

package/dist/compositor.js

@@ -153,9 +153,24 @@ export class Body {
     // box top), the live caps shrink by their rows, and the status
     // row's right hint shows the count while any turn waits.
     #queueState = () => [];
+    /** REL-0150-D1 — the conservative frame mode. Terminal.app does not
+     *  support DEC 2026 synchronized output (half-frames paint on its own
+     *  schedule — the reviewer dogfood watched the tearing live) and its
+     *  renderer is throughput-weak (typed input lagged seconds behind the
+     *  stream). Where TERM_PROGRAM says Apple_Terminal: the frame wraps
+     *  in ?25l/?25h (cursor hidden during the repaint — the classic
+     *  anti-tearing degrade; every frame re-shows it) instead of the dead
+     *  2026 bytes, and the coalesce window widens 16→40ms (fewer, bigger
+     *  frames: fewer tear opportunities, less renderer pressure). Every
+     *  other terminal keeps today's bytes exactly. Heuristic on purpose —
+     *  a DECRQM round-trip would race the editor for stdin at boot. */
+    #conservative;
+    #frameMs;
     constructor(opts) {
         this.#opts = opts;
         this.#write = opts.write ?? ((s) => process.stdout.write(s));
+        this.#conservative = (opts.termProgram ?? process.env.TERM_PROGRAM) === "Apple_Terminal";
+        this.#frameMs = this.#conservative ? 40 : FRAME_MS;
         this.#active = opts.active();
         // v6: the single writer — the compositor IS the dock; the CLI's
         // onDock callback (which used to re-pin the dock after a scroll)
@@ -472,9 +487,6 @@ export class Body {
             return;
         }
         this.#endMd();
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "text" && !last.done)
-            last.done = true;
         this.#mark();
     }
     /** W14 — the turn boundary's END: the CLI calls this at the run's
@@ -941,7 +953,7 @@ export class Body {
                 this.#dirty = false;
                 this.render();
             }
-        }, FRAME_MS);
+        }, this.#frameMs);
         this.#frameTimer.unref();
     }
     /** The spinner: a ONE-SHOT re-armed ONLY while a running tool exists —
@@ -1168,7 +1180,7 @@ export class Body {
             panelSpan === null ? null : { top: liveTop + panelSpan.offset, count: panelSpan.count, first: panelSpan.first };
         // 5. the frame bytes.
         const out = [];
-        out.push("\x1b[?2026h"); // synchronized output ON (DEC 2026)
+        out.push(this.#conservative ? "\x1b[?25l" : "\x1b[?2026h"); // D1: sync ON, or cursor-hide where 2026 is dead bytes
         // A8: the bottom-anchored window (the model's last H rows) shifts
         // DOWN when the live region SHRINKS — the done-fold, the fold-hold
         // release at the terminal event. The steady path's scroll syncs
@@ -1189,7 +1201,7 @@ export class Body {
         else {
             this.#drawSteady(out, W, H, liveTop, liveLines, queueRows, menuRows, editor);
         }
-        out.push("\x1b[?2026l");
+        out.push(this.#conservative ? "\x1b[?25h" : "\x1b[?2026l");
         this.#write(out.join(""));
         this.#lastLiveTop = liveTop;
         this.#lastLiveRows = liveRowsTotal;
@@ -1688,40 +1700,67 @@ export class Body {
         // content loss).
         if (skip > 0 && !overlay) {
             const leaving = Math.max(0, skip - this.#lastSkip);
-            // A8b (the fresh leaving share): a leaving row whose old-screen
-            // copy is stale — the committed-this-frame lines (their old rows
-            // held the previous live/chrome) — is pre-painted at its OLD row
-            // so the LF scroll carries it into the scrollback; the frozen
-            // leaving rows are already on screen and scroll as-is. The first
-            // overflow frame of a batch: the window's top row is the freshly
-            // committed line, NEVER on the old screen — without the
-            // pre-paint the scroll pushes a blank and the line's only paint
-            // (the clamped march at row 1) is overwritten by its neighbor.
-            if (skip > frozen.length) {
-                const fromIdx = Math.max(0, this.#lastSkip - frozen.length);
-                const top = Math.min(skip - frozen.length, all.length - frozen.length);
-                for (let i = fromIdx; i < top; i += 1) {
-                    out.push(`\x1b[${Math.max(1, frozen.length + i - this.#lastSkip + 1)};1H\x1b[0K${this.#checked(all[frozen.length + i], W)}`);
+            // TT-1B (finding TUI2-MD-1): a burst taller than the screen can
+            // NOT be staged in one pass — rows placed past H are clamped by
+            // the terminal itself (CUP pins to the last row), the pile keeps
+            // only its last member, and the scroll pushes the wreckage: the
+            // short-terminal row loss the finding measured. The transit is
+            // chunked instead: each pass paints <= H leaving rows at rows
+            // 1..chunk and scrolls exactly that many LFs, so every row is ON
+            // the screen when its scroll slot comes up. The <= H path below
+            // keeps its exact pre-round bytes (its staging never exceeds H —
+            // position <= skip - lastSkip = leaving).
+            if (leaving > H) {
+                let p = this.#lastSkip;
+                while (p < skip) {
+                    const chunk = Math.min(skip - p, H);
+                    for (let k = 0; k < chunk; k += 1) {
+                        out.push(`\x1b[${k + 1};1H\x1b[0K${this.#checked(all[p + k], W)}`);
+                    }
+                    if (chunk < H)
+                        out.push(`\x1b[${chunk + 1};1H\x1b[0J`);
+                    out.push(`\x1b[${H};1H`);
+                    for (let k = 0; k < chunk; k += 1)
+                        out.push("\n");
+                    p += chunk;
                 }
             }
-            if (leaving < skip)
-                out.push(`\x1b[${leaving + 1};1H\x1b[0J`);
-            out.push(`\x1b[${H};1H`);
-            // TUI2-R2pre ② — scroll the rows that LEFT THE WINDOW SINCE THE
-            // LAST FRAME (`leaving`), never `skip`, which is the window's
-            // ABSOLUTE top. Scrolling the absolute top re-pushed the whole
-            // history's worth of rows on EVERY full redraw — and a live-region
-            // shrink takes this path, so that was most frames of a real
-            // session. The ED above had just blanked everything below row
-            // `leaving`, so what those surplus LFs carried into the terminal's
-            // scrollback was blank rows: the large blank bands mid-history of
-            // the owner's field report. The SCREEN never showed it because the
-            // repaint below covers every row 1..H (the V6-1 rule), and the
-            // house emulator drops scrolled rows on the floor — so no gate
-            // could see it either. Measured on the 5-turn 80x24 repro: the
-            // scrollback went from 162 blank rows of 168 to 14 of 52.
-            for (let i = 0; i < leaving; i += 1)
-                out.push("\n");
+            else {
+                // A8b (the fresh leaving share): a leaving row whose old-screen
+                // copy is stale — the committed-this-frame lines (their old rows
+                // held the previous live/chrome) — is pre-painted at its OLD row
+                // so the LF scroll carries it into the scrollback; the frozen
+                // leaving rows are already on screen and scroll as-is. The first
+                // overflow frame of a batch: the window's top row is the freshly
+                // committed line, NEVER on the old screen — without the
+                // pre-paint the scroll pushes a blank and the line's only paint
+                // (the clamped march at row 1) is overwritten by its neighbor.
+                if (skip > frozen.length) {
+                    const fromIdx = Math.max(0, this.#lastSkip - frozen.length);
+                    const top = Math.min(skip - frozen.length, all.length - frozen.length);
+                    for (let i = fromIdx; i < top; i += 1) {
+                        out.push(`\x1b[${Math.max(1, frozen.length + i - this.#lastSkip + 1)};1H\x1b[0K${this.#checked(all[frozen.length + i], W)}`);
+                    }
+                }
+                if (leaving < skip)
+                    out.push(`\x1b[${leaving + 1};1H\x1b[0J`);
+                out.push(`\x1b[${H};1H`);
+                // TUI2-R2pre ② — scroll the rows that LEFT THE WINDOW SINCE THE
+                // LAST FRAME (`leaving`), never `skip`, which is the window's
+                // ABSOLUTE top. Scrolling the absolute top re-pushed the whole
+                // history's worth of rows on EVERY full redraw — and a live-region
+                // shrink takes this path, so that was most frames of a real
+                // session. The ED above had just blanked everything below row
+                // `leaving`, so what those surplus LFs carried into the terminal's
+                // scrollback was blank rows: the large blank bands mid-history of
+                // the owner's field report. The SCREEN never showed it because the
+                // repaint below covers every row 1..H (the V6-1 rule), and the
+                // house emulator drops scrolled rows on the floor — so no gate
+                // could see it either. Measured on the 5-turn 80x24 repro: the
+                // scrollback went from 162 blank rows of 168 to 14 of 52.
+                for (let i = 0; i < leaving; i += 1)
+                    out.push("\n");
+            }
         }
         if (!overlay)
             this.#lastSkip = skip;
@@ -1788,6 +1827,15 @@ export class Body {
         const overlay = this.#overlayFrame;
         const skip = overlay ? this.#lastSkip : Math.max(0, this.#committedLines + liveLines.length + CHROME_ROWS + inputExtra + queueRows.length + menuRows.length - H);
         const leaving = overlay ? 0 : Math.max(0, skip - this.#lastSkip);
+        // TT-1B (finding TUI2-MD-1): the steady staging has the same
+        // past-H clamp as the full path had — a window that moved more than
+        // a screenful in one frame cannot transit on this path at all.
+        // Delegate the oversized frame to #drawFull's chunked emission (the
+        // full path repaints every row, so the hand-off is self-contained).
+        if (leaving > H) {
+            this.#drawFull(out, W, H, liveTop, liveLines, queueRows, menuRows, editor);
+            return;
+        }
         // the jump 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 —
@@ -1999,9 +2047,6 @@ export class Body {
      *  tail block closes and its cell becomes commit-eligible. */
     #closeOpenText() {
         this.#endMd();
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "text" && !last.done)
-            last.done = true;
     }
     /** Close an open thinking cell when a new cell starts. */
     #closeOpenThinking() {

package/dist/editor.d.ts

@@ -60,6 +60,9 @@ export declare class Editor {
     onSigint(cb: () => void): void;
     onEot(cb: () => void): void;
     onEscape(cb: () => void): void;
+    /** R3a — Shift+Tab: the approval-tier cycle. The MEANING lives in the
+     *  CLI (which tier follows which); the editor only reports the key. */
+    onModeCycle(cb: () => void): void;
     onExpand(cb: () => void): void;
     /** KC2 §2: the redirect chain — the gesture hands the buffer's text
      *  over while the run is told to stop. Mirrors onEscape (a list, so
@@ -153,4 +156,10 @@ export declare class Editor {
         count: number;
         first?: number;
     } | null) | null): void;
+    /** R3a — cross-session input history: seed the recall buffer and
+     *  register the append sink. The cap and the adjacent-duplicate
+     *  collapse are unchanged; the seed takes the TAIL of what the CLI
+     *  loaded. Never persists question answers (#remember's callers
+     *  already exclude them). */
+    bindHistory(seed: readonly string[], persist: (line: string) => void): void;
 }

package/dist/editor.js

@@ -55,6 +55,9 @@ export const MENU_ITEMS = [
     { name: "/mode", desc: "switch the approval tier (manual/default/accept-edits/plan/bypass)" },
     { name: "/model", desc: "list model profiles; switch with /model <name|provider/model>" },
     { name: "/compact", desc: "summarize the older conversation to free context" },
+    // the /resume+/clear mini-spec: the session-navigation pair
+    { name: "/clear", desc: "start a fresh conversation (the old session stays resumable)" },
+    { name: "/resume", desc: "switch to another session; /resume <id> goes directly" },
     { name: "/think", desc: "show the last full thinking block" },
     { name: "/last", desc: "show the most recent tool call's input and output" },
     { name: "/status", desc: "show session id, event count, and context estimate" },
@@ -223,6 +226,12 @@ export class Editor {
     onEscape(cb) {
         this.#escapeCbs.push(cb);
     }
+    #onModeCycle = null;
+    /** R3a — Shift+Tab: the approval-tier cycle. The MEANING lives in the
+     *  CLI (which tier follows which); the editor only reports the key. */
+    onModeCycle(cb) {
+        this.#onModeCycle = cb;
+    }
     onExpand(cb) {
         this.#expandCbs.push(cb);
     }
@@ -1144,6 +1153,14 @@ export class Editor {
             this.#mouseEvent(params, final === "M");
             return;
         }
+        // R3a — Shift+Tab (CSI Z, the universal back-tab encoding) cycles
+        // the approval tier. Composer-idle ONLY: a panel, picker, menu,
+        // history browse or question owns its keys first (the W21 gate),
+        // and a mid-word back-tab has no meaning the composer would miss.
+        if (final === "Z" && params === "" && this.#composerIdle()) {
+            this.#onModeCycle?.();
+            return;
+        }
         // KC1 §4 — Shift+Enter WHERE THE TERMINAL ENCODES IT: kitty's
         // CSI-u (ESC [ 13;2 u) and xterm's modifyOtherKeys (ESC [ 27;2;13 ~).
         // Never claimed universal — Ctrl+J is the everywhere baseline; a
@@ -1736,11 +1753,25 @@ export class Editor {
      *  answers, never empties; adjacent duplicates collapse, the tail
      *  caps at 100. A redirect is a turn, so it is remembered too. */
     #remember(line) {
-        if (this.#history[this.#history.length - 1] !== line)
+        if (this.#history[this.#history.length - 1] !== line) {
             this.#history.push(line);
+            // R3a: the persistence seam — the CLI owns the file (the tui
+            // stays I/O-free); adjacent-duplicate collapse already applied
+            this.#persistHistory?.(line);
+        }
         if (this.#history.length > 100)
             this.#history.shift();
     }
+    #persistHistory = null;
+    /** R3a — cross-session input history: seed the recall buffer and
+     *  register the append sink. The cap and the adjacent-duplicate
+     *  collapse are unchanged; the seed takes the TAIL of what the CLI
+     *  loaded. Never persists question answers (#remember's callers
+     *  already exclude them). */
+    bindHistory(seed, persist) {
+        this.#history = seed.slice(-100).filter((l) => l !== "");
+        this.#persistHistory = persist;
+    }
     /** KC2 §2 — the NORMAL composer state: the redirect gesture is live
      *  ONLY here. The approval panel, the slash menu, the history browse
      *  and the queue-pop walk each OWN their keys first (the W21 "the

package/dist/status.d.ts

@@ -52,6 +52,12 @@ export declare function runningStatus(glyph: string, since: number, outTokens: n
  */
 export interface StatusMeter {
     readonly cacheHitPct: number | null;
+    /** RETIRED from the row (the owner's 2026-08-23 directive): live
+     *  prices fluctuate and the canonical table is "an approximation,
+     *  not a bill" — a four-decimal figure on the status bar claimed a
+     *  precision the data never had. The canonical cost STAYS recorded
+     *  (trace ledger, /context); the field is kept so callers need not
+     *  change shape, and it renders NOTHING. */
     readonly costUsd: number | null;
 }
 /** The IDLE row: the approval tier as the CALLER names it, the /mode

package/dist/status.js

@@ -55,8 +55,7 @@ export function idleStatus(tier, model, ctxRatio, meter) {
     const parts = [`▸ ${tier}`, "/mode to switch", model];
     if (meter?.cacheHitPct != null)
         parts.push(`CH ${Math.round(meter.cacheHitPct)}%`);
-    if (meter?.costUsd != null)
-        parts.push(`$${meter.costUsd.toFixed(4)}`);
+    // costUsd deliberately NOT rendered — see StatusMeter.costUsd.
     parts.push(`ctx left ~${ctxLeft(ctxRatio)}%`);
     return parts.join(" · ");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "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",
@@ -35,6 +35,6 @@
   },
   "homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
   "dependencies": {
-    "@vincemakes/kiso-tui-cells": "0.14.0"
+    "@vincemakes/kiso-tui-cells": "0.15.1"
   }
 }