@vincemakes/kiso-tui 0.39.2 → 0.40.1

package/dist/editor.js

@@ -46,13 +46,20 @@ import { PickInput } from "./pick-input.js";
 // "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).
 /**
- * TUI2-R3v2 ② — the mouse-mode bytes, stated once.
+ * TUI2-R3v2 ②, corrected by the owner's ruling of 2026-09-21 (finding
+ * DC-56) — the mouse-mode bytes, stated once.
  *
  * ?1000 is the button-event report and ?1006 is the SGR encoding that
  * makes it parseable past column 95 (the legacy X10 encoding packs the
- * coordinate into one byte and simply breaks on a wide terminal). Both
- * go on together and come off together; a terminal left with either one
- * set is a terminal that prints escape bytes at the shell prompt.
+ * coordinate into one byte and simply breaks on a wide terminal). kiso
+ * still RESETS them — on entry (a previous process may have died with
+ * reporting left on) and on exit — but it no longer ENABLES them, because
+ * a terminal that is reporting stops scrolling its own scrollback: a
+ * surface that takes the mouse takes the history with it. kiso's
+ * transcript lives in that scrollback by design, and the first version of
+ * this feature locked it exactly where a person most wants to read back —
+ * under a blocking question. The history wins: no surface claims the
+ * mouse, and every surface keeps its keys.
  */
 /**
  * R5 — the viewer's key table, as a pure function of the input chunk.
@@ -105,12 +112,11 @@ const ALT_WORD = new Map([
     ["\x7f", "killBack"],
     ["\x08", "killBack"],
 ]);
-export const MOUSE_ON = "\x1b[?1000h\x1b[?1006h";
 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 +136,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
@@ -310,12 +320,16 @@ export class Editor {
     /** TUI2-R3v2 ①: one-shot — a panel that just closed swallows the
      *  habitual trailing enter rather than submitting the restored draft. */
     #swallowEnter = false;
-    /** TUI2-R3v2 ②: whether SGR 1006 reporting is currently enabled. */
-    #mouseOn = false;
     /** TUI2-R3v2 ②: where the compositor put the panel's option rows this
      *  frame (absolute 1-based screen rows). The editor owns no geometry —
      *  it asks the surface that placed them. */
     #panelRows = null;
+    /** B (review of this round): the pick panel's window, published by the
+     *  surface that DREW it — the frame's budget decides the size, so the
+     *  editor PULLS it here instead of letting the input layer re-derive one
+     *  (two derivations are two sizes, and on a short terminal the digits named
+     *  rows nobody could see). */
+    #pickWin = null;
     #lineCb = null;
     #pendingLines = []; // submits before onLine is wired (startup) — never dropped
     #sigintCb = null;
@@ -341,6 +355,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 +370,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 +445,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;
@@ -510,7 +535,6 @@ export class Editor {
             // the human has no way to ask for it back.
             process.stdin.setRawMode(true);
             process.stdout.write(MOUSE_OFF);
-            this.#mouseOn = false;
             process.stdout.write("\x1b[?2004h");
             process.stdin.on("data", this.#onData);
         }
@@ -794,11 +818,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 +979,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 +998,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() {
@@ -998,7 +1047,6 @@ export class Editor {
         // chance this process gets, and emitting six harmless bytes twice
         // is not a cost worth reasoning about.
         process.stdout.write(MOUSE_OFF);
-        this.#mouseOn = false;
         process.stdout.write("\x1b[?2004l"); // bracketed paste OFF
         // REL-0161: the hardware cursor was hidden for the session's whole
         // life (the compositor's entry reset); this is the one place kiso
@@ -1010,30 +1058,20 @@ export class Editor {
         this.#closedResolve();
     }
     /**
-     * TUI2-R3v2 ② — mouse reporting follows the SELECTION SURFACES and
-     * nothing else.
+     * TUI2-R3v2 ②, corrected by the owner's ruling of 2026-09-21 (finding
+     * DC-56) — the bands still tell their host when a selection surface
+     * opens or closes, and the host's answer is now "leave the terminal
+     * alone".
      *
-     * While it is on, the terminal's own text selection changes behaviour
-     * (shift+drag still selects on every terminal that matters, but plain
-     * drag-to-copy does not), so leaving it on for the whole session would
-     * tax every copy-paste in the product to pay for a gesture that only
-     * means something while a list is up. It goes on when one opens and
-     * off when it closes — and both calls are idempotent, because the
-     * surfaces nest (a panel can open over a picker) and the bytes must
-     * not depend on the order they unwind in.
+     * The bands' contract is unchanged — a band reports that it has taken
+     * the composer — but the mouse is not a thing kiso hands out: reporting
+     * on means the terminal stops scrolling its own scrollback, and every
+     * band kiso has (the approval/ask/pick panel, the session picker, the @
+     * picker) is a keyboard surface — digits, arrows, enter, esc, a filter.
+     * The call sites stay so a future surface that DOES want the mouse has
+     * one place to ask, and the ruling is written at that place.
      */
-    #setMouse(on) {
-        if (this.#mouseOn === on)
-            return;
-        this.#mouseOn = on;
-        if (this.#entered)
-            process.stdout.write(on ? MOUSE_ON : MOUSE_OFF);
-    }
-    /** The surfaces that own a selection — the approval/ask/pick panel, the
-     *  session picker and the @ picker. Any one of them up = reporting on. */
-    #syncMouse() {
-        this.#setMouse(this.#panelInput.up() || this.#pickInput.up() || this.#atUp());
-    }
+    #syncMouse() { }
     /** OR-11 (a) — the lead the composer's row is DRAWN with, which is not
      *  always the brick. The CLI binds the compositor's input lead as `""`
      *  (a prompt character is a third thing saying "input lives here", and
@@ -1074,6 +1112,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 +1565,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.
@@ -1692,6 +1749,13 @@ export class Editor {
      * and context-menu everywhere else and would mean "approve" here.
      * The stakes are a side effect the human did not ask for, and an
      * ambiguous mouse event is not consent.
+     *
+     * 2026-09-21 (finding DC-56): kiso no longer ENABLES reporting, so on a
+     * terminal this path is reached only when something else left the mouse
+     * on — and then a click still answers the panel. The wheel stays
+     * dropped either way (a scroll past a panel is not a choice), which is
+     * the other half of why the settled rule is "no surface takes the
+     * mouse": a terminal that is reporting cannot scroll its own history.
      */
     #mouseEvent(params, press) {
         if (!press)
@@ -1712,6 +1776,11 @@ export class Editor {
     bindPanelRows(fn) {
         this.#panelRows = fn;
     }
+    /** B: the pick window the last frame drew — the Dock's value, not the
+     *  editor's guess. Same pull-on-demand shape as `bindPanelRows`. */
+    bindPickWindow(fn) {
+        this.#pickWin = fn;
+    }
     /** TMUX-F1 ②: `run` identical arrow sequences arrived in ONE read. Every
      *  surface but one gets every press — a wheel over the transcript viewer,
      *  a panel, a multi-row draft scrolls, as a wheel should. The HISTORY
@@ -1941,6 +2010,7 @@ export class Editor {
             reflow: () => this.#reflow(),
             render: () => this.#onRender(),
             syncMouse: () => this.#syncMouse(),
+            pickWindow: () => this.#pickWin?.() ?? null,
             closeBands: () => {
                 this.#menuOpen = false;
                 this.#menuSel = 0;
@@ -2436,6 +2506,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 +2520,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/panel-input.d.ts

@@ -32,6 +32,14 @@ export interface BandHost {
     line(): string;
     /** The buffer with its paste capsules expanded — the text that would leave the editor. */
     expandPastes(line: string): string;
+    /** The pick panel's window as the RENDERER drew it (review of this round):
+     *  the size depends on the frame's budget, so the digit keys must be handed
+     *  the value instead of deriving it again from PICK_MAX. Absent → the input
+     *  layer falls back to its own derivation. */
+    pickWindow?(): {
+        first: number;
+        size: number;
+    } | null;
     /** Empty the buffer: chars, cursor and the ↑↓ goal column. */
     clear(): void;
     /** Type one code point at the cursor. */

package/dist/panel-input.js

@@ -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, saferDegradedNote, startLevel, stepLevel, } from "./approval-panel.js";
+import { PICK_MAX, panelOptions, pickWindow, saferDegradedNote, startLevel, stepLevel, } from "./approval-panel.js";
 import { askCommitCustom, askKey, askOnCustomRow, askStart } from "./ask-panel.js";
 export class PanelInput {
     host;
@@ -206,7 +206,11 @@ export class PanelInput {
         if (panel === null)
             return false;
         if (panel.pick !== null && panel.pick.phase === "options") {
-            const n = Math.min(panel.view.pick.options.length, PICK_MAX);
+            // 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);
             // OR-7: the second axis belongs to the highlighted option, so it
@@ -448,9 +452,18 @@ export class PanelInput {
         const panel = this.#panel;
         if (panel === null || panel.pick === null)
             return;
-        if (index < 0 || index >= Math.min(panel.view.pick.options.length, PICK_MAX))
+        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);
+        if (index < 0 || index >= size)
             return;
-        panel.pick = { cursor: index, phase: "options", level: startLevel(panel.view.pick.options[index]) };
+        const target = first + index;
+        if (target >= count)
+            return;
+        panel.pick = { cursor: target, phase: "options", level: startLevel(panel.view.pick.options[target]) };
         this.host.render();
     }
     #pickPanelEnter() {

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;

package/dist/pick-input.js

@@ -18,12 +18,16 @@
  * through the host.
  */
 import { AT_VISIBLE } from "./at-picker.js";
-import { sessionFilter } from "./session-picker.js";
+import { scopeSessions, sessionFilter } from "./session-picker.js";
 export class PickInput {
     host;
     #cards = null;
     #commit = null;
     #sel = 0;
+    /** 0.40.0: the running workspace (undefined = an unscoped picker), and
+     *  whether the person flipped to ALL. */
+    #here = undefined;
+    #all = false;
     constructor(host) {
         this.host = host;
     }
@@ -34,10 +38,12 @@ export 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, onPick) {
+    begin(cards, onPick, here) {
         this.#cards = cards;
         this.#commit = onPick;
         this.#sel = 0;
+        this.#here = here;
+        this.#all = false;
         this.host.syncMouse();
         this.host.clear();
         this.host.reflow();
@@ -51,15 +57,35 @@ export class PickInput {
     state() {
         if (this.#cards === null)
             return null;
-        const cards = this.#cards();
+        // 0.40.0: the filter runs INSIDE the scope — typing narrows what the
+        // 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)) };
+        return { cards, matches, selected: Math.max(0, Math.min(this.#sel, matches.length - 1)), scope: scoped?.scope ?? 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() {
+        const view = this.state();
+        if (view === null || view.scope === null || view.scope === undefined)
+            return false;
+        this.#all = !this.#all;
+        this.#sel = 0;
+        this.host.reflow();
+        this.host.render();
+        return true;
     }
     /** The band's height estimate: the header + the windowed rows (or
      *  the one "no match" row) + the counter. */
     rows() {
         const view = this.state();
-        return view === null ? 0 : Math.min(Math.max(view.matches.length, 1), AT_VISIBLE) + 2;
+        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;
     }
     /** ↑↓: the selection walks the matches and stops at both ends. True
      *  when the picker owned the key (the caller renders). */
@@ -78,6 +104,8 @@ export class PickInput {
         this.#cards = null;
         this.#commit = null;
         this.#sel = 0;
+        this.#here = undefined;
+        this.#all = false;
         this.host.syncMouse();
         this.host.clear();
         this.host.reflow();