@vincemakes/kiso-tui 0.9.0 → 0.10.0

package/dist/editor.js

@@ -26,10 +26,15 @@ import { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 // authority) — re-exported so the editor's public surface is unchanged.
 export { charWidth, displayWidth, widthOf };
 import { palette } from "./render.js";
+import { PICK_MAX } from "./approval-panel.js";
 // KC3.5: the panel-slot dispatchers — the ask branch folded into the
 // W21 lead/rows, so this file keeps ONE panel and one key owner.
 import { askCommitCustom, askKey, askStart, panelLead } from "./ask-panel.js";
 import { AT_VISIBLE, atFilter } from "./at-picker.js";
+// TUI2-R2 ②: the session picker — the band's THIRD occupant. Its filter
+// is the @ picker's rank aimed at the session id; the editor owns the
+// keys, the compositor draws the rows.
+import { sessionFilter } from "./session-picker.js";
 // TUI v4 #16d: the input row is the blue brick + the edit area — the
 // "you>" text is gone (the brick IS the prompt; the pipe path's readline
 // prompt keeps its own "you> " — v2a line mode, byte-for-byte).
@@ -135,6 +140,20 @@ export class Editor {
     // next open re-snapshots, so a stale list can never be shown.
     #atList = null;
     #atItems = null;
+    // TUI2-R2 ② — the session picker. Two fields: the bound source (its
+    // presence IS "the picker is up") and the selection. The query, like
+    // the @ picker's, is DERIVED from the buffer on every read rather
+    // than stored — so every existing buffer op (backspace, the kills,
+    // paste) filters correctly with no handler of its own.
+    //
+    // The picker is MODAL in a way the @ picker is not: it opens before
+    // a session exists, owns the whole composer, and the only ways out
+    // are a pick and an esc. That is why the commit callback lives here
+    // rather than on the line channel — the caller is waiting for an id,
+    // not for a turn.
+    #pickCards = null;
+    #pickCommit = null;
+    #pickSel = 0;
     // A2 (the feel): the session-scoped input history — every submitted TURN
     // line (never a question answer), capped at 100, never persisted. ↑↓
     // navigate it ONLY from an empty input or while already browsing.
@@ -254,7 +273,7 @@ export class Editor {
      *  the frame's clamp is the authority. */
     #visibleRows(lineCount) {
         const H = process.stdout.rows ?? 24;
-        const bands = (this.#menuOpen ? this.#menuFiltered().length : 0) + this.#atRows() + this.#queueState().length;
+        const bands = (this.#menuOpen ? this.#menuFiltered().length : 0) + this.#atRows() + this.#pickRows() + this.#queueState().length;
         return Math.max(1, Math.min(lineCount, N_MAX, Math.max(1, H - 3 - bands)));
     }
     /** The dock's input-row state — ADDITIVE (§5): `line` + `cursor` keep
@@ -392,6 +411,11 @@ export class Editor {
     #atArm() {
         if (this.#atItems === null)
             return;
+        // TUI2-R2 ②: not inside a session filter. An `@` typed into the
+        // picker's query is a character in a session id, and a file picker
+        // opening over a session picker would put two bands in one slot.
+        if (this.#pickUp())
+            return;
         if (this.#panel !== null || this.#menuOpen || this.#questionCb !== null)
             return;
         if (this.#atToken() === null)
@@ -437,6 +461,71 @@ export class Editor {
         const view = this.#atView();
         return view === null ? 0 : Math.min(view.matches.length, AT_VISIBLE) + 1;
     }
+    // ── TUI2-R2 ② — the session picker ───────────────────────────────
+    /** Open the picker on a bound card source. The composer is cleared
+     *  (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. */
+    beginPick(cards, onPick) {
+        this.#pickCards = cards;
+        this.#pickCommit = onPick;
+        this.#pickSel = 0;
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#reflow();
+        this.#onRender();
+    }
+    /** 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. */
+    #pickView() {
+        if (this.#pickCards === null)
+            return null;
+        const cards = this.#pickCards();
+        const matches = sessionFilter(cards, this.line());
+        return { cards, matches, selected: Math.max(0, Math.min(this.#pickSel, matches.length - 1)) };
+    }
+    pickState() {
+        return this.#pickView();
+    }
+    #pickUp() {
+        return this.#pickCards !== null;
+    }
+    /** The band's height estimate: the header + the windowed rows (or
+     *  the one "no match" row) + the counter. */
+    #pickRows() {
+        const view = this.#pickView();
+        return view === null ? 0 : Math.min(Math.max(view.matches.length, 1), AT_VISIBLE) + 2;
+    }
+    /** Close and hand the verdict back. The callback fires AFTER the
+     *  state is cleared, so a caller that re-enters (a second picker, a
+     *  session that starts) never sees the closing picker's rows. */
+    #pickClose(id) {
+        const cb = this.#pickCommit;
+        this.#pickCards = null;
+        this.#pickCommit = null;
+        this.#pickSel = 0;
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#reflow();
+        cb?.(id);
+        this.#onRender();
+    }
+    /** Enter takes the SELECTED session. An empty match set takes
+     *  nothing and leaves the picker up: a picker that invented a pick
+     *  when the query matched nothing would resume the wrong session,
+     *  which is the one failure this surface must never have. */
+    #pickAccept() {
+        const view = this.#pickView();
+        if (view === null)
+            return;
+        const card = view.matches[view.selected];
+        if (card === undefined)
+            return;
+        this.#pickClose(card.id);
+    }
     /** One-shot question mode: the NEXT submit answers, not a turn. */
     question(_query, cb) {
         this.#questionCb = cb;
@@ -455,6 +544,9 @@ export class Editor {
             phase: "options",
             sel: 0,
             ask: view.ask === undefined ? null : askStart(view.ask),
+            // TUI2-R2 ④: the pick's walk — present exactly when the view is
+            // a pick, the same contract the ask's runtime has.
+            pick: view.pick === undefined ? null : { cursor: 0, phase: "options" },
             amend: "yes",
             onCommit,
             stash: { chars: this.#chars, cursor: this.#cursor, scroll: this.#scroll },
@@ -479,7 +571,13 @@ export class Editor {
         const panel = this.#panel;
         if (panel === null)
             return null;
-        return { view: panel.view, phase: panel.phase, sel: panel.sel, ...(panel.ask === null ? {} : { ask: panel.ask }) };
+        return {
+            view: panel.view,
+            phase: panel.phase,
+            sel: panel.sel,
+            ...(panel.ask === null ? {} : { ask: panel.ask }),
+            ...(panel.pick === null ? {} : { pick: panel.pick }),
+        };
     }
     enter() {
         if (this.#entered)
@@ -554,6 +652,44 @@ export class Editor {
                 // only esc and enter are intercepted while typing), esc
                 // declines the whole call. Everything else falls through to
                 // the ordinary editing chain below.
+                // TUI2-R2 ④: a PICK panel routes its own keys — a digit moves
+                // the cursor to that option (never commits: the choice is
+                // CONFIRMED, so a mistyped digit is a mistake you can see
+                // before it takes effect), `t` opens the type-it line, enter
+                // commits, esc backs out then cancels. The swallow rule below
+                // is the ask's, for the ask's reason: a typed `/` must not arm
+                // the menu under a panel that owns the keys.
+                if (panel.pick !== null) {
+                    const typing = panel.pick.phase === "custom";
+                    if (c === "\x1b" && !text.slice(i + 1).startsWith("[") && !text.slice(i + 1).startsWith("O")) {
+                        this.#pickPanelEsc();
+                        i += 1;
+                        continue;
+                    }
+                    if (c === "\x0d" || c === "\x0a") {
+                        this.#pickPanelEnter();
+                        i += 1;
+                        continue;
+                    }
+                    if (!typing && c !== undefined && c >= "1" && c <= "9") {
+                        this.#pickPanelDigit(Number(c) - 1);
+                        i += 1;
+                        continue;
+                    }
+                    if (!typing && (c === "t" || c === "T")) {
+                        panel.pick = { cursor: panel.pick.cursor, phase: "custom" };
+                        this.#chars = [];
+                        this.#cursor = 0;
+                        this.#scroll = 0;
+                        this.#onRender();
+                        i += 1;
+                        continue;
+                    }
+                    if (!typing && c !== undefined && c >= " " && c !== "\x7f") {
+                        i += 1;
+                        continue;
+                    }
+                }
                 if (panel.ask !== null) {
                     const typing = panel.ask.phase === "custom";
                     if (c === "\x1b" && !text.slice(i + 1).startsWith("[") && !text.slice(i + 1).startsWith("O")) {
@@ -602,22 +738,49 @@ export class Editor {
                     i += 1;
                     continue;
                 }
-                if (c === "1" || c === "y" || c === "Y") {
-                    if (panel.phase === "options")
+                // TUI2-R2 ⑧ — the shortcut keys belong to the OPTIONS phase and
+                // to it alone.
+                //
+                // `1`/`y` select yes and `3`/`n` select no, and they used to be
+                // applied in every phase of every flavour: the `i += 1;
+                // continue;` sat OUTSIDE the phase check, so a phase where the
+                // key meant nothing swallowed it anyway. A phase where a letter
+                // means nothing is exactly a phase where a human is typing
+                // prose — so every y, n, 1 and 3 vanished from the line,
+                // silently, with no error and no visible cause. "yes, run it
+                // now 13" committed as "es, ru it ow ".
+                //
+                // Three typed phases were affected: the ask's custom answer,
+                // the approval panel's rule input, and its amend/feedback line.
+                // The rule input is the one that mattered most — it writes a
+                // DURABLE don't-ask-again rule, so a dropped character persists
+                // a rule the human never typed.
+                //
+                // Slice ④ met the same mechanism on the new pick panel
+                // ("openai/deepseek-reasoner" -> "opeai/deepseek-reasoer") and
+                // guarded pick alone, because the rest was a behaviour change
+                // owed its own red. This is that guard, stated once for every
+                // flavour: the options phase keeps its keys, and every typed
+                // phase keeps its text.
+                const optionsPhase = panel.pick === null && // a pick has no yes and no no
+                    panel.phase === "options" && // the rule / amend lines are prose
+                    (panel.ask === null || panel.ask.phase === "options"); // and so is a typed ask answer
+                if (optionsPhase) {
+                    if (c === "1" || c === "y" || c === "Y") {
                         this.#panelSelect(1);
-                    i += 1;
-                    continue;
-                }
-                if (c === "2" && panel.phase === "options" && panel.view.flavor === "approval") {
-                    this.#panelRule();
-                    i += 1;
-                    continue;
-                }
-                if (c === "3" || c === "n" || c === "N") {
-                    if (panel.phase === "options")
+                        i += 1;
+                        continue;
+                    }
+                    if (c === "2" && panel.view.flavor === "approval") {
+                        this.#panelRule();
+                        i += 1;
+                        continue;
+                    }
+                    if (c === "3" || c === "n" || c === "N") {
                         this.#panelSelect(3);
-                    i += 1;
-                    continue;
+                        i += 1;
+                        continue;
+                    }
                 }
             }
             if (c === "\x1b") {
@@ -656,6 +819,15 @@ export class Editor {
                     this.#refreshMenu();
                     i += 1;
                 }
+                else if (this.#pickUp()) {
+                    // TUI2-R2 ②: esc leaves the picker with nothing picked.
+                    // The caller reads null and exits 0 — declining to resume
+                    // is a normal thing to do, not a failure, so it must not
+                    // fall through to the escapeCbs (which mean "abort the
+                    // run" and there is no run yet).
+                    this.#pickClose(null);
+                    i += 1;
+                }
                 else if (this.#atUp()) {
                     // KC3 §3: esc closes the picker and leaves the BUFFER
                     // ALONE — unlike the menu's esc, which clears it. The
@@ -839,9 +1011,25 @@ export class Editor {
             if (this.#panel !== null) {
                 // W21: the panel owns the keys. KC3.5: an ask uses ↑↓ for
                 // the option cursor (the approval panel still has no ↑↓ role).
-                if (this.#panel.ask !== null && this.#panel.ask.phase === "options")
+                if (this.#panel.pick !== null && this.#panel.pick.phase === "options") {
+                    // TUI2-R2 ④: ↑↓ walk the pick's cursor — the same list the
+                    // digits address, the other muscle.
+                    const n = Math.min(this.#panel.view.pick.options.length, PICK_MAX);
+                    const cur = this.#panel.pick.cursor;
+                    this.#panel.pick = { cursor: final === "A" ? Math.max(0, cur - 1) : Math.min(Math.max(0, n - 1), cur + 1), phase: "options" };
+                }
+                else if (this.#panel.ask !== null && this.#panel.ask.phase === "options")
                     this.#askStep(final === "A" ? "up" : "down");
             }
+            else if (this.#pickUp()) {
+                // TUI2-R2 ②: the session picker owns ↑↓ while up — the
+                // SELECTION, never the composer's line walk and never the
+                // history browse. It sits above both because the picker is
+                // modal: there is no turn to recall and no second line to
+                // walk to while it is open.
+                const view = this.#pickView();
+                this.#pickSel = final === "A" ? Math.max(0, view.selected - 1) : Math.min(Math.max(0, view.matches.length - 1), view.selected + 1);
+            }
             else if (this.#menuOpen) {
                 if (final === "A")
                     this.#menuSel = Math.max(0, this.#menuSel - 1);
@@ -1025,6 +1213,60 @@ export class Editor {
         }
         this.#onRender();
     }
+    /**
+     * TUI2-R2 ④ — the pick panel's three keys.
+     *
+     * A digit MOVES the cursor rather than committing. The list is short
+     * and the digits are adjacent on the keyboard; a picker that acted on
+     * the keypress would make a mistyped 3 a model switch, and the whole
+     * point of a confirm step is that the choice is visible before it is
+     * taken.
+     */
+    #pickPanelDigit(index) {
+        const panel = this.#panel;
+        if (panel === null || panel.pick === null)
+            return;
+        // a digit past the list is INERT — an option nobody has is never
+        // selected, and the cursor stays where the human left it
+        if (index < 0 || index >= Math.min(panel.view.pick.options.length, PICK_MAX))
+            return;
+        panel.pick = { cursor: index, phase: "options" };
+        this.#onRender();
+    }
+    /** enter — the typed line when there is one (an EMPTY line is not a
+     *  choice and commits nothing), else the option under the cursor. */
+    #pickPanelEnter() {
+        const panel = this.#panel;
+        if (panel === null || panel.pick === null)
+            return;
+        if (panel.pick.phase === "custom") {
+            const line = this.line().trim();
+            if (line === "")
+                return;
+            this.#panelClose({ action: "picked", result: { custom: line } });
+            return;
+        }
+        if (panel.view.pick.options.length === 0)
+            return; // nothing to take
+        this.#panelClose({ action: "picked", result: { index: panel.pick.cursor } });
+    }
+    /** esc — back out of the type-it line first, then cancel the panel.
+     *  Two escapes, two meanings, exactly as the approval panel's
+     *  rule/amend phases already work. */
+    #pickPanelEsc() {
+        const panel = this.#panel;
+        if (panel === null || panel.pick === null)
+            return;
+        if (panel.pick.phase === "custom") {
+            panel.pick = { cursor: panel.pick.cursor, phase: "options" };
+            this.#chars = [];
+            this.#cursor = 0;
+            this.#scroll = 0;
+            this.#onRender();
+            return;
+        }
+        this.#panelClose({ action: "cancel" });
+    }
     #panelClose(verdict) {
         const panel = this.#panel;
         if (panel === null)
@@ -1148,6 +1390,7 @@ export class Editor {
         return (this.#panel === null &&
             !this.#menuOpen &&
             !this.#atUp() && // KC3 §3: the @ picker owns the keys while up, exactly like the menu
+            !this.#pickUp() && // TUI2-R2 ②: and so does the session picker — `?` is a query character there
             this.#historyIdx === null &&
             !this.#queuePopMode &&
             !this.#pasting &&
@@ -1180,6 +1423,12 @@ export class Editor {
         this.#onRender();
     }
     #submit() {
+        // TUI2-R2 ②: the session picker takes Enter before anything else —
+        // while it is up there is no turn to submit and no line to send.
+        if (this.#pickUp()) {
+            this.#pickAccept();
+            return;
+        }
         // KC3 §3: Enter ACCEPTS while the picker is up — the same rule the
         // menu's A1 feel established (complete first, let the user read
         // what they got, and let the NEXT Enter send it). An @ reference

package/dist/index.d.ts

@@ -6,7 +6,7 @@
  * editor, the diff renderer, and the palette.
  */
 export { Body, Dock, CURSOR_MARKER, type BodyOptions } from "./compositor.js";
-export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, type PanelArgs, type PanelFlavor, type PanelPhase, type PanelSel, type PanelState, type PanelVerdict, type PanelView, } from "./approval-panel.js";
+export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, PICK_MAX, modelPickView, pickAffordance, pickBlockRows, pickLeadPlain, type PickOption, type PickResult, type PickRuntime, type PickSpec, type PanelArgs, type PanelFlavor, type PanelPhase, type PanelSel, type PanelState, type PanelVerdict, type PanelView, } from "./approval-panel.js";
 export { Container, foldLine, foldWords, visibleWidth, SPINNER, type Component, type FrameCtx } from "./components.js";
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, type MenuItem, } from "./editor.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, 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 "./render.js";
@@ -14,6 +14,7 @@ export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResu
 export { STATUS_GLYPHS, cacheHitPct, idleStatus, runningStatus, type StatusMeter } from "./status.js";
 export { contextRows, contextUnavailableRows, type ContextLedger } from "./context-ledger.js";
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, type TrustArtifact } from "./strings.js";
-export { AT_CAP, AT_SKIP, AT_VISIBLE, atEmbed, atFilter, atPanelRows, atWindow, longestRun, type AtItem, type AtMatch } from "./at-picker.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 { 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 { KEY_BINDINGS, PANEL_KEYS_ROW, extensionsBannerText, helpRows, keysHelpRow, keysSheetRows, unansweredAskView, type BannerExtension, type KeyBinding } from "./strings.js";
+export { KEY_BINDINGS, PANEL_KEYS_ROW, displayVerb, extensionsBannerText, helpRows, keysHelpRow, keysSheetRows, unansweredAskView, type BannerExtension, type KeyBinding } from "./strings.js";

package/dist/index.js

@@ -9,7 +9,9 @@ export { Body, Dock, CURSOR_MARKER } from "./compositor.js";
 // W21 (the v8 approval round): the approval panel — the bounded block
 // that replaces the running tool's live window while a human-chain
 // approval is pending (the shape authority is the committed preview).
-export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, } from "./approval-panel.js";
+export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, 
+// TUI2-R2 ④: the pick payload — the panel slot's third occupant.
+PICK_MAX, modelPickView, pickAffordance, pickBlockRows, pickLeadPlain, } from "./approval-panel.js";
 export { Container, foldLine, foldWords, visibleWidth, SPINNER } from "./components.js";
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, } from "./editor.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";
@@ -26,7 +28,11 @@ export { contextRows, contextUnavailableRows } from "./context-ledger.js";
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView } from "./strings.js";
 // KC3 §3/§5: the @ file picker's pure half — the subsequence filter, the
 // deterministic rank, and the ONE cap the CLI's file source shares.
-export { AT_CAP, AT_SKIP, AT_VISIBLE, atEmbed, atFilter, atPanelRows, atWindow, longestRun } from "./at-picker.js";
+export { AT_CAP, AT_SKIP, AT_VISIBLE, atEmbed, atFilter, atPanelRows, atWindow, bandHeader, longestRun } from "./at-picker.js";
+// 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";
 // 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.
@@ -35,4 +41,4 @@ export { ASK_HEADER_CAP, ASK_MAX_OPTIONS, ASK_MAX_QUESTIONS, ASK_MIN_OPTIONS, as
 // honestly for a question nobody answered (the ① probe's surface).
 // TUI2-R1 (D): the keys sheet + THE key table — one source for the ?
 // overlay and /help's keys row.
-export { KEY_BINDINGS, PANEL_KEYS_ROW, extensionsBannerText, helpRows, keysHelpRow, keysSheetRows, unansweredAskView } from "./strings.js";
+export { KEY_BINDINGS, PANEL_KEYS_ROW, displayVerb, extensionsBannerText, helpRows, keysHelpRow, keysSheetRows, unansweredAskView } from "./strings.js";

package/dist/session-picker.d.ts

@@ -0,0 +1,113 @@
+/**
+ * TUI2-R2 slices ①–③ — the session picker's PURE half: the durability
+ * badge, the row, the band, and the filter.
+ *
+ * The badge is the round's whole argument. kiso's claim is that a
+ * session survives kill -9 and resumes from its durable prefix; until
+ * now that claim was a sentence in a README. A badge per row makes it a
+ * thing you can SEE before you pick: this one completed, this one was
+ * cut mid-run and will resume exactly, this one is holding a question
+ * for you.
+ *
+ * The vocabulary (the palette's functional set — no new colour):
+ *
+ *   ✓ green   the run's terminal event says completed
+ *   ✗ red     the terminal says anything else
+ *   ▌ bold    no terminal event — interrupted mid-run
+ *   ? warn    the uncertain ledger is not empty (overrides ▌)
+ *   ◌ dim     a permission request nobody has answered
+ *
+ * Purity, as everywhere in this package: the cards are DATA the CLI
+ * projects (session-cards.ts) and this module turns them into bytes. It
+ * never reads a session, never asks the runtime anything, and holds no
+ * state — which is what lets the picker band and the `kiso sessions`
+ * listing render from ONE definition instead of two that drift.
+ */
+/** The projected card — structurally what apps/cli/src/session-cards.ts
+ *  produces. Declared here as the tui's INPUT contract (the package
+ *  imports nothing from the runtime, by rule). */
+export interface SessionCardView {
+    readonly id: string;
+    readonly badge: "uncertain" | "ask" | "interrupted" | "completed" | "failed";
+    readonly turns: number;
+    readonly updatedAt: number;
+    readonly uncertain: number;
+    readonly asks: number;
+    readonly outcome: string | null;
+}
+/** The glyph per state — one cell each, so the badge column never
+ *  shifts the id column (a column that moves per row reads as damage). */
+export declare const BADGE_GLYPH: Readonly<Record<SessionCardView["badge"], string>>;
+/** The badge, styled. The colour IS the meaning here (the mono
+ *  discipline's three functional exceptions), so NO_COLOR degrades to
+ *  the glyph alone — which is why the glyphs are distinct shapes and
+ *  not three coloured dots. */
+export declare function sessionBadge(badge: SessionCardView["badge"]): string;
+/**
+ * What the row SAYS about the state. The interrupted note is the
+ * product's promise stated in the place the promise matters: the run
+ * continues from its durable prefix, so picking this row costs nothing
+ * that was already paid for.
+ *
+ * The ✗ note names the OUTCOME rather than flattening six endings into
+ * one word — "aborted" and "max turns" are different things to have
+ * happened, and a picker that calls both "failed" teaches the user
+ * nothing.
+ */
+export declare function sessionNote(card: SessionCardView): string;
+/** The compact age — the picker's column, not the banner's sentence.
+ *  `relativeTime` says "3d ago"; a column of ages does not need the
+ *  word repeated on every row. */
+export declare function sessionAge(updatedAt: number, now: number): string;
+/** The id column's width — computed over EVERY card, never over the
+ *  filtered subset, so the columns do not jump while the user types
+ *  (the whole reason a filter-as-you-type picker is usable). */
+export declare function idColumn(cards: readonly SessionCardView[]): number;
+/**
+ * The filter — the @ picker's muscle, aimed at the session id: a
+ * case-insensitive SUBSEQUENCE, ranked by the longest contiguous run,
+ * then by id length, then lexically. Identical determinism, identical
+ * feel; a row under the cursor never moves because two ids tied.
+ *
+ * An empty query matches everything and keeps the caller's order (the
+ * listing's newest-first), because "no query" is not a search — it is
+ * the list.
+ */
+export declare function sessionFilter(cards: readonly SessionCardView[], query: string): SessionCardView[];
+/**
+ * ONE picker row. The selection is a FULL-ROW reverse bar — the R1.5
+ * ⑧ ruling's shape, shared with the @ picker and the user chip: a
+ * two-cell marker in an eighty-column row is a selection you have to
+ * hunt for.
+ *
+ * The inner spans close with rvEnd inside the bar (never SGR 0, which
+ * would punch a hole in it) — the same composition atRow uses.
+ */
+export declare function sessionRow(card: SessionCardView, selected: boolean, W: number, now: number, idCol: number): string;
+/** The counter row — the SELECTION's 1-based place in the whole
+ *  filtered list, which the visible window cannot tell the user. */
+export declare function sessionCounterRow(selected: number, total: number, W: number): string;
+/** The picker's bound state — the editor owns it, the compositor reads
+ *  it (the @ picker's contract, one surface over). */
+export interface SessionPickState {
+    readonly cards: readonly SessionCardView[];
+    readonly matches: readonly SessionCardView[];
+    readonly selected: number;
+}
+/**
+ * The whole band: the `sessions` header (R1.5 ⑦(b) — a band names
+ * itself or it reads as more scrollback), at most AT_VISIBLE windowed
+ * rows, then the counter. Returned as plain strings for the menu-rows
+ * channel, which already accounts them in chromeRows — the picker needs
+ * no geometry of its own, which is the entire reason it rides that
+ * channel.
+ */
+export declare function sessionPickerRows(state: SessionPickState, W: number, now: number): string[];
+/** Slice ③ — the `kiso sessions` TTY row: the SAME projection, printed
+ *  rather than picked. No selection bar (nothing is selected on a
+ *  listing) and no leading indent: this row starts at column 1 like
+ *  every other line a shell command prints. */
+export declare function sessionListRow(card: SessionCardView, W: number, now: number, idCol: number): string;
+/** Slice ③ — the listing's last line: the count, and the one thing the
+ *  user can do next. */
+export declare function sessionListFooter(count: number, W: number): string;