@selesai/code 0.13.15 → 0.13.18

package/dist/modes/interactive/components/scoped-models-selector.js

@@ -2,17 +2,21 @@ import { Container, fuzzyFilter, getKeybindings, Input, Key, matchesKey, Spacer,
 import { getModelSearchText } from "../model-search.js";
 import { theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
-import { keyText } from "./keybinding-hints.js";
+import { keyDisplayText } from "./keybinding-hints.js";
 function isEnabled(enabledIds, id) {
     return enabledIds === null || enabledIds.includes(id);
 }
-function toggle(enabledIds, id) {
+/** Collapse an explicit list back to null (= all enabled) when it covers every available model. */
+function normalizeEnabled(result, allIds) {
+    return result.length === allIds.length && result.every((id) => allIds.includes(id)) ? null : result;
+}
+function toggle(enabledIds, allIds, id) {
     if (enabledIds === null)
-        return [id]; // First toggle: start with only this one
+        return allIds.filter((modelId) => modelId !== id);
     const index = enabledIds.indexOf(id);
     if (index >= 0)
         return [...enabledIds.slice(0, index), ...enabledIds.slice(index + 1)];
-    return [...enabledIds, id];
+    return normalizeEnabled([...enabledIds, id], allIds);
 }
 function enableAll(enabledIds, allIds, targetIds) {
     if (enabledIds === null)
@@ -23,7 +27,7 @@ function enableAll(enabledIds, allIds, targetIds) {
         if (!result.includes(id))
             result.push(id);
     }
-    return result.length === allIds.length && result.every((id) => allIds.includes(id)) ? null : result;
+    return normalizeEnabled(result, allIds);
 }
 function clearAll(enabledIds, allIds, targetIds) {
     if (enabledIds === null) {
@@ -91,7 +95,7 @@ export class ScopedModelsSelectorComponent extends Container {
         this.addChild(new DynamicBorder());
         this.addChild(new Spacer(1));
         this.addChild(new Text(theme.fg("accent", theme.bold("Model Configuration")), 0, 0));
-        this.addChild(new Text(theme.fg("muted", `Session-only. ${keyText("app.models.save")} to save to settings.`), 0, 0));
+        this.addChild(new Text(theme.fg("muted", `Session-only. ${keyDisplayText("app.models.save")} to save to settings.`), 0, 0));
         this.addChild(new Spacer(1));
         // Search input
         this.searchInput = new Input();
@@ -122,12 +126,12 @@ export class ScopedModelsSelectorComponent extends Container {
             ? "all enabled"
             : `${enabledCount}/${this.allIds.length} enabled${unavailableCount ? ` · ${unavailableCount} unavailable` : ""}`;
         const parts = [
-            `${keyText("tui.select.confirm")} toggle`,
-            `${keyText("app.models.enableAll")} all`,
-            `${keyText("app.models.clearAll")} clear`,
-            `${keyText("app.models.toggleProvider")} provider`,
-            `${keyText("app.models.reorderUp")}/${keyText("app.models.reorderDown")} reorder`,
-            `${keyText("app.models.save")} save`,
+            `${keyDisplayText("tui.select.confirm")} toggle`,
+            `${keyDisplayText("app.models.enableAll")} all`,
+            `${keyDisplayText("app.models.clearAll")} clear`,
+            `${keyDisplayText("app.models.toggleProvider")} provider`,
+            `${keyDisplayText("app.models.reorderUp")}/${keyDisplayText("app.models.reorderDown")} reorder`,
+            `${keyDisplayText("app.models.save")} save`,
             countText,
         ];
         return this.isDirty
@@ -157,22 +161,16 @@ export class ScopedModelsSelectorComponent extends Container {
         }
         const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredItems.length - this.maxVisible));
         const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
-        const allEnabled = this.enabledIds === null;
         for (let i = startIndex; i < endIndex; i++) {
             const item = this.filteredItems[i];
             const isSelected = i === this.selectedIndex;
             const prefix = isSelected ? theme.fg("accent", "→ ") : "  ";
             const id = item.model?.id ?? item.fullId;
-            const modelText = isSelected ? theme.fg("accent", id) : id;
+            const styledId = item.model ? id : theme.strikethrough(id);
+            const modelText = isSelected ? theme.fg("accent", styledId) : styledId;
             const providerBadge = theme.fg("muted", item.model ? ` [${item.model.provider}]` : " [unavailable]");
-            const status = item.model
-                ? allEnabled
-                    ? ""
-                    : item.enabled
-                        ? theme.fg("success", " ✓")
-                        : theme.fg("dim", " ✗")
-                : theme.fg("dim", " ✗");
-            this.listContainer.addChild(new Text(`${prefix}${modelText}${providerBadge}${status}`, 0, 0));
+            const status = item.model && item.enabled ? theme.fg("accent", "✓ ") : "  ";
+            this.listContainer.addChild(new Text(`${prefix}${status}${modelText}${providerBadge}`, 0, 0));
         }
         // Add scroll indicator if needed
         if (startIndex > 0 || endIndex < this.filteredItems.length) {
@@ -227,7 +225,7 @@ export class ScopedModelsSelectorComponent extends Container {
         if (kb.matches(data, "tui.select.confirm")) {
             const item = this.filteredItems[this.selectedIndex];
             if (item) {
-                this.enabledIds = toggle(this.enabledIds, item.fullId);
+                this.enabledIds = toggle(this.enabledIds, this.allIds, item.fullId);
                 this.isDirty = true;
                 this.refresh();
                 this.notifyChange();

package/dist/modes/interactive/components/settings-selector.d.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { Transport } from "@earendil-works/pi-ai";
+import { type Model, type Transport } from "@earendil-works/pi-ai";
 import { Container, type ScrollViewScrollbar, SettingsList } from "@earendil-works/pi-tui";
 import type { DefaultProjectTrust, FullscreenExitOutput, TuiMode, WarningSettings } from "../../../core/settings-manager.ts";
 import { type TerminalTheme } from "../theme/theme.ts";
@@ -29,6 +29,10 @@ export interface SettingsConfig {
     httpIdleTimeoutMs: number;
     thinkingLevel: ThinkingLevel;
     availableThinkingLevels: ThinkingLevel[];
+    defaultModel: string;
+    currentModel?: Model<any>;
+    availableDefaultModels: readonly Model<any>[];
+    modelThinkingLevels: Record<string, ThinkingLevel>;
     currentTheme: string;
     terminalTheme: TerminalTheme;
     availableThemes: string[];
@@ -67,6 +71,8 @@ export interface SettingsCallbacks {
     onFollowUpModeChange: (mode: "all" | "one-at-a-time") => void;
     onTransportChange: (transport: Transport) => void;
     onHttpIdleTimeoutMsChange: (timeoutMs: number) => void;
+    onModelThinkingLevelChange: (provider: string, modelId: string, level: ThinkingLevel) => void;
+    onModelThinkingLevelRemove: (provider: string, modelId: string) => void;
     onThinkingLevelChange: (level: ThinkingLevel) => void;
     onThemeChange: (theme: string) => void;
     onThemePreview?: (theme: string) => void;

package/dist/modes/interactive/components/settings-selector.js

@@ -1,8 +1,11 @@
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import { Container, getCapabilities, SelectList, SettingsList, Spacer, Text, } from "@earendil-works/pi-tui";
 import { formatHttpIdleTimeoutMs, HTTP_IDLE_TIMEOUT_CHOICES } from "../../../core/http-dispatcher.js";
 import { getSelectListTheme, getSettingsListTheme, parseAutoThemeSetting, theme, } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyDisplayText } from "./keybinding-hints.js";
+import { SteppedSubmenu } from "./settings-submenu.js";
+const MODEL_PICKER_LAYOUT = { minPrimaryColumnWidth: 12, maxPrimaryColumnWidth: 46 };
 const SETTINGS_SUBMENU_SELECT_LIST_LAYOUT = {
     minPrimaryColumnWidth: 12,
     maxPrimaryColumnWidth: 32,
@@ -132,18 +135,21 @@ class SelectSubmenu extends Container {
         this.selectList.handleInput(data);
     }
 }
-function themeItems(availableThemes) {
-    return availableThemes.map((name) => ({ value: name, label: name }));
+function themeItems(availableThemes, currentTheme) {
+    return availableThemes.map((name) => ({
+        value: name,
+        label: `${name === currentTheme ? "✓ " : "  "}${name}`,
+    }));
 }
 const AUTOMATIC_THEME_VALUE = "/";
-function singleModeThemeItems(availableThemes) {
+function singleModeThemeItems(availableThemes, currentTheme) {
     return [
         {
             value: AUTOMATIC_THEME_VALUE,
-            label: "Automatic",
+            label: "  Automatic",
             description: "Use separate themes for light and dark terminal appearance",
         },
-        ...themeItems(availableThemes),
+        ...themeItems(availableThemes, currentTheme),
     ];
 }
 function preferredTheme(availableThemes, preferred, fallback) {
@@ -203,7 +209,7 @@ class ThemeSubmenu extends Container {
     }
     showSingleMenu() {
         this.mode = "single";
-        const menu = new SelectSubmenu("Theme", "Select a theme, or choose Automatic to follow terminal appearance.", singleModeThemeItems(this.availableThemes), this.singleTheme, (value) => {
+        const menu = new SelectSubmenu("Theme", "Select a theme, or choose Automatic to follow terminal appearance.", singleModeThemeItems(this.availableThemes, this.singleTheme), this.singleTheme, (value) => {
             if (value === AUTOMATIC_THEME_VALUE) {
                 this.mode = "automatic";
                 this.callbacks.onThemePreview?.(this.getThemeSetting());
@@ -280,7 +286,7 @@ class ThemeSubmenu extends Container {
         this.setContent(content, settingsList);
     }
     createThemeSelect(title, description, currentValue, done, onSelect) {
-        return new SelectSubmenu(title, description, themeItems(this.availableThemes), currentValue, onSelect, () => {
+        return new SelectSubmenu(title, description, themeItems(this.availableThemes, currentValue), currentValue, onSelect, () => {
             this.callbacks.onThemePreview?.(this.getThemeSetting());
             done();
         }, (value) => this.callbacks.onThemePreview?.(value));
@@ -302,6 +308,22 @@ class ThemeSubmenu extends Container {
         this.onDone();
     }
 }
+const CLEAR_OVERRIDE_VALUE = "__clear__";
+function modelSettingKey(model) {
+    return `${model.provider}/${model.id}`;
+}
+function modelDisplayLabel(model) {
+    return `${model.id} [${model.provider}]`;
+}
+function modelThinkingOverridesSummary(overrides) {
+    const count = Object.keys(overrides).length;
+    if (count === 0)
+        return "none";
+    return `${count} configured`;
+}
+function modelItemLabel(model) {
+    return `${model.id} ${theme.fg("muted", `[${model.provider}]`)}`;
+}
 /**
  * Main settings selector component.
  */
@@ -311,7 +333,12 @@ export class SettingsSelectorComponent extends Container {
         super();
         const supportsImages = getCapabilities().images;
         const followUpKey = keyDisplayText("app.message.followUp");
+        const cycleThinkingKey = keyDisplayText("app.thinking.cycle");
         let currentWarnings = { ...config.warnings };
+        const currentModelThinkingLevels = { ...config.modelThinkingLevels };
+        const defaultModelByValue = new Map(config.availableDefaultModels.map((model) => [modelSettingKey(model), model]));
+        const currentDefaultModelKey = defaultModelByValue.has(config.defaultModel) ? config.defaultModel : undefined;
+        const currentModelKey = config.currentModel ? modelSettingKey(config.currentModel) : undefined;
         let skillsChanged = false;
         const items = [
             {
@@ -373,7 +400,7 @@ export class SettingsSelectorComponent extends Container {
             {
                 id: "cache-miss-notices",
                 label: "Cache miss notices",
-                description: "Show transcript notices for significant prompt-cache misses",
+                description: "Show transcript notices for cache costs and provider recovery diagnostics",
                 currentValue: config.showCacheMissNotices ? "true" : "false",
                 values: ["true", "false"],
             },
@@ -440,18 +467,99 @@ export class SettingsSelectorComponent extends Container {
                 }, () => done()),
             },
             {
-                id: "thinking",
-                label: "Thinking level",
-                description: "Reasoning depth for thinking-capable models",
-                currentValue: config.thinkingLevel,
-                submenu: (currentValue, done) => new SelectSubmenu("Thinking Level", "Select reasoning depth for thinking-capable models", config.availableThinkingLevels.map((level) => ({
-                    value: level,
-                    label: level,
-                    description: THINKING_DESCRIPTIONS[level],
-                })), currentValue, (value) => {
-                    callbacks.onThinkingLevelChange(value);
-                    done(value);
-                }, () => done()),
+                id: "model-thinking",
+                label: "Default thinking level per model",
+                description: `Override the default thinking level for specific models. ${cycleThinkingKey} cycles in-session.`,
+                currentValue: modelThinkingOverridesSummary(currentModelThinkingLevels),
+                submenu: (_currentValue, done) => {
+                    const steps = [
+                        {
+                            key: "model",
+                            title: "Per-Model Thinking Level",
+                            description: "Select a model to configure",
+                            options: () => {
+                                const sorted = [...config.availableDefaultModels].sort((a, b) => {
+                                    const aKey = modelSettingKey(a);
+                                    const bKey = modelSettingKey(b);
+                                    if (aKey === currentModelKey)
+                                        return -1;
+                                    if (bKey === currentModelKey)
+                                        return 1;
+                                    if (aKey === currentDefaultModelKey)
+                                        return -1;
+                                    if (bKey === currentDefaultModelKey)
+                                        return 1;
+                                    return a.provider.localeCompare(b.provider);
+                                });
+                                const items = sorted.map((model) => {
+                                    const key = modelSettingKey(model);
+                                    const override = currentModelThinkingLevels[key];
+                                    return {
+                                        value: key,
+                                        label: modelItemLabel(model),
+                                        description: override ?? undefined,
+                                    };
+                                });
+                                if (items.length === 0) {
+                                    items.push({
+                                        value: "__none__",
+                                        label: "No models available",
+                                        description: "Log in to a provider or configure an API key first",
+                                    });
+                                }
+                                return items;
+                            },
+                            preselect: () => currentModelKey ?? currentDefaultModelKey,
+                            searchable: true,
+                            layout: MODEL_PICKER_LAYOUT,
+                        },
+                        {
+                            key: "level",
+                            title: (ctx) => {
+                                const m = defaultModelByValue.get(ctx.model);
+                                return `Thinking Level for ${m ? modelDisplayLabel(m) : ctx.model}`;
+                            },
+                            description: "Select default thinking level for this model",
+                            options: (ctx) => {
+                                const model = defaultModelByValue.get(ctx.model);
+                                if (!model)
+                                    return [];
+                                const levels = (model.reasoning ? getSupportedThinkingLevels(model) : ["off"]);
+                                const activeLevel = currentModelThinkingLevels[ctx.model];
+                                const items = levels.map((level) => ({
+                                    value: level,
+                                    label: `${level === activeLevel ? "✓ " : "  "}${level}`,
+                                    description: THINKING_DESCRIPTIONS[level],
+                                }));
+                                if (currentModelThinkingLevels[ctx.model] !== undefined) {
+                                    items.push({
+                                        value: CLEAR_OVERRIDE_VALUE,
+                                        label: "  (clear override)",
+                                        description: `Revert to global default (${config.thinkingLevel})`,
+                                    });
+                                }
+                                return items;
+                            },
+                            preselect: (ctx) => currentModelThinkingLevels[ctx.model],
+                        },
+                    ];
+                    const summary = () => modelThinkingOverridesSummary(currentModelThinkingLevels);
+                    return new SteppedSubmenu(steps, (selections) => {
+                        const model = defaultModelByValue.get(selections.model);
+                        if (!model)
+                            return;
+                        if (selections.level === CLEAR_OVERRIDE_VALUE) {
+                            callbacks.onModelThinkingLevelRemove(model.provider, model.id);
+                            delete currentModelThinkingLevels[selections.model];
+                        }
+                        else {
+                            callbacks.onModelThinkingLevelChange(model.provider, model.id, selections.level);
+                            currentModelThinkingLevels[selections.model] = selections.level;
+                        }
+                    }, () => {
+                        done(summary());
+                    }, { loop: true });
+                },
             },
             {
                 id: "tui-mode",

package/dist/modes/interactive/components/settings-submenu.d.ts

@@ -0,0 +1,71 @@
+import { Container, type SelectItem, type SelectListLayoutOptions } from "@earendil-works/pi-tui";
+export interface SelectSubmenuOptions {
+    /** Enable type-to-search fuzzy filtering. */
+    searchable?: boolean;
+    /** Override the select list layout (column widths). */
+    layout?: SelectListLayoutOptions;
+}
+/**
+ * Single-step submenu that shows a titled select list.
+ * With `searchable: true`, typing filters the list using fuzzy matching.
+ */
+export declare class SelectSubmenu extends Container {
+    private selectList;
+    private listChildIndex;
+    private allOptions;
+    private listLayout;
+    private searchInput;
+    private onSelectCb;
+    private onCancelCb;
+    private onSelectionChangeCb?;
+    constructor(title: string, description: string, options: SelectItem[], currentValue: string, onSelect: (value: string) => void, onCancel: () => void, onSelectionChange?: (value: string) => void, submenuOptions?: SelectSubmenuOptions);
+    private buildSelectList;
+    private applyFilter;
+    handleInput(data: string): void;
+}
+/** One step in a {@link SteppedSubmenu}. */
+export interface SteppedSubmenuStep {
+    /** Unique key \u2014 the selected value is stored in the result context under this key. */
+    key: string;
+    /** Title shown at the top of the step. Receives prior selections. */
+    title: string | ((context: Record<string, string>) => string);
+    /** Description shown below the title. Receives prior selections. */
+    description: string | ((context: Record<string, string>) => string);
+    /** Build the option list for this step. Called fresh each time the step is shown. */
+    options: (context: Record<string, string>) => SelectItem[];
+    /** Optionally pre-select a value when entering this step. */
+    preselect?: (context: Record<string, string>) => string | undefined;
+    /** Enable type-to-search fuzzy filtering for this step. */
+    searchable?: boolean;
+    /** Override the select list layout (column widths) for this step. */
+    layout?: SelectListLayoutOptions;
+}
+interface SteppedSubmenuOptions {
+    /** Start at this step index (0-based), skipping earlier steps. Requires initialContext for skipped keys. */
+    startAtStep?: number;
+    /** Pre-fill selections for skipped steps. */
+    initialContext?: Record<string, string>;
+    /** After completing the last step, loop back to step 0 instead of closing. */
+    loop?: boolean;
+}
+/**
+ * Generic N-step submenu built on top of {@link SelectSubmenu}.
+ *
+ * Each step's options can depend on prior selections via the shared context.
+ * Esc goes back one step; Esc at step 0 cancels.
+ * With `loop: true`, completing the final step invokes `onComplete` then returns to step 0.
+ */
+export declare class SteppedSubmenu extends Container {
+    private readonly steps;
+    private readonly onComplete;
+    private readonly onCancel;
+    private readonly opts;
+    private activeComponent;
+    private context;
+    constructor(steps: SteppedSubmenuStep[], onComplete: (context: Record<string, string>) => void, onCancel: () => void, opts?: SteppedSubmenuOptions);
+    private buildStep;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    invalidate(): void;
+}
+export {};

package/dist/modes/interactive/components/settings-submenu.js

@@ -0,0 +1,164 @@
+import { Container, fuzzyFilter, getKeybindings, Input, SelectList, Spacer, Text, } from "@earendil-works/pi-tui";
+import { getSelectListTheme, theme } from "../theme/theme.js";
+const SUBMENU_SELECT_LIST_LAYOUT = {
+    minPrimaryColumnWidth: 12,
+    maxPrimaryColumnWidth: 32,
+};
+/**
+ * Single-step submenu that shows a titled select list.
+ * With `searchable: true`, typing filters the list using fuzzy matching.
+ */
+export class SelectSubmenu extends Container {
+    selectList;
+    listChildIndex;
+    allOptions;
+    listLayout;
+    searchInput;
+    onSelectCb;
+    onCancelCb;
+    onSelectionChangeCb;
+    constructor(title, description, options, currentValue, onSelect, onCancel, onSelectionChange, submenuOptions) {
+        super();
+        this.allOptions = options;
+        this.listLayout = submenuOptions?.layout ?? SUBMENU_SELECT_LIST_LAYOUT;
+        this.onSelectCb = onSelect;
+        this.onCancelCb = onCancel;
+        this.onSelectionChangeCb = onSelectionChange;
+        // Title
+        this.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
+        // Description
+        if (description) {
+            this.addChild(new Spacer(1));
+            this.addChild(new Text(theme.fg("muted", description), 0, 0));
+        }
+        // Search input
+        if (submenuOptions?.searchable) {
+            this.addChild(new Spacer(1));
+            this.searchInput = new Input();
+            this.searchInput.onSubmit = () => {
+                this.selectList.handleInput("\r");
+            };
+            this.addChild(this.searchInput);
+        }
+        // Spacer
+        this.addChild(new Spacer(1));
+        // Select list
+        this.selectList = this.buildSelectList(options, currentValue);
+        this.listChildIndex = this.children.length;
+        this.addChild(this.selectList);
+        // Hint
+        this.addChild(new Spacer(1));
+        const hint = submenuOptions?.searchable
+            ? "  Type to filter \u00b7 Enter to select \u00b7 Esc to go back"
+            : "  Enter to select \u00b7 Esc to go back";
+        this.addChild(new Text(theme.fg("dim", hint), 0, 0));
+    }
+    buildSelectList(options, preselect) {
+        const list = new SelectList(options, Math.min(options.length, 10), getSelectListTheme(), this.listLayout);
+        const idx = options.findIndex((o) => o.value === preselect);
+        if (idx !== -1)
+            list.setSelectedIndex(idx);
+        list.onSelect = (item) => this.onSelectCb(item.value);
+        list.onCancel = this.onCancelCb;
+        if (this.onSelectionChangeCb) {
+            const cb = this.onSelectionChangeCb;
+            list.onSelectionChange = (item) => cb(item.value);
+        }
+        return list;
+    }
+    applyFilter(query) {
+        const filtered = query
+            ? fuzzyFilter(this.allOptions, query, (item) => `${item.label} ${item.description ?? ""}`)
+            : this.allOptions;
+        const newList = this.buildSelectList(filtered, "");
+        this.children[this.listChildIndex] = newList;
+        this.selectList = newList;
+    }
+    handleInput(data) {
+        if (this.searchInput) {
+            const kb = getKeybindings();
+            const isNav = kb.matches(data, "tui.select.up") ||
+                kb.matches(data, "tui.select.down") ||
+                kb.matches(data, "tui.select.confirm") ||
+                kb.matches(data, "tui.select.cancel");
+            if (isNav) {
+                this.selectList.handleInput(data);
+            }
+            else {
+                this.searchInput.handleInput(data);
+                this.applyFilter(this.searchInput.getValue());
+            }
+        }
+        else {
+            this.selectList.handleInput(data);
+        }
+    }
+}
+/**
+ * Generic N-step submenu built on top of {@link SelectSubmenu}.
+ *
+ * Each step's options can depend on prior selections via the shared context.
+ * Esc goes back one step; Esc at step 0 cancels.
+ * With `loop: true`, completing the final step invokes `onComplete` then returns to step 0.
+ */
+export class SteppedSubmenu extends Container {
+    steps;
+    onComplete;
+    onCancel;
+    opts;
+    activeComponent;
+    context;
+    constructor(steps, onComplete, onCancel, opts = {}) {
+        super();
+        this.steps = steps;
+        this.onComplete = onComplete;
+        this.onCancel = onCancel;
+        this.opts = opts;
+        this.context = { ...(opts.initialContext ?? {}) };
+        this.activeComponent = this.buildStep(opts.startAtStep ?? 0);
+    }
+    buildStep(stepIndex) {
+        const step = this.steps[stepIndex];
+        const total = this.steps.length;
+        const stepLabel = total > 1 ? `Step ${stepIndex + 1}/${total} \u00b7 ` : "";
+        const title = typeof step.title === "function" ? step.title(this.context) : step.title;
+        const desc = typeof step.description === "function" ? step.description(this.context) : step.description;
+        const items = step.options(this.context);
+        const preselect = step.preselect?.(this.context) ?? "";
+        return new SelectSubmenu(title, `${stepLabel}${desc}`, items, preselect, (value) => {
+            this.context[step.key] = value;
+            if (stepIndex < total - 1) {
+                // Advance to next step
+                this.activeComponent = this.buildStep(stepIndex + 1);
+            }
+            else {
+                // Final step \u2014 deliver result
+                this.onComplete({ ...this.context });
+                if (this.opts.loop) {
+                    this.context = {};
+                    this.activeComponent = this.buildStep(0);
+                }
+                else {
+                    this.onCancel();
+                }
+            }
+        }, () => {
+            if (stepIndex > 0) {
+                delete this.context[step.key];
+                this.activeComponent = this.buildStep(stepIndex - 1);
+            }
+            else {
+                this.onCancel();
+            }
+        }, undefined, step.searchable || step.layout ? { searchable: step.searchable, layout: step.layout } : undefined);
+    }
+    render(width) {
+        return this.activeComponent.render(width);
+    }
+    handleInput(data) {
+        this.activeComponent.handleInput?.(data);
+    }
+    invalidate() {
+        this.activeComponent.invalidate?.();
+    }
+}

package/dist/modes/interactive/components/status-indicator.d.ts

@@ -7,7 +7,9 @@ export declare class StatusIndicator extends Loader {
     dispose(): void;
 }
 export declare class WorkingStatusIndicator extends StatusIndicator {
-    constructor(ui: TUI, message: string, indicator?: WorkingIndicatorOptions);
+    constructor(ui: TUI, message: string, indicator?: WorkingIndicatorOptions, colorFn?: (text: string) => string);
+    renderInBorder(width: number): string;
+    renderSpinnerInBorder(width: number): string;
 }
 export declare class ImageCaptioningStatusIndicator extends StatusIndicator {
     constructor(ui: TUI);

package/dist/modes/interactive/components/status-indicator.js

@@ -1,4 +1,4 @@
-import { Loader } from "@earendil-works/pi-tui";
+import { Loader, truncateToWidth } from "@earendil-works/pi-tui";
 import { theme } from "../theme/theme.js";
 import { CountdownTimer } from "./countdown-timer.js";
 import { keyText } from "./keybinding-hints.js";
@@ -13,8 +13,15 @@ export class StatusIndicator extends Loader {
     }
 }
 export class WorkingStatusIndicator extends StatusIndicator {
-    constructor(ui, message, indicator) {
-        super("working", ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), message, indicator);
+    constructor(ui, message, indicator, colorFn) {
+        super("working", ui, colorFn ?? ((text) => theme.fg("accent", text)), colorFn ?? ((text) => theme.fg("muted", text)), message, indicator);
+    }
+    renderInBorder(width) {
+        const line = super.render(width + 2)[1] ?? "";
+        return truncateToWidth(line.startsWith(" ") ? line.slice(1).trimEnd() : line.trimEnd(), width, "");
+    }
+    renderSpinnerInBorder(width) {
+        return truncateToWidth(this.getRenderedIndicator(), width, "");
     }
 }
 export class ImageCaptioningStatusIndicator extends StatusIndicator {

package/dist/modes/interactive/components/thinking-selector.d.ts

@@ -1,10 +1,22 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { Container, SelectList } from "@earendil-works/pi-tui";
+import { Container, type Focusable, SelectList } from "@earendil-works/pi-tui";
 /**
  * Component that renders a thinking level selector with borders
  */
-export declare class ThinkingSelectorComponent extends Container {
+export declare class ThinkingSelectorComponent extends Container implements Focusable {
+    private searchInput;
     private selectList;
-    constructor(currentLevel: ThinkingLevel, availableLevels: ThinkingLevel[], onSelect: (level: ThinkingLevel) => void, onCancel: () => void);
+    private selectListChildIndex;
+    private allItems;
+    private onSelect;
+    private onCancel;
+    private onSelectAsDefault?;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(currentLevel: ThinkingLevel, availableLevels: ThinkingLevel[], onSelect: (level: ThinkingLevel) => void, onCancel: () => void, onSelectAsDefault?: (level: ThinkingLevel) => void, defaultThinkingLevel?: ThinkingLevel);
+    private buildSelectList;
+    private applyFilter;
+    handleInput(keyData: string): void;
     getSelectList(): SelectList;
 }