@vincemakes/kiso-tui 0.46.1 → 0.47.0

package/dist/panel-input.js

@@ -6,8 +6,8 @@
  * one band, in an order the editor keeps in one place: the panel first,
  * then the session picker, then the composer's own bands. What the
  * panel may do to the composer is the `BandHost` surface and nothing
- * else: it types its amend reason, its custom ask answer and its custom
- * pick into the composer, stashes the composer at open, restores it at
+ * else: it types its amend reason, its custom ask answer and a pick's
+ * filter into the composer, stashes the composer at open, restores it at
  * close — that is the whole coupling, and it is visible here.
  *
  * DECLARED MOVE (S5, 2026-09-06): every method below stood in editor.ts
@@ -16,7 +16,7 @@
  * and the mouse hit. The bodies are the same; only the buffer access
  * goes through the host.
  */
-import { PICK_MAX, panelOptions, pickWindow, saferDegradedNote, startLevel, stepLevel, } from "./approval-panel.js";
+import { panelOptions, pickList, pickWindowOf, saferDegradedNote, startLevel, stepLevel, } from "./approval-panel.js";
 import { askCommitCustom, askKey, askOnCustomRow, askStart } from "./ask-panel.js";
 export class PanelInput {
     host;
@@ -52,7 +52,7 @@ export class PanelInput {
             safer: opts?.safer,
             saferRun: null,
             ask: view.ask === undefined ? null : askStart(view.ask),
-            pick: view.pick === undefined ? null : { cursor: start, phase: "options", level: startLevel(view.pick.options[start]) },
+            pick: view.pick === undefined ? null : { cursor: start, level: startLevel(view.pick.options[start]) },
             onCommit,
             stash: this.host.stash(),
         };
@@ -78,9 +78,20 @@ export class PanelInput {
             ...(panel.note === null ? {} : { note: panel.note }),
             ...(panel.saferRun === null ? {} : { safer: panel.saferRun }),
             ...(panel.ask === null ? {} : { ask: panel.ask }),
-            ...(panel.pick === null ? {} : { pick: panel.pick }),
+            ...(panel.pick === null ? {} : { pick: this.#pickNow(panel.view, panel.pick) }),
         };
     }
+    /** The pick's runtime as the renderer and the keys read it (Graphite
+     *  P3): a filter's query is the composer's text, read now, and the
+     *  cursor and level are the CORRECTED ones — a row the filter took away
+     *  is never reported as the selection. */
+    #pickNow(view, pick) {
+        const now = view.pick?.input === "filter" ? { ...pick, query: this.host.line() } : pick;
+        if (view.pick === undefined)
+            return now;
+        const list = pickList(view.pick, now);
+        return { ...now, cursor: list.cursor, level: list.level };
+    }
     /**
      * A parsed key while the panel is up. Returns the bytes it consumed,
      * or null when the key falls through to the composer — the amend
@@ -97,14 +108,16 @@ export class PanelInput {
             return null;
         const enterBytes = key.kind === "enter" && key.crlf ? 2 : 1;
         if (panel.pick !== null) {
-            const typing = panel.pick.phase === "custom";
+            const filter = panel.view.pick?.input === "filter";
             if (key.kind === "esc") {
-                this.#pickPanelEsc();
+                this.#close({ action: "cancel" });
                 return 1;
             }
             if (key.kind === "enter") {
                 if (pasting) {
-                    this.host.newline();
+                    // a pasted line break is not a pick, and a filter is one line
+                    if (!filter)
+                        this.host.newline();
                     return enterBytes;
                 }
                 this.#pickPanelEnter();
@@ -112,20 +125,27 @@ export class PanelInput {
             }
             if (key.kind === "char") {
                 const c = key.ch;
-                if (!typing && c >= "1" && c <= "9") {
-                    this.#pickPanelDigit(Number(c) - 1);
-                    return 1;
+                // Graphite P3: a filter takes every printable key — a digit or an
+                // `h` is a letter of a model name there. Backspace and the
+                // composer's other editing keys fall through to the composer,
+                // and the list re-derives from its text on the next read.
+                if (filter) {
+                    if (c >= " " && c !== "\x7f") {
+                        this.host.insert(c.codePointAt(0));
+                        this.host.render();
+                        return 1;
+                    }
                 }
-                if (!typing && (c === "h" || c === "l") && this.#levelStep(c === "h" ? -1 : 1))
-                    return 1;
-                if (!typing && (c === "t" || c === "T") && panel.view.pick?.typeHint !== undefined) {
-                    panel.pick = { cursor: panel.pick.cursor, phase: "custom", level: panel.pick.level };
-                    this.host.clear();
-                    this.host.render();
-                    return 1;
+                else {
+                    if ((panel.view.pick?.input ?? "digits") === "digits" && c >= "1" && c <= "9") {
+                        this.#pickPanelDigit(Number(c) - 1);
+                        return 1;
+                    }
+                    if ((c === "h" || c === "l") && this.#levelStep(c === "h" ? -1 : 1))
+                        return 1;
+                    if (c >= " " && c !== "\x7f")
+                        return 1;
                 }
-                if (!typing && c >= " " && c !== "\x7f")
-                    return 1;
             }
         }
         if (panel.ask !== null) {
@@ -208,19 +228,20 @@ export class PanelInput {
         const panel = this.#panel;
         if (panel === null)
             return false;
-        if (panel.pick !== null && panel.pick.phase === "options") {
+        if (panel.pick !== null) {
             // DC-58: EVERY option is reachable by ↑↓ — the window follows the
-            // cursor (`pickWindow`) and PICK_MAX is only how many rows one
-            // screen holds. This bound used to be `min(count, PICK_MAX)`, which
-            // is what left a 60-profile config with nine reachable rows.
-            const n = panel.view.pick.options.length;
-            const cur = panel.pick.cursor;
-            const next = dir === "up" ? Math.max(0, cur - 1) : Math.min(Math.max(0, n - 1), cur + 1);
+            // cursor. P3: the walk is over what the list SHOWS (a filter's
+            // matches, then the direct row), so ↑↓ never lands on a row the
+            // person cannot see.
+            const list = pickList(panel.view.pick, this.#pickNow(panel.view, panel.pick));
+            const at = list.shown.indexOf(list.cursor);
+            const to = list.shown[dir === "up" ? Math.max(0, at - 1) : Math.min(list.shown.length - 1, at + 1)];
             // OR-7: the second axis belongs to the highlighted option, so it
             // re-lands on THAT option's own level. Carrying the previous
             // row's index across would point at a level this model may not
             // have — the silent clamp the coordination note exists to end.
-            panel.pick = { cursor: next, phase: "options", level: startLevel(panel.view.pick.options[next]) };
+            if (to !== undefined)
+                panel.pick = { cursor: to, level: startLevel(panel.view.pick.options[to]) };
         }
         else if (panel.ask !== null && panel.ask.phase === "options")
             this.#askStep(dir);
@@ -252,12 +273,13 @@ export class PanelInput {
      *  no axis to walk, which is what leaves the key to the composer. */
     #levelStep(dir) {
         const panel = this.#panel;
-        if (panel === null || panel.pick === null || panel.pick.phase !== "options")
+        if (panel === null || panel.pick === null)
             return false;
-        const o = panel.view.pick?.options[panel.pick.cursor];
-        if (o?.levels === undefined)
+        const list = pickList(panel.view.pick, this.#pickNow(panel.view, panel.pick));
+        const o = panel.view.pick.options[list.cursor];
+        if (o?.levels === undefined || o.levels.length === 0)
             return false;
-        panel.pick = { cursor: panel.pick.cursor, phase: "options", level: stepLevel(o, panel.pick.level, dir) };
+        panel.pick = { cursor: list.cursor, level: stepLevel(o, list.level, dir) };
         this.host.render();
         return true;
     }
@@ -455,47 +477,35 @@ export class PanelInput {
         const panel = this.#panel;
         if (panel === null || panel.pick === null)
             return;
-        const count = panel.view.pick.options.length;
         // DC-58: a digit names the row ON SCREEN. The window's origin is what
-        // turns a visible position into an option index — the same
-        // `pickWindow` the renderer drew the rows with, so what the row says
-        // and what the key does cannot drift apart.
-        const { first, size } = this.host.pickWindow?.() ?? pickWindow(panel.pick.cursor, count, PICK_MAX);
+        // turns a visible position into an option — the same window the
+        // renderer drew the rows with, so what the row says and what the key
+        // does cannot drift apart.
+        const now = this.#pickNow(panel.view, panel.pick);
+        const { first, size } = this.host.pickWindow?.() ?? pickWindowOf(panel.view, now, Number.MAX_SAFE_INTEGER, process.stdout.rows ?? 24);
         if (index < 0 || index >= size)
             return;
-        const target = first + index;
-        if (target >= count)
+        const target = pickList(panel.view.pick, now).shown[first + index];
+        if (target === undefined || target >= panel.view.pick.options.length)
             return;
-        panel.pick = { cursor: target, phase: "options", level: startLevel(panel.view.pick.options[target]) };
+        panel.pick = { cursor: target, level: startLevel(panel.view.pick.options[target]) };
         this.host.render();
     }
     #pickPanelEnter() {
         const panel = this.#panel;
         if (panel === null || panel.pick === null)
             return;
-        if (panel.pick.phase === "custom") {
-            const line = this.host.line().trim();
-            if (line === "")
-                return;
-            this.#close({ action: "picked", result: { custom: line } });
-            return;
-        }
-        if (panel.view.pick.options.length === 0)
+        const list = pickList(panel.view.pick, this.#pickNow(panel.view, panel.pick));
+        if (list.cursor < 0)
             return; // nothing to take
-        const level = panel.pick.level;
-        this.#close({ action: "picked", result: { index: panel.pick.cursor }, ...(level === null ? {} : { level }) });
-    }
-    #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", level: panel.pick.level };
-            this.host.clear();
-            this.host.render();
+        // P3: the direct row hands back what was typed — the old `t` row's result
+        if (list.cursor === panel.view.pick.options.length) {
+            if (list.direct !== null)
+                this.#close({ action: "picked", result: { custom: list.direct } });
             return;
         }
-        this.#close({ action: "cancel" });
+        const level = list.level;
+        this.#close({ action: "picked", result: { index: list.cursor }, ...(level === null ? {} : { level }) });
     }
     /** Close: the state is cleared FIRST, the stashed composer comes
      *  back, the Enter that closed the panel is swallowed, and only then

package/dist/pick-input.d.ts

@@ -1,3 +1,22 @@
+/**
+ * The SESSION PICKER's input controller — S5 (finding C10). TUI2-R2 ②:
+ * the band's third occupant. Its filter is the @ picker's rank aimed at
+ * the session id; this controller owns the keys, the compositor draws
+ * the rows.
+ *
+ * The picker is MODAL in a way the @ picker is not: it opens before a
+ * session exists, owns the whole composer (the buffer IS the filter
+ * query, derived on every read rather than stored, so every buffer op —
+ * backspace, the kills, paste — filters correctly with no handler of
+ * its own), 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.
+ *
+ * DECLARED MOVE (S5, 2026-09-06): `beginPick`, `#pickView`, `pickState`,
+ * `#pickUp`, `#pickRows`, `#pickClose`, `#pickAccept` and the ↑↓ branch
+ * stood in editor.ts; the bodies are the same, the buffer access goes
+ * through the host.
+ */
 import type { BandHost } from "./panel-input.js";
 import { type SessionCardView, type SessionPickState } from "./session-picker.js";
 export declare class PickInput {
@@ -20,9 +39,10 @@ export declare class PickInput {
      *  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;
+    /** The band's height estimate: the header, the windowed rows and the
+     *  selected row's opened second row (or the one "no match" row), and
+     *  the key row — sessionPickerRows' shape at this terminal height. */
+    rows(height: number): number;
     /** ↑↓: the selection walks the matches and stops at both ends. True
      *  when the picker owned the key (the caller renders). */
     arrow(dir: "up" | "down"): boolean;

package/dist/pick-input.js

@@ -1,24 +1,4 @@
-/**
- * The SESSION PICKER's input controller — S5 (finding C10). TUI2-R2 ②:
- * the band's third occupant. Its filter is the @ picker's rank aimed at
- * the session id; this controller owns the keys, the compositor draws
- * the rows.
- *
- * The picker is MODAL in a way the @ picker is not: it opens before a
- * session exists, owns the whole composer (the buffer IS the filter
- * query, derived on every read rather than stored, so every buffer op —
- * backspace, the kills, paste — filters correctly with no handler of
- * its own), 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.
- *
- * DECLARED MOVE (S5, 2026-09-06): `beginPick`, `#pickView`, `pickState`,
- * `#pickUp`, `#pickRows`, `#pickClose`, `#pickAccept` and the ↑↓ branch
- * stood in editor.ts; the bodies are the same, the buffer access goes
- * through the host.
- */
-import { AT_VISIBLE } from "./at-picker.js";
-import { scopeSessions, sessionFilter } from "./session-picker.js";
+import { resumeVisible, scopeSessions, sessionFilter } from "./session-picker.js";
 export class PickInput {
     host;
     #cards = null;
@@ -61,8 +41,9 @@ export class PickInput {
         // title says is showing, never reaches past it
         const scoped = this.#here === undefined ? null : scopeSessions(this.#cards(), this.#here, this.#all);
         const cards = scoped === null ? this.#cards() : scoped.cards;
-        const matches = sessionFilter(cards, this.host.line());
-        return { cards, matches, selected: Math.max(0, Math.min(this.#sel, matches.length - 1)), scope: scoped?.scope ?? null };
+        const query = this.host.line();
+        const matches = sessionFilter(cards, query);
+        return { cards, matches, selected: Math.max(0, Math.min(this.#sel, matches.length - 1)), scope: scoped?.scope ?? null, query };
     }
     /** 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
@@ -77,15 +58,14 @@ export class PickInput {
         this.host.render();
         return true;
     }
-    /** The band's height estimate: the header + the windowed rows (or
-     *  the one "no match" row) + the counter. */
-    rows() {
+    /** The band's height estimate: the header, the windowed rows and the
+     *  selected row's opened second row (or the one "no match" row), and
+     *  the key row — sessionPickerRows' shape at this terminal height. */
+    rows(height) {
         const view = this.state();
         if (view === null)
             return 0;
-        // 0.40.1: + the unknown-workspace row, when CURRENT shows it
-        const unknownRow = view.scope != null && !view.scope.all && view.scope.unknown > 0 ? 1 : 0;
-        return Math.min(Math.max(view.matches.length, 1), AT_VISIBLE) + 2 + unknownRow;
+        return view.matches.length === 0 ? 3 : Math.min(view.matches.length, resumeVisible(height)) + 3;
     }
     /** ↑↓: the selection walks the matches and stops at both ends. True
      *  when the picker owned the key (the caller renders). */

package/dist/session-picker.d.ts

@@ -62,8 +62,14 @@ export declare function scopeSessions(cards: readonly SessionCardView[], here: s
     readonly cards: readonly SessionCardView[];
     readonly scope: PickScopeState;
 };
-/** The band's title — the scope and both counts, and the key that flips it. */
-export declare function scopeTitle(scope: PickScopeState | null): string;
+/** The band's title — named after the command that opened it, then the
+ *  scope and its counts. Graphite P1 (owner, 2026-09-30): the key that
+ *  flips the scope moved to the key row, and a filter says how many of
+ *  the scope match. */
+export declare function scopeTitle(scope: PickScopeState | null, filter?: {
+    readonly matches: number;
+    readonly of: number;
+} | null): 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
@@ -108,19 +114,6 @@ export declare function idColumn(cards: readonly SessionCardView[]): number;
  * 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, here?: string | null): 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 {
@@ -129,16 +122,38 @@ export interface SessionPickState {
     readonly selected: number;
     /** 0.40.0: null when the picker was opened without a workspace. */
     readonly scope?: PickScopeState | null;
+    /** Graphite P1: the filter as typed — the title lights the letters it
+     *  matched, and the band says how many match. Absent = no filter. */
+    readonly query?: string;
 }
+/** How many sessions the band shows: eight on a terminal 30 rows or
+ *  taller, five below (owner, 2026-09-30). */
+export declare function resumeVisible(height: number): number;
+/** The window over the matches, with a scroll-off of one: while more lies
+ *  past an edge, the cursor stays a row inside it, so the edge row that
+ *  carries a more-mark is never the selected one. Stateless, like
+ *  bandWindow: the same (total, selected) always draws the same window. */
+export declare function resumeWindow(total: number, selected: number, visible: number): {
+    first: number;
+    count: number;
+};
+/** The row's state word — empty for the quiet default, a finished session. */
+export declare function sessionStateWord(card: SessionCardView): string;
+/** When the session started, read from its id — the id IS the UTC stamp
+ *  it was made at (apps/cli session-id.ts) — in local time. Null for an
+ *  id that is not one. */
+export declare function sessionStarted(id: string): string | null;
+/** What the empty input says while the picker is up: typing there filters. */
+export declare const RESUME_FILTER_HINT = "filter by title or id";
 /**
- * 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.
+ * The whole band: the named hairline, the windowed table with the
+ * selected row opened, and the key row. 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. `height` is the terminal's: it sets how many
+ * sessions show (resumeVisible).
  */
-export declare function sessionPickerRows(state: SessionPickState, W: number, now: number): string[];
+export declare function sessionPickerRows(state: SessionPickState, W: number, now: number, height?: number): string[];
 /**
  * Slice ③ — the `kiso sessions` TTY row: the same projection, printed
  * rather than picked. No selection bar (nothing is selected on a