@vincemakes/kiso-tui 0.39.2 → 0.40.0

package/dist/compositor.d.ts

@@ -132,10 +132,13 @@ export declare class Body {
     toolProgress(callId: string, text: string): void;
     toolSucceeded(callId: string): void;
     toolFailed(callId: string, error: string): void;
+    /** `untimed`: 4c's replay settles a card from the durable log, whose
+     *  events carry no clock — the card then says nothing about time. */
     toolResult(callId: string, result: {
         content: string;
         isError: boolean;
         reason?: string | null;
+        untimed?: boolean;
     }): void;
     textAppend(text: string): void;
     textEnd(): void;
@@ -144,6 +147,18 @@ export declare class Body {
      *  CLI's wall-clocked thinking window. */
     endTurn(thoughtSeconds: number): void;
     terminal(label: string, statusLineText: string): void;
+    /**
+     * 4c — fold what `replay` puts on the body into ONE row. The replayed
+     * cells are the same cells a live run makes (the caller drives the
+     * ordinary mutations), moved out of the transcript into the fold cell:
+     * the row commits as one line and never expands on screen — so a resize
+     * reprint redraws one row however long the history — and the ctrl+r
+     * viewer reads them. Mutations only schedule frames, so nothing the
+     * replay adds can have committed before it is moved. Active bodies
+     * only: a pipe has no viewer to read a fold with (the caller prints the
+     * plain tail there).
+     */
+    fold(label: string, replay: () => void, summary?: string | null): 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
@@ -339,8 +354,19 @@ export declare class Body {
      *  reads it — the marker math never desyncs by construction). */
     editCol(): number;
     /** The old dock's redraw — the editor's onRender target: mark + the
-     *  scheduler (16ms coalescing — the old sync draw coalesces the same). */
-    redraw(): void;
+     *  scheduler (16ms coalescing — the old sync draw coalesces the same).
+     *
+     *  Item 6: a KEY-originated redraw paints on the next tick and takes
+     *  the pending trailing frame with it. Keyboard input is the one
+     *  latency-sensitive source: the trailing window made every key wait
+     *  16 ms, and 40 ms on Terminal.app — where an IME commit erases the
+     *  terminal's marked text at once and the committed characters came
+     *  back a frame window later, a visible blink. Stream, tool and
+     *  spinner marks keep the trailing window exactly (the conservative
+     *  mode's throughput protection is for them). setImmediate, not a
+     *  synchronous paint: every mutation one chunk of keys makes still
+     *  lands in one frame. */
+    redraw(fromKey?: boolean): void;
     /** Teardown — flush a pending frame, stop the timers. */
     close(): void;
     /** The live region's scalar — the unit tests assert the cap directly
@@ -403,5 +429,5 @@ export declare class Dock {
      *  the LineInput's own bindQueue). */
     bindQueue(state: () => readonly string[]): void;
     editCol(): number;
-    redraw(): void;
+    redraw(fromKey?: boolean): void;
 }

package/dist/compositor.js

@@ -197,6 +197,10 @@ export class Body {
     #lastInputRows = 1;
     #lastAnchorRow = 0;
     #frameTimer = null;
+    #inputFrame = null;
+    /** Body mutations and non-key redraws so far — the input frame's
+     *  "did anything but typing change the screen?" */
+    #runMarks = 0;
     #spinnerTimer = null;
     #spinnerI = 0;
     #lastThinking = null;
@@ -520,6 +524,8 @@ export class Body {
             this.#write(`${p.red}  failed: ${escapeTerminal(error.slice(0, 160))}${p.reset}\n`);
         }
     }
+    /** `untimed`: 4c's replay settles a card from the durable log, whose
+     *  events carry no clock — the card then says nothing about time. */
     toolResult(callId, result) {
         const call = this.#pendingCalls.get(callId);
         if (call !== undefined) {
@@ -543,7 +549,7 @@ export class Body {
             cell.isError = result.isError;
             cell.resultText = result.content;
             cell.reason = result.reason ?? null;
-            cell.doneAt = Date.now();
+            cell.doneAt = result.untimed === true ? null : Date.now();
             cell.done = true;
         }
         this.#mark();
@@ -692,6 +698,31 @@ export class Body {
         this.#cells.push({ kind: "terminal", label: label.trim(), line: statusLineText, done: true });
         this.#mark();
     }
+    /**
+     * 4c — fold what `replay` puts on the body into ONE row. The replayed
+     * cells are the same cells a live run makes (the caller drives the
+     * ordinary mutations), moved out of the transcript into the fold cell:
+     * the row commits as one line and never expands on screen — so a resize
+     * reprint redraws one row however long the history — and the ctrl+r
+     * viewer reads them. Mutations only schedule frames, so nothing the
+     * replay adds can have committed before it is moved. Active bodies
+     * only: a pipe has no viewer to read a fold with (the caller prints the
+     * plain tail there).
+     */
+    fold(label, replay, summary = null) {
+        if (!this.#isActive())
+            return;
+        const start = this.#cells.length;
+        replay();
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        const children = this.#cells.splice(start);
+        for (const cell of children)
+            if (!cell.done)
+                cell.done = true; // a replay settles; nothing in a fold is live
+        this.#cells.push({ kind: "fold", label, children, summary, done: true });
+        this.#mark();
+    }
     notice(text) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
@@ -935,8 +966,15 @@ export class Body {
             const cell = this.#cells[idx];
             if (cell === undefined)
                 continue;
-            // R13 — the viewer's FOLD entry retired with the fold: every
-            // entry is now a card, and a card's entry is its own full body.
+            // 4c — the resumed history's fold: the head is its one row, the
+            // body is the replayed turns rendered at the viewer's width —
+            // the checkpoint's summary first when it is one.
+            if (cell.kind === "fold") {
+                out.push({ head: cellComponent(cell).render(inner, ctx)[0] ?? "", body: this.#foldBody(cell, inner, ctx) });
+                continue;
+            }
+            // R13 — every other entry is a card, and a card's entry is its
+            // own full body.
             if (cell.kind !== "tool")
                 continue;
             // the tool card's FULL body — the same rows its own ctrl+o
@@ -959,6 +997,24 @@ export class Body {
         }
         return out;
     }
+    /** 4c — a fold's children as the transcript would have shown them: each
+     *  cell's own render, spaced by the body's own formula (no blank between
+     *  two blocks of one message). */
+    #foldBody(cell, W, ctx) {
+        const out = [];
+        let prev = null;
+        let prevKind = null;
+        const cells = cell.summary === null ? cell.children : [{ kind: "raw", lines: cell.summary.split("\n"), done: true, wrap: "words" }, ...cell.children];
+        for (const child of cells) {
+            const rows = cellComponent(child).render(W, ctx);
+            if (rows.length === 0)
+                continue;
+            out.push(...(prevKind === "md" && child.kind === "md" ? rows : bodySpacing(prev, rows)));
+            prev = rows;
+            prevKind = child.kind;
+        }
+        return out;
+    }
     /** The viewer's band: its title, its list, its keys. */
     #viewerBand(W) {
         if (this.#viewer === null)
@@ -1513,20 +1569,64 @@ export class Body {
         return 1 + leadWidth(lead) + st.cursor;
     }
     /** The old dock's redraw — the editor's onRender target: mark + the
-     *  scheduler (16ms coalescing — the old sync draw coalesces the same). */
-    redraw() {
+     *  scheduler (16ms coalescing — the old sync draw coalesces the same).
+     *
+     *  Item 6: a KEY-originated redraw paints on the next tick and takes
+     *  the pending trailing frame with it. Keyboard input is the one
+     *  latency-sensitive source: the trailing window made every key wait
+     *  16 ms, and 40 ms on Terminal.app — where an IME commit erases the
+     *  terminal's marked text at once and the committed characters came
+     *  back a frame window later, a visible blink. Stream, tool and
+     *  spinner marks keep the trailing window exactly (the conservative
+     *  mode's throughput protection is for them). setImmediate, not a
+     *  synchronous paint: every mutation one chunk of keys makes still
+     *  lands in one frame. */
+    redraw(fromKey = false) {
         if (!this.#isActive())
             return;
         this.#dirty = true;
+        if (fromKey) {
+            this.#scheduleInputFrame();
+            return;
+        }
+        this.#runMarks += 1; // a non-key redraw is not typing: it keeps the window
         this.#scheduleFrame();
     }
     // ---- the scheduler (event-driven; zero heartbeat timers) ----
     #mark() {
         if (!this.#isActive())
             return;
+        this.#runMarks += 1;
         this.#dirty = true;
         this.#scheduleFrame();
     }
+    #scheduleInputFrame() {
+        if (this.#inputFrame !== null)
+            return;
+        const marksAtKey = this.#runMarks;
+        this.#inputFrame = setImmediate(() => {
+            this.#inputFrame = null;
+            // A key whose consequence is run state (an approval verdict, a
+            // submit) mutates the body before this tick. That frame carries
+            // the run, so it keeps the run's trailing window, exactly as
+            // before: painting it now showed an approved write's transient
+            // live card for one frame before its result settled.
+            if (this.#runMarks !== marksAtKey) {
+                if (this.#dirty)
+                    this.#scheduleFrame();
+                return;
+            }
+            if (this.#frameTimer !== null) {
+                clearTimeout(this.#frameTimer);
+                this.#frameTimer = null;
+            }
+            if (this.#dirty) {
+                this.#dirty = false;
+                this.render();
+            }
+        });
+        this.#inputFrame.unref();
+    }
     #scheduleFrame() {
         if (this.#frameTimer !== null)
             return;
@@ -1574,6 +1674,10 @@ export class Body {
     }
     /** Teardown — flush a pending frame, stop the timers. */
     close() {
+        if (this.#inputFrame !== null) {
+            clearImmediate(this.#inputFrame);
+            this.#inputFrame = null;
+        }
         if (this.#frameTimer !== null) {
             clearTimeout(this.#frameTimer);
             this.#frameTimer = null;
@@ -2024,6 +2128,9 @@ export class Body {
         // oldest-first, so the newest cut is at the front.
         if (cell.kind === "tool" && lines.some((l) => l.includes("ctrl+o")))
             this.#collapsed.unshift(i);
+        // 4c: a fold is read in the viewer and nowhere else.
+        if (cell.kind === "fold")
+            this.#collapsed.unshift(i);
         this.#lineCache[i] = lines;
         const placed = this.#space(i, i > 0 ? this.#lineCache[i - 1] : null, lines);
         this.#committed += 1;
@@ -2848,8 +2955,8 @@ export class Dock {
     editCol() {
         return compositorRef?.editCol() ?? 1;
     }
-    redraw() {
-        compositorRef?.redraw();
+    redraw(fromKey = false) {
+        compositorRef?.redraw(fromKey);
     }
 }
 /** The one-compositor registry — the Dock façade routes to it. */

package/dist/context-ledger.d.ts

@@ -58,6 +58,11 @@ export interface ContextLedger {
  * the detail text rides after them, dim, and is cut by the caller's
  * width if it must be.
  */
+/** 0.40.0 — the ONE fill rule for a ▰▱ meter: `ratio` of `cells`, rounded,
+ *  clamped to the bar. The `/context` bar and the compacting row's bar both
+ *  draw through it, so the two cannot fill differently. Plain glyphs; the
+ *  caller styles them. */
+export declare function meterGlyphs(ratio: number, cells: number): string;
 export declare function contextRows(ledger: ContextLedger): string[];
 /** TUI2-R1 (E) — the honest fallback. The ledger is written PER REQUEST:
  *  a session that has not called the model yet has no sidecar, and the

package/dist/context-ledger.js

@@ -45,15 +45,24 @@ function k(n) {
  * the detail text rides after them, dim, and is cut by the caller's
  * width if it must be.
  */
+/** 0.40.0 — the ONE fill rule for a ▰▱ meter: `ratio` of `cells`, rounded,
+ *  clamped to the bar. The `/context` bar and the compacting row's bar both
+ *  draw through it, so the two cannot fill differently. Plain glyphs; the
+ *  caller styles them. */
+export function meterGlyphs(ratio, cells) {
+    const filled = Math.max(0, Math.min(cells, Math.round((Number.isFinite(ratio) ? ratio : 0) * cells)));
+    return `${"\u25b0".repeat(filled)}${"\u25b1".repeat(cells - filled)}`;
+}
 export function contextRows(ledger) {
     const p = palette();
     const used = ledger.systemPrompt + ledger.toolTable + ledger.skillsIndex + ledger.envelope + ledger.messages;
     const free = Math.max(0, ledger.window - used);
     const ratio = ledger.window > 0 ? Math.min(1, used / ledger.window) : 1;
-    const filled = Math.max(0, Math.min(BAR_CELLS, Math.round(ratio * BAR_CELLS)));
+    const bar = meterGlyphs(ratio, BAR_CELLS);
+    const filled = bar.indexOf("\u25b1") < 0 ? BAR_CELLS : bar.indexOf("\u25b1");
     const rows = [
         `${p.bold}context — ${k(used)} / ${k(ledger.window)} tokens (${Math.round(ratio * 100)}%)${p.reset}`,
-        `${p.bold}${"▰".repeat(filled)}${p.reset}${p.dim}${"▱".repeat(BAR_CELLS - filled)}${p.reset}`,
+        `${p.bold}${bar.slice(0, filled)}${p.reset}${p.dim}${bar.slice(filled)}${p.reset}`,
     ];
     /** One surface row: the label at 14 columns, the count right-aligned
      *  at 5, then the dim detail. */

package/dist/editor.d.ts

@@ -65,7 +65,7 @@ export declare const MENU_ITEMS: readonly MenuItem[];
 export declare class Editor {
     #private;
     readonly closed: Promise<void>;
-    constructor(onRender: () => void);
+    constructor(onRender: (fromKey: boolean) => void);
     /**
      *  DC-7 — the terminal answering a question kiso asked it.
      *
@@ -153,6 +153,9 @@ export declare class Editor {
         items: readonly MenuItem[];
         selected: number;
     } | null;
+    /** 0.40.1 — bind the menu's extra entries (the CLI binds the installed
+     *  skills). A function, read per keystroke, never a snapshot. */
+    bindMenuExtras(extras: () => readonly MenuItem[]): void;
     /** KC3 §3 — bind the file source. The tui owns no file list and
      *  never touches a disk (input is data, output is bytes): the CLI
      *  feeds the paths, and until it does, the picker cannot open at
@@ -168,7 +171,7 @@ export declare class Editor {
         capped: boolean;
     } | null;
     /** Open the picker on a bound card source (PickInput, S5). */
-    beginPick(cards: () => readonly SessionCardView[], onPick: (id: string | null) => void): void;
+    beginPick(cards: () => readonly SessionCardView[], onPick: (id: string | null) => void, here?: string): void;
     pickState(): SessionPickState | null;
     /** One-shot question mode: the NEXT submit answers, not a turn. */
     question(_query: string, cb: (answer: string) => void): void;

package/dist/editor.js

@@ -110,7 +110,7 @@ export const MOUSE_OFF = "\x1b[?1000l\x1b[?1006l";
 export const PROMPT = "▌ ";
 export const PROMPT_WIDTH = displayWidth(PROMPT);
 export const MENU_ITEMS = [
-    { name: "/mode", desc: "switch the approval tier (manual/default/accept-edits/plan/bypass)" },
+    { name: "/mode", desc: "switch the approval tier (default/accept-edits/plan/dontAsk/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
@@ -130,6 +130,10 @@ export const MENU_ITEMS = [
     { name: "/status", desc: "show session id, event count, and context estimate" },
     // TUI2-R1 (E): the rent-ledger attribution — where the context went
     { name: "/context", desc: "show where the context went — the last request's rent ledger" },
+    // 0.40.0: the person's door to the installed skills — `/<name>` works
+    // too when no command here has that name.
+    { name: "/skills", desc: "list the installed skills — /<name> [args] runs one" },
+    { name: "/skill", desc: "run a skill as your turn: /skill <name> [args]" },
     { name: "/help", desc: "print this list of commands" },
 ];
 /** KC1 §3 — the newline code point. Every source (paste, Ctrl+J, the
@@ -341,6 +345,14 @@ export class Editor {
      *  KEY, the CLI owns what it means. */
     #copyCbs = [];
     #onRender;
+    /** Item 6: true while a chunk of keys is being fed — the render hook
+     *  is told a frame is key-originated, and the compositor paints it on
+     *  the next tick instead of waiting out the trailing frame window. */
+    #feeding = false;
+    /** Item 6: set when a key in this chunk handed control to the run —
+     *  a submitted line or a panel verdict. What follows is run state, not
+     *  typing, so its frames keep the run's trailing window. */
+    #handedOff = false;
     /** TUI2-R1 (D): the keys sheet — a static one-screen overlay opened by
      *  `?` on an empty composer and closed by the next key, whatever it
      *  is. Deliberately a BOOLEAN and not a panel: the panel machinery
@@ -348,6 +360,9 @@ export class Editor {
      *  buffer), and the sheet has no interaction to speak of. */
     #sheetOpen = false;
     #menuOpen = false; // v3 §04: the slash-command menu
+    /** 0.40.1: the menu's extra entries (the installed skills), read LIVE on
+     *  every keystroke — a skill added by /reload appears without rebinding. */
+    #menuExtras = () => [];
     #menuSel = 0;
     // KC3 §3 — the @ file picker. THREE fields and no more: the armed
     // bit, the selection, and the per-open SNAPSHOT of the file list.
@@ -420,7 +435,7 @@ export class Editor {
     #closedResolve;
     closed;
     constructor(onRender) {
-        this.#onRender = onRender;
+        this.#onRender = () => onRender(this.#feeding && !this.#handedOff);
         this.#onData = (raw) => this.feed(raw);
         this.closed = new Promise((resolve) => {
             this.#closedResolve = resolve;
@@ -794,11 +809,28 @@ export class Editor {
         const line = this.line();
         if (!line.startsWith("/"))
             return [];
-        return MENU_ITEMS.filter((m) => m.name.startsWith(line));
+        // 0.40.1: the built-ins first, then the extras (skills) — and a
+        // built-in WINS a shared name, so a skill named like a command is
+        // never listed twice and never shadows it (the dispatcher's rule)
+        const builtins = new Set(MENU_ITEMS.map((m) => m.name));
+        const all = [...MENU_ITEMS, ...this.#menuExtras().filter((m) => !builtins.has(m.name))];
+        return all.filter((m) => m.name.startsWith(line));
+    }
+    /** 0.40.1 — bind the menu's extra entries (the CLI binds the installed
+     *  skills). A function, read per keystroke, never a snapshot. */
+    bindMenuExtras(extras) {
+        this.#menuExtras = extras;
     }
     #refreshMenu() {
-        if (this.#panelInput.up())
-            return; // W21: the menu never opens while the panel owns the keys
+        if (this.#panelInput.up()) {
+            // W21: the menu never opens while the panel owns the keys — but
+            // the key that got here still changed the line, and insert and
+            // delete render only through this method (item 6: returning
+            // before the render left a panel's typed text to ride the next
+            // spinner tick, 0–150 ms late, or no tick at all).
+            this.#onRender();
+            return;
+        }
         const f = this.#menuFiltered();
         this.#menuOpen = f.length > 0;
         if (this.#menuSel >= f.length)
@@ -938,8 +970,8 @@ export class Editor {
     }
     // ── TUI2-R2 ② — the session picker ───────────────────────────────
     /** Open the picker on a bound card source (PickInput, S5). */
-    beginPick(cards, onPick) {
-        this.#pickInput.begin(cards, onPick);
+    beginPick(cards, onPick, here) {
+        this.#pickInput.begin(cards, onPick, here);
     }
     pickState() {
         return this.#pickInput.state();
@@ -957,7 +989,15 @@ export class Editor {
      *  stashed and restored at close, the panel takes the keys and the
      *  input row's lead, the composer's own bands close. */
     beginPanel(view, onCommit, opts) {
-        this.#panelInput.begin(view, onCommit, opts);
+        const handOff = (v) => {
+            // item 6: a verdict hands the frame to the run. The panel already
+            // asked for a key frame on this key; the non-key render after the
+            // verdict demotes it to the run's window.
+            this.#handedOff = true;
+            onCommit(v);
+            this.#onRender();
+        };
+        this.#panelInput.begin(view, handOff, opts);
     }
     /** W21: cancel the panel — the SIGINT path's pair to beginPanel. */
     cancelPanel() {
@@ -1074,6 +1114,21 @@ export class Editor {
     // ---- input ----
     /** Feed raw stdin bytes — the parser. Public for unit tests. */
     feed(raw) {
+        const outer = this.#feeding;
+        const outerHandedOff = this.#handedOff;
+        this.#feeding = true;
+        if (!outer)
+            this.#handedOff = false;
+        try {
+            this.#feedKeys(raw);
+        }
+        finally {
+            this.#feeding = outer;
+            if (!outer)
+                this.#handedOff = outerHandedOff;
+        }
+    }
+    #feedKeys(raw) {
         const text = this.#pending + this.#decoder.decode(raw, { stream: true });
         this.#pending = "";
         // TUI2-R1 (D): the sheet is up — ANY key closes it, and the key
@@ -1512,6 +1567,10 @@ export class Editor {
                 }
                 i += 1;
             }
+            else if (c === "\t" && this.#pickInput.toggleScope()) {
+                // 0.40.0: the session picker's scope — this workspace ↔ all
+                i += 1;
+            }
             else if (c === "\t" && this.#atUp()) {
                 // KC3 §3: Tab accepts the selected path — the token becomes
                 // `@<path> `. Never the file's content.
@@ -2436,6 +2495,7 @@ export class Editor {
         // recalls a readable line that still expands when it is sent
         // again (the map outlives the buffer, by design).
         const sent = this.#expandPastes(line);
+        this.#handedOff = true;
         const cb = this.#questionCb;
         this.#questionCb = null;
         if (cb !== null) {
@@ -2449,7 +2509,7 @@ export class Editor {
         }
         if (cb === null && line !== "")
             this.#remember(line);
-        this.#onRender();
+        this.#onRender(); // item 6: #handedOff is set, so this render is non-key — the submit's frame keeps the run's window
     }
     /** A2: step the history browse; a delta past the newest exits back to
      *  the pre-browse input. */

package/dist/index.d.ts

@@ -12,12 +12,12 @@ export { Container, foldLine, foldWords, visibleWidth, SPINNER, type Component,
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, type MenuItem, } from "./editor.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, currentGround, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type PathResolver, type RecapStats, type ResumeMeta, type RenderInput, type RenderResult, type RunUsage, } from "./lines.js";
 export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";
-export { STATUS_GLYPHS, cacheHitPct, decodeRate, idleStatus, runningStatus, type StatusMeter } from "./status.js";
+export { STATUS_GLYPHS, cacheHitPct, compactingStatus, composeRow, decodeRate, idleStatus, retrySegment, runningStatus, type CompactingProgress, type RetryOnRow, type RowSegment, type StatusMeter } from "./status.js";
 export { contextRows, contextUnavailableRows, type ContextLedger } from "./context-ledger.js";
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, verifyOfferView, type TrustArtifact } from "./strings.js";
 export { AT_CAP, AT_SKIP, AT_VISIBLE, atEmbed, atFilter, atPanelRows, atWindow, bandHeader, longestRun, type AtItem, type AtMatch } from "./at-picker.js";
-export { BADGE_GLYPH, idColumn, sessionAge, sessionBadge, sessionCounterRow, sessionFilter, sessionListFooter, sessionListRow, sessionNote, sessionPickerRows, sessionRow, type SessionCardView, type SessionPickState, } from "./session-picker.js";
+export { idColumn, sessionAge, sessionCounterRow, sessionFilter, sessionListFooter, sessionListHeader, sessionListUnknownLine, sessionListRow, sessionNote, sessionPickerRows, sessionRow, scopeSessions, scopeTitle, type PickScopeState, type SessionCardView, type SessionPickState, } from "./session-picker.js";
 export { ASK_HEADER_CAP, ASK_MAX_OPTIONS, ASK_MAX_QUESTIONS, ASK_MIN_OPTIONS, askAffordance, askAnswers, askBlockRows, askCommitCustom, askDeclineAll, askDeclineList, askKey, askLeadPlain, askStart, askStatus, askView, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, type AskStep, } from "./ask-panel.js";
 export { resolveGround, type Ground } from "@vincemakes/kiso-tui-cells";
 export { settledLabel } from "@vincemakes/kiso-tui-cells";
-export { KEY_BINDINGS, PANEL_KEYS_ROW, displayVerb, extensionsBannerText, helpRows, keysHelpRow, keysSheetRows, slashCommandNames, unansweredAskView, type BannerExtension, type KeyBinding } from "./strings.js";
+export { KEY_BINDINGS, PANEL_KEYS_ROW, coldResumeLine, coldResumeView, displayVerb, extensionsBannerText, helpRows, keysHelpRow, keysSheetRows, slashCommandNames, unansweredAskView, type BannerExtension, type KeyBinding } from "./strings.js";

package/dist/index.js

@@ -19,7 +19,7 @@ export { bannerLines, COLOR_OFF, COLOR_ON, currentGround, setGround, escapeTermi
 export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";
 // KC2 §5: the status rows' formatters — the CLI keeps the state and the
 // repaint, the terminal layer owns what the row says.
-export { STATUS_GLYPHS, cacheHitPct, decodeRate, idleStatus, runningStatus } from "./status.js";
+export { STATUS_GLYPHS, cacheHitPct, compactingStatus, composeRow, decodeRate, idleStatus, retrySegment, runningStatus } from "./status.js";
 // TUI2-R1 (E): /context's attribution rows — a pure function of the
 // counts the trace sidecar already records (the CLI reads, this renders).
 export { contextRows, contextUnavailableRows } from "./context-ledger.js";
@@ -33,7 +33,10 @@ export { AT_CAP, AT_SKIP, AT_VISIBLE, atEmbed, atFilter, atPanelRows, atWindow,
 // TUI2-R2 ①–③: the session picker's pure half — the durability badge,
 // the row (picked or printed), the band, and the filter. The CARDS are
 // the cli's projection (session-cards.ts); this turns them into bytes.
-export { BADGE_GLYPH, idColumn, sessionAge, sessionBadge, sessionCounterRow, sessionFilter, sessionListFooter, sessionListRow, sessionNote, sessionPickerRows, sessionRow, } from "./session-picker.js";
+export { idColumn, sessionAge, sessionCounterRow, sessionFilter, sessionListFooter, sessionListHeader, sessionListUnknownLine, sessionListRow, sessionNote, sessionPickerRows, sessionRow, 
+// 0.40.0: the workspace scope — pure, so `kiso sessions` and the picker
+// scope by one rule
+scopeSessions, scopeTitle, } from "./session-picker.js";
 // KC3.5 (the ask round): the ask view — the panel machinery generalized.
 // The cli composes the view and hands the answers to the tool; the keys,
 // the rows and the walk are the terminal layer's.
@@ -46,4 +49,4 @@ export { resolveGround } from "@vincemakes/kiso-tui-cells";
 // one duration form: the CLI's own surfaces label a settled duration the
 // way a settled card does, rather than writing a second one.
 export { settledLabel } from "@vincemakes/kiso-tui-cells";
-export { KEY_BINDINGS, PANEL_KEYS_ROW, displayVerb, extensionsBannerText, helpRows, keysHelpRow, keysSheetRows, slashCommandNames, unansweredAskView } from "./strings.js";
+export { KEY_BINDINGS, PANEL_KEYS_ROW, coldResumeLine, coldResumeView, displayVerb, extensionsBannerText, helpRows, keysHelpRow, keysSheetRows, slashCommandNames, unansweredAskView } from "./strings.js";

package/dist/lines.d.ts

@@ -169,6 +169,11 @@ export interface RecapStats {
      *  passed only when above the noise floor — the re-sent-uncached
      *  prefix. Absent → the recap bytes stay the historical form. */
     readonly missed?: number;
+    /** 0.40.0 (the owner): the turn's first request came this many minutes
+     *  after the session's last bill, and the prompt cache had gone cold —
+     *  the recap says so instead of a bare `fresh 730k · cache 0%`, which
+     *  is true and reads like a fault. Absent → the historical form. */
+    readonly coldAfterMinutes?: number;
     readonly ctxLeftPct: number | null;
     /** R3g — the terminal's width. The recap is the ONE row on the screen
      *  that was never measured: it is written raw, so a line longer than

package/dist/lines.js

@@ -96,8 +96,8 @@ export function renderEvent(ev, prevThinking = false, resolvePath = (p) => p) {
         case "compacted":
             return { text: `${p.dim}  [compacted ${ev.cleared.length} results]${p.reset}\n`, newline: true, prompt: false };
         case "summarized":
-            // ADR-0044: the /compact event is OFF-LOOP — it never appears in
-            // a run stream; rendered for the switch's completeness only.
+            // ADR-0044: /compact's event is off-loop; since ADR-0055 Amendment 1
+            // the in-run tiers also append one mid-run, and this is its line.
             return { text: `${p.dim}  [summarized up to seq ${ev.coversToSeq}]${p.reset}\n`, newline: true, prompt: false };
         case "uncertain_pending":
             return {
@@ -211,7 +211,16 @@ export function renderRecap(s) {
             ? [`${s.tools} tool${s.tools === 1 ? "" : "s"}${edits > 0 ? ` (${edits} edit${edits === 1 ? "" : "s"})` : ""}`]
             : [];
     const parts = [`took ${elapsedLabel(s.seconds)}`, ...work];
-    if (s.usage.known) {
+    // The cold turn: the gap and the re-read are the FACTS and come first,
+    // so a cut from the end never reaches them; "cache cold after" is the
+    // label, and it is the first thing shortened when the row is narrow.
+    const cold = s.coldAfterMinutes !== undefined && s.usage.known && s.usage.in !== null;
+    if (cold) {
+        parts.push(`cache cold after ${s.coldAfterMinutes} min`, `re-read ${kUnit(s.missed ?? s.usage.in ?? 0)}`);
+        if (s.usage.out !== null)
+            parts.push(`out ${kUnit(s.usage.out)}`);
+    }
+    else if (s.usage.known) {
         const seg = `${s.usage.in !== null ? `fresh ${kUnit(s.usage.in)}` : ""}${s.usage.in !== null && s.usage.out !== null ? " " : ""}${s.usage.out !== null ? `out ${kUnit(s.usage.out)}` : ""}`;
         if (seg !== "")
             parts.push(seg);
@@ -230,7 +239,13 @@ export function renderRecap(s) {
     // R3g: ONE physical row, at any width — the same rule every other row
     // in the product obeys. The cut is the honest "…": the recap said
     // more than fits, and says so.
-    const line = parts.join(" · ");
+    let line = parts.join(" · ");
+    // A cold turn that does not fit sheds its LABEL first, then the cut
+    // below takes the tail — the gap and the re-read stand in front of it.
+    if (cold && s.width !== undefined && s.width >= 20 && visibleWidth(`✦ ${line}`) > s.width) {
+        parts[parts.indexOf(`cache cold after ${s.coldAfterMinutes} min`)] = `cold ${s.coldAfterMinutes} min`;
+        line = parts.join(" · ");
+    }
     // R3g: the floor is the renderer's own guard against a caller that
     // hands it a degenerate width (a PTY with no winsize reports 0). A
     // recap cut to one character is worse than one that wraps.

package/dist/pick-input.d.ts

@@ -9,13 +9,17 @@ export declare class PickInput {
      *  (the buffer becomes the filter query) and `onPick` receives the
      *  chosen id — or null when the human leaves without picking, which
      *  is a first-class outcome and not an error. */
-    begin(cards: () => readonly SessionCardView[], onPick: (id: string | null) => void): void;
+    begin(cards: () => readonly SessionCardView[], onPick: (id: string | null) => void, here?: string): void;
     /** The picker's state, derived: the full card list (the id column
      *  measures over ALL of them, so the columns never jump), the
      *  filtered matches, and the selection CLAMPED at read time — the
      *  same correction discipline the @ picker uses, for the same
      *  reason: narrowing can only ever shrink the list. */
     state(): SessionPickState | null;
+    /** 0.40.0 — tab flips CURRENT ↔ ALL. The filter owns every printable
+     *  key (the buffer IS the query), so the toggle cannot be one. True when
+     *  the picker owned the key. */
+    toggleScope(): boolean;
     /** The band's height estimate: the header + the windowed rows (or
      *  the one "no match" row) + the counter. */
     rows(): number;