@vincemakes/kiso-tui 0.8.0 → 0.10.0

package/dist/ask-panel.d.ts

@@ -27,7 +27,7 @@
  * durability would need a new durable mechanism), no "chat about this"
  * hand-off, no timeout and no countdown.
  */
-import { type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, type PanelPhase, type PanelSel, type PanelState, type PanelView } from "./approval-panel.js";
+import { type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, type PanelPhase, type PanelSel, type PanelState, type PanelView, type PickRuntime } from "./approval-panel.js";
 /** The schema's own bounds — the registry refuses anything outside them
  *  (extensions/ask validates; these are the numbers it validates to). */
 export declare const ASK_MAX_QUESTIONS = 4;
@@ -77,13 +77,14 @@ export declare function askStatus(view: PanelView, state: AskRuntime): string;
 /** The input row's lead: the digit lead while picking, the typing lead
  *  in the custom phase (the rule-input phase's shape, reused). */
 export declare function askLeadPlain(state: AskRuntime): string;
-export declare function panelBlockRows(view: PanelView, phase: PanelPhase, sel: PanelSel, W: number, maxRows: number, ask?: AskRuntime): string[];
-export declare function panelLead(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime): string;
-export declare function panelLeadPlain(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime): string;
-export declare function panelStatus(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime): string;
-export declare function panelAffordance(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime): string;
+export declare function panelBlockRows(view: PanelView, phase: PanelPhase, sel: PanelSel, W: number, maxRows: number, ask?: AskRuntime, pick?: PickRuntime): string[];
+export declare function panelLead(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime, pick?: PickRuntime): string;
+export declare function panelLeadPlain(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime, pick?: PickRuntime): string;
+export declare function panelStatus(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime, pick?: PickRuntime): string;
+export declare function panelAffordance(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime, pick?: PickRuntime): string;
 /** The whole panel state in one call — the compositor's four reads share
- *  one source, so an ask can never render half as an approval. */
+ *  one source, so an ask can never render half as an approval (TUI2-R2
+ *  ④: nor a pick as either). */
 export declare const panelRowsOf: (s: PanelState, W: number, maxRows: number) => string[];
 export declare const panelLeadOf: (s: PanelState) => string;
 export declare const panelStatusOf: (s: PanelState) => string;

package/dist/ask-panel.js

@@ -27,7 +27,7 @@
  * durability would need a new durable mechanism), no "chat about this"
  * hand-off, no timeout and no countdown.
  */
-import { panelAffordance as basePanelAffordance, panelBlockRows as basePanelBlockRows, panelLead as basePanelLead, panelLeadPlain as basePanelLeadPlain, panelStatus as basePanelStatus, } from "./approval-panel.js";
+import { panelAffordance as basePanelAffordance, panelBlockRows as basePanelBlockRows, panelLead as basePanelLead, panelLeadPlain as basePanelLeadPlain, panelStatus as basePanelStatus, pickAffordance, pickBlockRows, pickLead, pickLeadPlain, pickStatus, } from "./approval-panel.js";
 import { cutLine } from "@vincemakes/kiso-tui-cells/components";
 import { escapeTerminal, palette } from "./render.js";
 /** The schema's own bounds — the registry refuses anything outside them
@@ -197,7 +197,15 @@ export function askBlockRows(view, state, W, maxRows) {
         rows.push(...body);
     }
     rows.push(`${gutter}${p.dim}${askAffordance(state)}${p.reset}`);
-    rows.push(`${p.dim}└ ${p.reset}`);
+    // TUI2-R1.5 11 (VD-13), shared with the approval panel: a real bottom RULE, in the block's own edge
+    // vocabulary — the same box-drawing run its divider already uses —
+    // anchored at the gutter column. It used to be `\u2514 `: a two-cell stub
+    // floating at column 1, with no rule running from it and no corner
+    // above it to answer. Worse, `\u2514 ` is the cut-notice prefix everywhere
+    // else in the product, so a CAPPED panel emitted two elbow rows in a
+    // row meaning entirely different things. The rule reads as an edge,
+    // and the cut notice above it reads as a notice.
+    rows.push(`${p.dim}\u2514${"\u2500".repeat(Math.max(0, W - 1))}${p.reset}`);
     return rows;
 }
 /** The status row's right-hand hint — the phase's keys. */
@@ -217,38 +225,49 @@ export function askLeadPlain(state) {
     return state.phase === "custom" ? "your answer: " : "1-4> ";
 }
 // ── the dispatchers: the panel slot, with the ask branch folded in ────
-export function panelBlockRows(view, phase, sel, W, maxRows, ask) {
+export function panelBlockRows(view, phase, sel, W, maxRows, ask, pick) {
+    if (view.pick !== undefined && pick !== undefined)
+        return pickBlockRows(view, pick, W, maxRows);
     if (view.ask !== undefined && ask !== undefined)
         return askBlockRows(view, ask, W, maxRows);
     return basePanelBlockRows(view, phase, sel, W, maxRows);
 }
-export function panelLead(view, phase, sel, ask) {
+export function panelLead(view, phase, sel, ask, pick) {
     const p = palette();
+    if (view.pick !== undefined && pick !== undefined)
+        return pickLead(view, pick);
     if (view.ask !== undefined && ask !== undefined)
         return `${p.bold}${askLeadPlain(ask)}${p.reset}`;
     return basePanelLead(view, phase, sel);
 }
-export function panelLeadPlain(view, phase, sel, ask) {
+export function panelLeadPlain(view, phase, sel, ask, pick) {
+    if (view.pick !== undefined && pick !== undefined)
+        return pickLeadPlain(view, pick);
     if (view.ask !== undefined && ask !== undefined)
         return askLeadPlain(ask);
     return basePanelLeadPlain(view, phase, sel);
 }
-export function panelStatus(view, phase, sel, ask) {
+export function panelStatus(view, phase, sel, ask, pick) {
+    if (view.pick !== undefined && pick !== undefined)
+        return pickStatus(view);
     if (view.ask !== undefined && ask !== undefined)
         return askStatus(view, ask);
     return basePanelStatus(view, phase, sel);
 }
-export function panelAffordance(view, phase, sel, ask) {
+export function panelAffordance(view, phase, sel, ask, pick) {
+    if (view.pick !== undefined && pick !== undefined)
+        return pickAffordance(pick);
     if (view.ask !== undefined && ask !== undefined)
         return askAffordance(ask);
     return basePanelAffordance(view, phase, sel);
 }
 /** The whole panel state in one call — the compositor's four reads share
- *  one source, so an ask can never render half as an approval. */
-export const panelRowsOf = (s, W, maxRows) => panelBlockRows(s.view, s.phase, s.sel, W, maxRows, s.ask);
-export const panelLeadOf = (s) => panelLead(s.view, s.phase, s.sel, s.ask);
-export const panelStatusOf = (s) => panelStatus(s.view, s.phase, s.sel, s.ask);
-export const panelAffordanceOf = (s) => panelAffordance(s.view, s.phase, s.sel, s.ask);
+ *  one source, so an ask can never render half as an approval (TUI2-R2
+ *  ④: nor a pick as either). */
+export const panelRowsOf = (s, W, maxRows) => panelBlockRows(s.view, s.phase, s.sel, W, maxRows, s.ask, s.pick);
+export const panelLeadOf = (s) => panelLead(s.view, s.phase, s.sel, s.ask, s.pick);
+export const panelStatusOf = (s) => panelStatus(s.view, s.phase, s.sel, s.ask, s.pick);
+export const panelAffordanceOf = (s) => panelAffordance(s.view, s.phase, s.sel, s.ask, s.pick);
 // ── the view: what the human reads when the model asks ────────────────
 /** The ask's PanelView. The dock-less fallback question is HONEST: a
  *  terminal without a panel cannot walk options, so it says the ask is

package/dist/at-picker.d.ts

@@ -157,3 +157,7 @@ export declare function atPanelRows(state: {
     selected: number;
     capped: boolean;
 }, W: number): string[];
+/** TUI2-R1.5 ⑦(b) — the one-row dim header that turns a band into a
+ *  surface. Shared by the @ picker and the / menu so the two read the
+ *  same way. */
+export declare function bandHeader(label: string, W: number): string;

package/dist/at-picker.js

@@ -182,20 +182,41 @@ function splitPath(path) {
 export function atRow(match, selected, W) {
     const p = palette();
     const { dir, name } = splitPath(escapeTerminal(match.path));
-    const lead = selected ? `${p.rv}→ ${p.rvEnd}` : "  ";
     // the name's own matched positions, mapped out of the full path
     const marks = new Set(match.hit.filter((i) => i >= dir.length).map((i) => i - dir.length));
-    // room: W − the 2-cell lead − 1 separating space before the directory
-    const nameRoom = Math.max(1, W - 2 - (dir === "" ? 0 : visibleWidth(dir) + 1));
+    // TUI2-R1.5 ⑧ (VD-9): the directory rides NEXT TO the name it
+    // qualifies. It used to be right-aligned to the band's far edge, which
+    // on a 100-column terminal put `src/` some eighty columns from the
+    // `parser.ts` it belongs to: the eye had to cross the whole row to
+    // learn which parser.ts this was, and the column read as a second list.
+    // Adjacent and dim, it is what it always meant to be — a qualifier.
+    // the name is the flexible column and the qualifier gives way first: a
+    // narrow window keeps the thing being aimed at.
+    const room = Math.max(1, W - 2);
+    const suffix = dir === "" ? "" : widthCut(`  — ${dir}`, Math.max(0, room - 4));
+    const nameRoom = Math.max(1, room - visibleWidth(suffix));
     const shownName = widthCut(name, nameRoom);
     let painted = "";
     for (let i = 0; i < shownName.length; i += 1) {
         painted += marks.has(i) ? `${p.bold}${shownName[i]}${p.reset}` : shownName[i];
     }
-    if (dir === "")
-        return `${lead}${painted}`;
-    const pad = Math.max(1, W - 2 - visibleWidth(shownName) - visibleWidth(dir));
-    return `${lead}${painted}${" ".repeat(pad)}${p.dim}${dir}${p.reset}`;
+    const text = `${painted}${suffix === "" ? "" : `${p.dim}${suffix}${p.reset}`}`;
+    const width = visibleWidth(shownName) + visibleWidth(suffix);
+    if (!selected)
+        return `  ${text}`;
+    // TUI2-R1.5 ⑧ (VD-9): the selection is a FULL-ROW bar — the W16 chip
+    // mechanism, which the user chip and the turn fold already use. A
+    // two-cell `→ ` marker on the inverse band is one character of
+    // highlight in an eighty-column row, and the walkthrough could barely
+    // find it. The bar spans the row's whole width so the selection is
+    // visible from anywhere on the line. Mono discipline: reverse video,
+    // no new colours.
+    //
+    // The inner spans close with rvEnd (SGR 27), never SGR 0 — a reset
+    // inside the bar would punch a hole in it. `painted`'s bold marks and
+    // the dim suffix both end in SGR 0, so the bar is re-opened after each.
+    const inner = `${painted.replaceAll(p.reset, `${p.reset}${p.rv}`)}${suffix === "" ? "" : `${p.dim}${suffix}${p.reset}${p.rv}`}`;
+    return `${p.rv} ${inner}${" ".repeat(Math.max(0, W - width - 2))} ${p.rvEnd}`;
 }
 /**
  * KC3 §4 — the counter row: `(n/total)`, where n is the 1-based
@@ -220,9 +241,21 @@ export function atCounterRow(selected, total, capped, W) {
  */
 export function atPanelRows(state, W) {
     const { first, count } = atWindow(state.matches.length, state.selected);
-    const rows = [];
+    // TUI2-R1.5 ⑦(b) (VD-8): the band NAMES itself. It renders frameless
+    // directly above the composer, so with scrollback behind it there was
+    // nothing to say where the surface began — the rows read as more
+    // history. One dim row is enough to make it UI. Mono discipline: dim
+    // text, no rule, no colour.
+    const rows = [bandHeader("files", W)];
     for (let i = first; i < first + count; i += 1)
         rows.push(atRow(state.matches[i], i === state.selected, W));
     rows.push(atCounterRow(state.selected, state.matches.length, state.capped, W));
     return rows;
 }
+/** TUI2-R1.5 ⑦(b) — the one-row dim header that turns a band into a
+ *  surface. Shared by the @ picker and the / menu so the two read the
+ *  same way. */
+export function bandHeader(label, W) {
+    const p = palette();
+    return `${p.dim}${widthCut(label, Math.max(1, W))}${p.reset}`;
+}

package/dist/compositor.d.ts

@@ -45,6 +45,7 @@
 import { type MenuItem } from "./editor.js";
 import type { PanelState } from "./approval-panel.js";
 import { type AtMatch } from "./at-picker.js";
+import { type SessionPickState } from "./session-picker.js";
 /** KC3 §4 — the @ picker's bound state (the editor's atState()). */
 export interface AtPanelState {
     readonly matches: readonly AtMatch[];
@@ -109,6 +110,20 @@ export declare class Body {
      *  outcome. */
     toolVerdict(callId: string, decision: "approved" | "denied", decidedBy?: string, reason?: string): void;
     toolRunning(callId: string): void;
+    /**
+     * TUI2-R1 (C) — the RUNNING call's observed output.
+     *
+     * The CLI tails the shell tool's progress sidecar and hands what it
+     * read to the cell. Deliberately narrow: only a cell that is still
+     * RUNNING accepts it, so an observation can never overwrite a real
+     * result, and an unchanged read costs no frame at all (a poller
+     * fires far more often than the output changes).
+     *
+     * This adds no event and no durable state. The text lands in the
+     * cell's live rendering and is replaced wholesale by the tool's own
+     * result at settle — which is the only text anything else ever reads.
+     */
+    toolProgress(callId: string, text: string): void;
     toolSucceeded(callId: string): void;
     toolFailed(callId: string, error: string): void;
     toolResult(callId: string, result: {
@@ -152,7 +167,7 @@ export declare class Body {
      *  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;
+    raw(lines: string[], wrap?: "words"): void;
     /** The last COMPLETE thinking block, for /think. */
     lastThinking(): string | null;
     /** The last completed tool call, for /last. */
@@ -164,15 +179,6 @@ 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";
     } | {
@@ -208,6 +214,8 @@ export declare class Body {
     bindInput(state: () => InputState, prompt: string): void;
     /** Bind the editor's slash-command menu state — the MenuSelect slot
      *  occupant (the menu replaces the editor's view while open). */
+    /** TUI2-R1 (D): bind the editor's keys-sheet flag. */
+    bindSheet(state: () => boolean): void;
     bindMenu(state: () => {
         items: readonly MenuItem[];
         selected: number;
@@ -216,6 +224,9 @@ export declare class Body {
      *  band — see #menuRows for why that is a decision and not a
      *  shortcut. */
     bindAt(state: () => AtPanelState | null): void;
+    /** TUI2-R2 ②: bind the editor's session picker — the band's third
+     *  occupant (see #menuRows for why they share one). */
+    bindPick(state: () => SessionPickState | null): void;
     /** Bind the pending-turn queue — the CLI's live slots (chat.ts):
      *  the chips render in the menu-rows family, the live caps shrink
      *  by their rows, and the +N queued hint rides the status row. */
@@ -252,6 +263,9 @@ export declare class Dock {
      *  occupant (the panel replaces the live region + the input lead
      *  while up; the old ApprovalPrompt's question slot retires). */
     bindApproval(state: () => PanelState | null): void;
+    /** TUI2-R1 (D): bind the editor's keys-sheet flag — the slot read for
+     *  the ? overlay (the menu/picker binding pattern). */
+    bindSheet(state: () => boolean): void;
     bindInput(state: () => InputState, prompt: string): void;
     bindMenu(state: () => {
         items: readonly MenuItem[];
@@ -261,6 +275,10 @@ export declare class Dock {
      *  menu (see Body#menuRows). Unbound, the picker cannot render, and
      *  every frame is byte-identical to before the round. */
     bindAt(state: () => AtPanelState | null): void;
+    /** TUI2-R2 ②: bind the editor's session picker — the band's third
+     *  occupant. Unbound (every path but bare `kiso resume`), the picker
+     *  cannot render and every frame is byte-identical to before. */
+    bindPick(state: () => SessionPickState | null): void;
     /** W22: bind the pending-turn queue — the chips + the +N queued
      *  hint (the CLI binds it from chat(); the editor's pop keys ride
      *  the LineInput's own bindQueue). */