@crouton-kit/crouter 0.3.28 → 0.3.29

package/dist/clients/attach/input-controller.js

@@ -12,41 +12,43 @@
 // is what calls `matchesKey` internally, so the controller wires intent via the
 // editor's `onSubmit`/`onEscape`/`onPasteImage` hooks + `onAction(app.*)`
 // registrations rather than matching raw keys itself.
+import { spawn } from 'node:child_process';
+import { readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { BROKER_READ_CAPS, encodeFrame, } from '../../core/runtime/broker-protocol.js';
 import { renderDialog } from './extension-dialogs.js';
-import { readClipboardImage } from './clipboard-image.js';
+import { readClipboardImage, writeClipboardImageToFile } from './clipboard-image.js';
 import { dispatchSlashCommand, isSlashCommand } from './slash-commands.js';
-/** Aggregate budget for images held for the next message (review M2). A drained
- *  prompt/steer/follow_up frame inlines ALL pending images as base64 in a single
- *  frame; these ceilings keep the images[] portion well within the broker's
- *  24 MiB line cap. Each clipboard image is ≤ 3 MiB base64 (clipboard-image
- *  MAX_BYTES), so the worst case is MAX_PENDING_IMAGES × 3 MiB = 12 MiB. A paste
- *  that would exceed EITHER bound is refused (not accumulated). The WHOLE frame
- *  (images + unbounded text + JSON envelope) is then bounded airtight by the
- *  MAX_FRAME_BYTES guard in `emitDrive` — this budget alone is not enough, since
- *  `text` is otherwise unbounded. */
-const MAX_PENDING_IMAGE_BYTES = 16 * 1024 * 1024;
-const MAX_PENDING_IMAGES = 4;
+import { buildForkPicker, buildModelPicker, buildScopedModelsPicker, buildSessionPicker, buildSettingsPicker, buildTreePicker, } from './pickers.js';
+/** Overlay geometry for the native pickers — a touch wider/taller than the
+ *  extension-dialog default since the model/session/tree lists are denser. */
+const PICKER_OVERLAY_OPTIONS = { anchor: 'center', width: '80%', maxHeight: '85%' };
+/** Max gap between two Esc presses to count as a double-tap (pi uses 500ms). */
+const DOUBLE_ESCAPE_MS = 500;
 /** Largest drive frame the controller will emit. The broker DESTROYS the viewer
  *  socket on any client line over BROKER_READ_CAPS.maxLineBytes (24 MiB), so we
  *  refuse to emit within a 4 MiB margin of that. `emitDrive` measures the ACTUAL
- *  encoded frame (text + base64 images[] + JSON envelope), so the cap holds no
- *  matter how the bytes split — closing the gap where a large text paste plus
- *  max images could otherwise overflow and tear down the socket. */
+ *  encoded frame (text + JSON envelope), so the cap holds however the bytes
+ *  split. Pasted images go to a temp file and enter the prompt as a path, never
+ *  as inline base64, so a paste can no longer push a frame toward this ceiling. */
 const MAX_FRAME_BYTES = BROKER_READ_CAPS.maxLineBytes - 4 * 1024 * 1024;
 export class InputController {
     tui;
     editor;
     keybindings;
     hooks;
-    /** Images pasted since the last send, attached to the next prompt/follow-up. */
-    pendingImages = [];
-    /** Running base64-byte total of `pendingImages` (review M2 aggregate budget). */
-    pendingImageBytes = 0;
     /** The currently-rendered blocking dialog, if any (for supersede/dismiss). */
     dialog;
+    /** The currently-open native picker overlay, if any (for supersede/dismiss). */
+    picker;
+    /** Monotonic open counter — a slow read-op reply whose `seq` is no longer the
+     *  latest is dropped, so an earlier picker never pops over a later request. */
+    openSeq = 0;
     /** Latest engine state from `welcome`/`session_info_changed` (for `/session`). */
     state;
+    /** Timestamp of the last lone Esc, for double-tap → tree detection (0 = none). */
+    lastEscapeAt = 0;
     constructor(tui, editor, keybindings, hooks) {
         this.tui = tui;
         this.editor = editor;
@@ -73,16 +75,52 @@ export class InputController {
     // -------------------------------------------------------------------------
     wire() {
         this.editor.onSubmit = (text) => this.handleSubmit(text);
-        // Esc / app.interrupt → abort the running turn.
-        this.editor.onEscape = () => this.hooks.onCommand({ type: 'abort' });
-        // Ctrl+V / Alt+V → read clipboard image, hold it for the next message.
+        // Esc — mirror pi's native interactive escape (interactive-mode
+        // setupKeyHandlers): while streaming, abort the turn; with an EMPTY editor
+        // and idle, a double-tap (≤500ms) opens the session-tree navigator to rewind
+        // to an earlier point (a lone tap just arms it); a non-empty editor swallows
+        // Esc (it never clears text). openTreePicker is the same get_tree →
+        // navigate_tree path that `/tree` and app.session.tree use.
+        this.editor.onEscape = () => {
+            if (this.state?.isStreaming) {
+                this.hooks.onCommand({ type: 'abort' });
+                return;
+            }
+            if (this.editor.getText().trim())
+                return;
+            const now = Date.now();
+            if (now - this.lastEscapeAt < DOUBLE_ESCAPE_MS) {
+                this.lastEscapeAt = 0;
+                void this.openTreePicker();
+            }
+            else {
+                this.lastEscapeAt = now;
+            }
+        };
+        // Ctrl+V / Alt+V → read clipboard image, save it to a temp file, and splice
+        // the file PATH into the editor at the caret (so the agent can read it).
         this.editor.onPasteImage = () => {
             void this.handlePaste();
         };
         // Keyboard shortcuts that map 1:1 to a frame needing no engine-side data.
         this.editor.onAction('app.session.new', () => this.hooks.onCommand({ type: 'new_session' }));
-        this.editor.onAction('app.model.cycleForward', () => this.hooks.onCommand({ type: 'cycle_model' }));
+        this.editor.onAction('app.model.cycleForward', () => this.hooks.onCommand({ type: 'cycle_model', direction: 'forward' }));
+        this.editor.onAction('app.model.cycleBackward', () => this.hooks.onCommand({ type: 'cycle_model', direction: 'backward' }));
+        this.editor.onAction('app.thinking.cycle', () => this.hooks.onCommand({ type: 'cycle_thinking' }));
         this.editor.onAction('app.message.followUp', () => this.handleFollowUp());
+        this.editor.onAction('app.message.dequeue', () => void this.handleDequeue());
+        // Pure client-side render toggles (ChatView owns the components).
+        this.editor.onAction('app.tools.expand', () => this.hooks.onToggleToolsExpand?.());
+        this.editor.onAction('app.thinking.toggle', () => this.hooks.onToggleThinking?.());
+        // Ctrl+G — compose the prompt in $VISUAL/$EDITOR, then load it back.
+        this.editor.onAction('app.editor.external', () => void this.openExternalEditor());
+        // Native pickers via keybinding. `app.model.select` is bound to ctrl+l by
+        // default (vendored in config-load); the session.* actions ship with no
+        // default key but fire if the user binds one — wiring them keeps parity.
+        this.editor.onAction('app.model.select', () => void this.openModelPicker());
+        this.editor.onAction('app.session.tree', () => void this.openTreePicker());
+        this.editor.onAction('app.session.fork', () => void this.openForkPicker());
+        this.editor.onAction('app.session.resume', () => void this.openSessionPicker());
     }
     slashContext() {
         return {
@@ -92,13 +130,161 @@ export class InputController {
             cwd: process.cwd(),
             nodeId: this.hooks.nodeId,
             onGraph: this.hooks.onGraph,
+            onQuit: this.hooks.onQuit,
+            onCopy: this.hooks.onCopy,
+            openModelPicker: () => void this.openModelPicker(),
+            openSessionPicker: () => void this.openSessionPicker(),
+            openForkPicker: () => void this.openForkPicker(),
+            openTreePicker: () => void this.openTreePicker(),
+            openSettingsPicker: () => void this.openSettingsPicker(),
+            openScopedModelsPicker: () => void this.openScopedModelsPicker(),
+            openLoginPicker: this.hooks.openLoginPicker ? () => this.hooks.openLoginPicker() : undefined,
+            openLogoutPicker: this.hooks.openLogoutPicker ? () => this.hooks.openLogoutPicker() : undefined,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Native interactive pickers (overlays). Each fetches its payload via the
+    // correlated read-op, builds the REAL pi selector, and routes selection to the
+    // same command frame the text-arg slash path sends. Opened by slash command
+    // (via slashContext) AND by keybinding (onAction, below).
+    // -------------------------------------------------------------------------
+    /** Send a command frame to the broker (picker selection sink). */
+    send = (frame) => this.hooks.onCommand(frame);
+    /** Fetch a picker payload (narrowed on `kind`), then build + show its overlay
+     *  iff this open is still the latest (m4: a stale slow reply is dropped). Any
+     *  failure — unwired channel, wrong kind, request error, or a throwing builder
+     *  — surfaces a notice instead of an unhandled rejection (m5). */
+    async openPicker(frame, kind, label, build) {
+        if (this.hooks.onRequest === undefined) {
+            this.notify(`The ${label} picker isn't available in this viewer`);
+            return;
+        }
+        const seq = ++this.openSeq;
+        let reply;
+        try {
+            reply = await this.hooks.onRequest(frame);
+        }
+        catch (err) {
+            this.notify(`Could not open the ${label} picker: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        if (seq !== this.openSeq)
+            return; // a newer picker open superseded this one
+        if (reply.kind !== kind) {
+            this.notify(`Unexpected reply building the ${label} picker`);
+            return;
+        }
+        this.showPicker((controls) => build(reply, controls.close));
+    }
+    /** Show a picker built by `build` (given a `close` that tears it down).
+     *  Mounted INLINE under the editor when attach-cmd wires onMountPicker/
+     *  onUnmountPicker (the integrated chrome path); otherwise falls back to a
+     *  centered overlay. Supersedes any picker already on screen. Routes focus to
+     *  the builder's declared focus target (an inner list for fork/settings) and
+     *  ALWAYS restores editor focus on close — `OverlayHandle.hide()` only
+     *  auto-restores when the OUTER component held focus, which is not the case
+     *  once we focus an inner child. A throwing builder is caught into a notice (m5). */
+    showPicker(build) {
+        this.picker?.dismiss();
+        const inline = this.hooks.onMountPicker !== undefined && this.hooks.onUnmountPicker !== undefined;
+        let handle;
+        let current;
+        let done = false;
+        const disposeCurrent = () => {
+            const disposable = current?.component;
+            try {
+                disposable?.dispose?.();
+            }
+            catch {
+                /* ignore dispose errors during teardown */
+            }
+        };
+        const mount = (p) => {
+            if (inline)
+                this.hooks.onMountPicker(p.component);
+            else
+                handle = this.tui.showOverlay(p.component, PICKER_OVERLAY_OPTIONS);
+            this.tui.setFocus(p.focus);
+        };
+        const unmount = () => {
+            if (inline)
+                this.hooks.onUnmountPicker?.();
+            else
+                handle?.hide();
+        };
+        // Swap the mounted component IN PLACE (same inline slot) — multi-step flows
+        // like /login replace the provider selector with the login dialog without
+        // ever popping a centered overlay. Does NOT restore editor focus (only a
+        // genuine close does); focus moves to the new component.
+        const replace = (component, focus) => {
+            if (done)
+                return;
+            disposeCurrent();
+            unmount();
+            current = { component, focus };
+            mount(current);
+            this.tui.requestRender();
+        };
+        const close = () => {
+            if (done)
+                return;
+            done = true;
+            disposeCurrent();
+            unmount();
+            this.picker = undefined;
+            this.tui.setFocus(this.editor);
+            this.tui.requestRender();
+        };
+        try {
+            current = build({ close, replace });
+        }
+        catch (err) {
+            this.notify(`Could not open picker: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        mount(current);
+        this.picker = {
+            // Supersede: tear down without restoring editor focus — the new picker
+            // grabs focus next. Genuine close restores the editor (above).
+            dismiss: () => {
+                if (done)
+                    return;
+                done = true;
+                disposeCurrent();
+                unmount();
+            },
         };
+        this.tui.requestRender();
+    }
+    openModelPicker() {
+        return this.openPicker({ type: 'list_models' }, 'list_models', 'model', (data, close) => buildModelPicker(this.tui, data, this.send, close));
+    }
+    openSessionPicker() {
+        return this.openPicker({ type: 'list_sessions', scope: 'cwd' }, 'list_sessions', 'session', (data, close) => buildSessionPicker(this.tui, data, this.hooks.onRequest, this.keybindings, this.send, close));
+    }
+    openTreePicker() {
+        return this.openPicker({ type: 'get_tree' }, 'get_tree', 'tree', (data, close) => buildTreePicker(this.tui, data, this.send, close));
+    }
+    openForkPicker() {
+        return this.openPicker({ type: 'get_tree' }, 'get_tree', 'fork', (data, close) => buildForkPicker(data, this.send, close));
+    }
+    openSettingsPicker() {
+        return this.openPicker({ type: 'get_settings' }, 'get_settings', 'settings', (data, close) => buildSettingsPicker(data, this.send, close, (m) => this.notify(m)));
+    }
+    openScopedModelsPicker() {
+        return this.openPicker({ type: 'list_scoped_models' }, 'list_scoped_models', 'scoped-models', (data, close) => buildScopedModelsPicker(data, close, (m) => this.notify(m)));
+    }
+    /** Open a viewer-local auth picker (login/logout) — uses the same showPicker
+     *  machinery as read-op pickers, but with a locally-built component (no read-op
+     *  request; auth operations are viewer-local in tmux-local attach). */
+    openAuthPicker(build) {
+        this.showPicker(build);
     }
     handleSubmit(text) {
         const trimmed = text.trim();
-        if (!trimmed && this.pendingImages.length === 0)
+        if (!trimmed)
             return;
-        if (trimmed && isSlashCommand(trimmed)) {
+        if (isSlashCommand(trimmed)) {
             // Recognized builtin/scoped-out → handled here; unrecognized falls through
             // and is sent to the engine as a prompt (extension command).
             if (dispatchSlashCommand(trimmed, this.slashContext())) {
@@ -106,34 +292,105 @@ export class InputController {
                 return;
             }
         }
-        const images = this.pendingImagesPayload();
         // Submit-while-streaming = steer (pi-native parity): interject into the
         // running turn instead of queueing a fresh prompt. `isStreaming` is the
         // broker snapshot's busy signal; the broker routes `steer` → session.steer()
         // and `prompt` → session.prompt(). Idle / no state yet → prompt (safe default).
         const busy = this.state?.isStreaming === true;
         const frame = busy
-            ? { type: 'steer', text: trimmed, images }
-            : { type: 'prompt', text: trimmed, images };
+            ? { type: 'steer', text: trimmed }
+            : { type: 'prompt', text: trimmed };
         if (!this.emitDrive(frame))
-            return; // too large — keep editor + pending to trim
-        this.clearPendingImages();
-        if (trimmed)
-            this.editor.addToHistory(trimmed);
+            return; // too large — keep editor to trim
+        this.editor.addToHistory(trimmed);
         this.editor.setText('');
     }
     handleFollowUp() {
         const text = this.editor.getText().trim();
-        if (!text && this.pendingImages.length === 0)
+        if (!text)
             return;
-        const images = this.pendingImagesPayload();
-        if (!this.emitDrive({ type: 'follow_up', text, images }))
+        if (!this.emitDrive({ type: 'follow_up', text }))
             return;
-        this.clearPendingImages();
-        if (text)
-            this.editor.addToHistory(text);
+        this.editor.addToHistory(text);
         this.editor.setText('');
     }
+    /** Ctrl+G / app.editor.external — open the current editor text in $VISUAL/$EDITOR
+     *  and load the saved result back. Ported from pi's `openExternalEditor`: stop
+     *  the TUI to release the terminal, run the editor with inherited stdio, and on
+     *  a clean exit (status 0) replace the editor text; the socket keeps running in
+     *  the background throughout. */
+    async openExternalEditor() {
+        const editorCmd = process.env.VISUAL || process.env.EDITOR;
+        if (!editorCmd) {
+            this.notify('No editor configured — set $VISUAL or $EDITOR');
+            return;
+        }
+        const editorWithExpanded = this.editor;
+        const currentText = editorWithExpanded.getExpandedText?.() ?? this.editor.getText();
+        const tmpFile = join(tmpdir(), `crtr-attach-editor-${Date.now()}.pi.md`);
+        try {
+            writeFileSync(tmpFile, currentText, 'utf-8');
+            this.tui.stop();
+            // Split on spaces so `code --wait`-style commands keep their args.
+            const [cmd, ...args] = editorCmd.split(' ');
+            process.stdout.write(`Launching external editor: ${editorCmd}\nThe viewer resumes when it exits.\n`);
+            const status = await new Promise((resolve) => {
+                const child = spawn(cmd, [...args, tmpFile], {
+                    stdio: 'inherit',
+                    shell: process.platform === 'win32',
+                });
+                child.on('error', () => resolve(null));
+                child.on('close', (code) => resolve(code));
+            });
+            if (status === 0) {
+                this.editor.setText(readFileSync(tmpFile, 'utf-8').replace(/\n$/, ''));
+            }
+        }
+        catch (err) {
+            this.notify(`External editor failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch {
+                /* ignore temp-file cleanup errors */
+            }
+            this.tui.start();
+            this.tui.requestRender(true);
+        }
+    }
+    /** Alt+Up / app.message.dequeue — clear the broker's queued steering + follow-up
+     *  messages and restore them to the editor, prepended to any in-progress text
+     *  (pi's `restoreQueuedMessagesToEditor`: queued text first, joined by blank
+     *  lines). A read-AND-mutate op over the correlated request channel. */
+    async handleDequeue() {
+        if (this.hooks.onRequest === undefined) {
+            this.notify("Restoring queued messages isn't available in this viewer");
+            return;
+        }
+        let reply;
+        try {
+            reply = await this.hooks.onRequest({ type: 'dequeue' });
+        }
+        catch (err) {
+            this.notify(`Could not restore queued messages: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        if (reply.kind !== 'dequeue') {
+            this.notify('Unexpected reply restoring queued messages');
+            return;
+        }
+        const queued = [...reply.steering, ...reply.followUp];
+        if (queued.length === 0) {
+            this.notify('No queued messages to restore');
+            return;
+        }
+        const combined = [queued.join('\n\n'), this.editor.getText()].filter((t) => t.trim()).join('\n\n');
+        this.editor.setText(combined);
+        this.tui.requestRender();
+        this.notify(`Restored ${queued.length} queued message${queued.length > 1 ? 's' : ''} to editor`);
+    }
     /** Send a drive frame iff the WHOLE encoded frame fits under MAX_FRAME_BYTES
      *  (the broker destroys the socket on any line over its 24 MiB read cap). Over
      *  the ceiling → notify + refuse so the caller leaves the editor + pending
@@ -162,44 +419,25 @@ export class InputController {
                 this.notify('No image in the clipboard');
                 return;
             }
-            // The clipboard layer read an image but DROPPED it (over its per-image
-            // ceiling) — surface the reason and attach nothing.
+            // The clipboard layer read an image but DROPPED it — surface the reason.
             if (!result.image) {
-                this.notify(result.note ?? 'Image not attached');
+                this.notify(result.note ?? 'Image not pasted');
                 return;
             }
-            // Enforce the aggregate pending-image budget so the eventual drained frame
-            // stays under the broker cap: refuse a paste that would breach the count or
-            // byte ceiling rather than accumulate an over-cap images[] (review M2).
-            const bytes = Buffer.byteLength(result.image.data);
-            if (this.pendingImages.length + 1 > MAX_PENDING_IMAGES ||
-                this.pendingImageBytes + bytes > MAX_PENDING_IMAGE_BYTES) {
-                this.notify('Image not attached: pending image budget exceeded — send your message first');
-                return;
-            }
-            this.pendingImages.push(result.image);
-            this.pendingImageBytes += bytes;
-            this.notify(result.note
-                ? `Image attached (${result.note}) — sends with your next message`
-                : 'Image attached — sends with your next message');
+            // Persist to a temp file and splice the PATH into the editor at the caret,
+            // so the agent reads the image off disk instead of relying on inline base64
+            // the viewer can't render.
+            const path = writeClipboardImageToFile(result.image);
+            const cur = this.editor.getText();
+            const sep = cur && !/\s$/.test(cur) ? ' ' : '';
+            this.editor.insertTextAtCursor(`${sep}${path} `);
+            this.notify(result.note ? `Image saved (${result.note}) — path inserted` : 'Image saved — path inserted');
             this.tui.requestRender();
         }
         catch {
             this.notify('Could not read the clipboard image');
         }
     }
-    /** Snapshot the pending images as an `images?` payload (undefined when none)
-     *  WITHOUT clearing — so a frame refused by `emitDrive` (too large) keeps them
-     *  for the user to trim. The caller clears via `clearPendingImages` only after a
-     *  successful send. */
-    pendingImagesPayload() {
-        return this.pendingImages.length === 0 ? undefined : this.pendingImages.slice();
-    }
-    /** Drop all pending images + reset the aggregate byte counter (after a send). */
-    clearPendingImages() {
-        this.pendingImages = [];
-        this.pendingImageBytes = 0;
-    }
     notify(message) {
         this.hooks.onNotice?.(message);
     }

package/dist/clients/attach/pickers.d.ts

@@ -0,0 +1,58 @@
+import { type Component, type KeybindingsManager, type TUI } from '@earendil-works/pi-tui';
+import type { ClientToBroker, GetSettingsData, GetTreeData, ListModelsData, ListScopedModelsData, ListSessionsData } from '../../core/runtime/broker-protocol.js';
+import type { ReadOpRequest } from './view-socket.js';
+/** A built picker overlay: the `component` to show, and the `focus` target the
+ *  caller must `setFocus` (the component itself, or the inner list that owns
+ *  `handleInput`). */
+export interface Picker {
+    component: Component;
+    focus: Component;
+}
+/** Controls handed to a picker builder by InputController.showPicker. `close`
+ *  tears the whole picker down + restores editor focus; `replace` swaps the
+ *  CURRENTLY-mounted component for a new one IN THE SAME inline slot (no centered
+ *  overlay), focusing it — used by multi-step flows like /login, where selecting
+ *  a provider replaces the selector with the login dialog right under the editor. */
+export interface PickerControls {
+    close: () => void;
+    replace: (component: Component, focus: Component) => void;
+}
+/** Send a command frame to the broker (= InputController hooks.onCommand). */
+type Send = (frame: ClientToBroker) => void;
+/** Issue a correlated read-op (lazy loaders need it after construction). */
+type Request = (frame: ReadOpRequest) => Promise<unknown>;
+/** Tear the picker overlay down (owned by InputController). */
+type Close = () => void;
+/** Surface a one-line viewer notice. */
+type Notify = (message: string) => void;
+/** `/model` (and ctrl+l) — the real model selector with search + scope toggle.
+ *  Select → `set_model` with the resolved `provider/id` (the broker's
+ *  `findModelSpec` requires that form). */
+export declare function buildModelPicker(tui: TUI, data: ListModelsData, send: Send, close: Close): Picker;
+/** `/resume` — the real session selector. Reconstructs from async loaders that
+ *  fetch each scope on demand (cwd is pre-fetched so the current-session marker
+ *  shows immediately; the `all` scope loads only on toggle). Select →
+ *  `switch_session`. Rename/delete are out of scope (no command frame). */
+export declare function buildSessionPicker(tui: TUI, prefetchedCwd: ListSessionsData, request: Request, keybindings: KeybindingsManager, send: Send, close: Close): Picker;
+/** `/tree` — the real tree navigator (pure data). Select → `navigate_tree`.
+ *  Label-edit is out of scope (no command frame) → no `onLabelChange`. */
+export declare function buildTreePicker(tui: TUI, data: GetTreeData, send: Send, close: Close): Picker;
+/** `/fork` — the real prior-user-message selector (pure data, from
+ *  `get_tree.forkPoints`). Select → `fork`. The outer component has no
+ *  `handleInput`; the inner `getMessageList()` does (focus target). */
+export declare function buildForkPicker(data: GetTreeData, send: Send, close: Close): Picker;
+/** `/settings` — the real settings menu (the wire `settings` IS a SettingsConfig
+ *  superset). Only the contract-enumerated mutations are wired: thinking level →
+ *  `set_thinking_level`, auto-compact → `set_auto_compaction`. Every other toggle
+ *  has no command frame (out of scope), so its callback notifies rather than
+ *  silently lying that the change took. The theme submenu is viewer-local (CTO).
+ *  The outer component has no `handleInput`; `getSettingsList()` is the focus
+ *  target. */
+export declare function buildSettingsPicker(data: GetSettingsData, send: Send, close: Close, notify: Notify): Picker;
+/** `/scoped-models` — READ-ONLY via a pi-tui SelectList. CONTRACT GAP: pi (through
+ *  0.79.1) does not re-export `ScopedModelsSelectorComponent`, and the contract
+ *  exposes no command frame for its enable/disable/persist mutations, so a
+ *  faithful editable picker is not buildable in scope. This shows the registry
+ *  with the enabled set marked; select notifies that toggling is unsupported. */
+export declare function buildScopedModelsPicker(data: ListScopedModelsData, close: Close, notify: Notify): Picker;
+export {};