@vincemakes/kiso-tui 0.1.36 → 0.1.38

package/dist/compositor.d.ts

@@ -35,12 +35,14 @@
  *    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 { type MenuItem } from "./editor.js";
+import { type ResumeMeta } 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). */
@@ -77,15 +79,44 @@ 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";
     }[]): void;
+    /** The startup banner (W1): a LIVE cell — the tier re-derives per
+     *  frame (bannerLines with the CURRENT W and H), so a resize re-tiers
+     *  the art instead of re-folding frozen rows (a window below 40 cols
+     *  never paints the logo). W5: the resume metas ride the cell — the
+     *  list re-gates with the tier (BIG only) and re-times with the
+     *  frame. The inactive path keeps the historical bytes (no resume —
+     *  the pipe contract). */
+    banner(version: string, extensionsText: string, resume?: ResumeMeta[]): void;
     raw(lines: string[]): void;
     /** The last COMPLETE thinking block, for /think. */
     lastThinking(): string | null;
@@ -98,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;
@@ -112,7 +160,10 @@ export declare class Body {
      *  top: external writes (the CLI's console.error CRLF) can shift the
      *  committed content down, and a formula-top ED0 would clear it. */
     onResize(): void;
-    setStatus(text: string): void;
+    /** W18: the status row's right-aligned hint is part of the status
+     *  state — the compacting row passes "esc to cancel" (the affordance
+     *  must survive repaints). */
+    setStatus(text: string, hint?: string | null): void;
     setTail(tail: string): void;
     showQuestion(question: string): void;
     clearQuestion(): void;
@@ -138,7 +189,9 @@ export declare class Body {
     /** Teardown — flush a pending frame, stop the timers. */
     close(): void;
     /** The live region's scalar — the unit tests assert the cap directly
-     *  (the e2e gate pins the screen consequence). */
+     *  (the e2e gate pins the screen consequence). W11: the formula's
+     *  blanks are join artifacts — the count includes them (they are real
+     *  screen rows), threaded against the previous sibling's OWN rows. */
     liveCount(): number;
     render(): void;
 }
@@ -152,7 +205,7 @@ export declare class Dock {
     enter(): void;
     exit(): void;
     onResize(): void;
-    setStatus(text: string): void;
+    setStatus(text: string, hint?: string | null): void;
     setTail(tail: string): void;
     showQuestion(question: string): void;
     clearQuestion(): void;