pi-advisor-flow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Philip Brembeck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# pi-advisor
+
+An on-demand Advisor model flow for autonomous **Pi** coding agents.
+
+This extension introduces a strategic "Executor/Advisor" workflow, inspired by Claudes [Advisor](https://code.claude.com/docs/en/advisor).
+
+The primary agent (the Executor) acts, writes code, and executes tools. Whenever the Executor encounters high risk, ambiguity, or potential loops, it MUST escalate the scenario to a smarter, second-opinion LLM (the Advisor) for strategic guidance.
+
+[Read more about it here](https://philipbrembeck.com/writings/2026/07/blog/2026/07/only-as-much-intelligence-as-you-need).
+
+## Installation
+
+Install the package directly into your global Pi agent environment:
+
+### From NPM
+
+```bash
+pi install npm:pi-advisor-flow
+```
+
+### From Git
+
+```bash
+pi install git:github.com/philipbrembeck/pi-advisor.git
+```
+
+### From Local Folder (For Development)
+
+```bash
+pi install /path/to/pi-advisor
+```
+
+## Usage & Commands
+
+Once installed, the following commands are available inside the Pi terminal:
+
+### `/advisor`
+
+Enables the Advisor flow. Switches the primary model to the configured Executor model and registers the `ask_advisor` tool.
+
+- _Example:_ `/advisor executor=anthropic/claude-sonnet-5 advisor=openai/gpt-5.6-sol`
+
+### `/advisor-models`
+
+Opens an interactive, scrollable fuzzy-search picker in the TUI to choose:
+
+1. Executor Model & Reasoning Effort
+2. Advisor Model & Reasoning Effort
+
+Saves and persists your configuration to `~/.pi/agent/advisor.json`.
+
+### `/advisor-off`
+
+Disables the Advisor flow, removing the `ask_advisor` tool from the active session.
+
+## Local Development
+
+`pi-advisor` uses Bun for rapid testing and TypeScript. Standard commands apply:
+
+### 1. Clone the repository
+
+```bash
+git clone git@github.com:philipbrembeck/pi-advisor.git
+cd pi-advisor
+```
+
+### 2. Install dependencies
+
+```bash
+bun install
+```
+
+### 3. Run type-checks & tests
+
+Verify code-splitting correctness and registration logic:
+
+```bash
+bun test            # Run unit tests
+npm run typecheck   # Perform strict TS checks
+```

package/extensions/index.ts

@@ -0,0 +1,8 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerAdvisorTool } from "../src/tools.js";
+import { registerCommands } from "../src/commands.js";
+
+export default function (pi: ExtensionAPI) {
+  registerAdvisorTool(pi);
+  registerCommands(pi);
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "pi-advisor-flow",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/philipbrembeck/pi-advisor.git"
+  },
+  "description": "Executor/Advisor flow for autonomous pi coding agents",
+  "type": "module",
+  "main": "extensions/index.ts",
+  "types": "extensions/index.ts",
+  "keywords": [
+    "pi-package"
+  ],
+  "files": [
+    "extensions",
+    "src",
+    "README.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/index.ts"
+    ]
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "^0.80.7",
+    "@earendil-works/pi-coding-agent": "^0.80.7",
+    "@earendil-works/pi-tui": "^0.80.7",
+    "typebox": "^1.1.38"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "^0.80.7",
+    "@earendil-works/pi-coding-agent": "^0.80.7",
+    "@earendil-works/pi-tui": "^0.80.7",
+    "typebox": "^1.1.38",
+    "@types/node": "^20.11.0",
+    "bun-types": "^1.0.0",
+    "typescript": "^5.3.3"
+  }
+}

package/src/commands.ts

@@ -0,0 +1,70 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  advisorRef, advisorEffortRef, executorRef, executorEffortRef,
+  setAdvisorRef, setAdvisorEffortRef, setExecutorRef, setExecutorEffortRef,
+  loadConfig, saveConfig, parseArgs, splitRef,
+} from "./config.js";
+import { SearchableModelSelector } from "./ui.js";
+
+const EFFORT_LEVELS = ["Default (Model Default)", "off", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+export const registerCommands = (pi: ExtensionAPI) => {
+  const flowEnabled = () => pi.getActiveTools().includes("ask_advisor");
+
+  pi.registerCommand("advisor", {
+    description: "Enable the Executor/Advisor flow and switch to the configured Executor model",
+    handler: async (args, ctx) => {
+      loadConfig(ctx);
+      parseArgs(args);
+      const [provider, modelId] = splitRef(executorRef);
+      const executor = ctx.modelRegistry.find(provider, modelId);
+      if (!executor) return ctx.hasUI ? ctx.ui.notify(`Executor model not found: ${executorRef}`, "error") : undefined;
+      const [ap, am] = splitRef(advisorRef);
+      if (!ctx.modelRegistry.find(ap, am)) return ctx.hasUI ? ctx.ui.notify(`Advisor model not found: ${advisorRef}`, "error") : undefined;
+      if (!(await pi.setModel(executor))) return ctx.hasUI ? ctx.ui.notify(`No API key for Executor ${executorRef}`, "error") : undefined;
+      if (executorEffortRef) pi.setThinkingLevel(executorEffortRef as any);
+      if (!flowEnabled()) pi.setActiveTools([...pi.getActiveTools(), "ask_advisor"]);
+      if (ctx.hasUI) ctx.ui.notify(`Advisor flow ready — Executor: ${executorRef} (thinking: ${executorEffortRef || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`, "info");
+    },
+  });
+
+  pi.registerCommand("advisor-models", {
+    description: "Select and persist the Executor and Advisor models with reasoning levels",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return;
+      const refs = ctx.modelRegistry.getAvailable().map((m) => `${m.provider}/${m.id}`);
+
+      const executor = await ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) =>
+        new SearchableModelSelector({ tui, title: "Select Executor Model", allOptions: refs, theme, keybindings, onSelect: done, onCancel: () => done(undefined) })
+      );
+      if (!executor) return;
+
+      const executorEffort = await ctx.ui.select("Select Executor Reasoning/Thinking Level", EFFORT_LEVELS);
+      if (!executorEffort) return;
+
+      const advisor = await ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) =>
+        new SearchableModelSelector({ tui, title: "Select Advisor Model", allOptions: refs, theme, keybindings, onSelect: done, onCancel: () => done(undefined) })
+      );
+      if (!advisor) return;
+
+      const advisorEffort = await ctx.ui.select("Select Advisor Reasoning/Thinking Level", EFFORT_LEVELS);
+      if (!advisorEffort) return;
+
+      setExecutorRef(executor);
+      setAdvisorRef(advisor);
+      setExecutorEffortRef(executorEffort === "Default (Model Default)" ? undefined : executorEffort);
+      setAdvisorEffortRef(advisorEffort === "Default (Model Default)" ? undefined : advisorEffort);
+
+      const path = saveConfig(ctx);
+      ctx.ui.notify(`Saved Executor + Advisor configurations to ${path}`, "info");
+    },
+  });
+
+  pi.registerCommand("advisor-off", {
+    description: "Disable on-demand Advisor calls; keep the current model",
+    handler: async (_args, ctx) => {
+      pi.setActiveTools(pi.getActiveTools().filter((name) => name !== "ask_advisor"));
+      if (ctx.hasUI) ctx.ui.notify("Advisor flow disabled. Current model unchanged.", "info");
+    },
+  });
+};

package/src/config.ts

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME, type ExtensionContext, getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export const FALLBACK_EXECUTOR = "aikeys/claude-sonnet-5";
+export const FALLBACK_ADVISOR = "aikeys/claude-fable-5";
+
+export let executorRef = FALLBACK_EXECUTOR;
+export let advisorRef = FALLBACK_ADVISOR;
+export let executorEffortRef: string | undefined = undefined;
+export let advisorEffortRef: string | undefined = undefined;
+
+export const setExecutorRef = (ref: string) => { executorRef = ref; };
+export const setAdvisorRef = (ref: string) => { advisorRef = ref; };
+export const setExecutorEffortRef = (effort: string | undefined) => { executorEffortRef = effort; };
+export const setAdvisorEffortRef = (effort: string | undefined) => { advisorEffortRef = effort; };
+
+export const splitRef = (ref: string): [string, string] => {
+  const i = ref.indexOf("/");
+  return i === -1 ? ["aikeys", ref] : [ref.slice(0, i), ref.slice(i + 1)];
+};
+
+export const configPaths = (ctx: ExtensionContext) => [
+  ctx.isProjectTrusted() ? join(ctx.cwd, CONFIG_DIR_NAME, "advisor.json") : null,
+  join(getAgentDir(), "advisor.json"),
+];
+
+export const loadConfig = (ctx: ExtensionContext) => {
+  executorRef = FALLBACK_EXECUTOR;
+  advisorRef = FALLBACK_ADVISOR;
+  executorEffortRef = undefined;
+  advisorEffortRef = undefined;
+  for (const path of configPaths(ctx)) {
+    if (!path || !existsSync(path)) continue;
+    try {
+      const config = JSON.parse(readFileSync(path, "utf8")) as {
+        executor?: string;
+        advisor?: string;
+        executorEffort?: string;
+        advisorEffort?: string;
+      };
+      if (config.executor) executorRef = config.executor;
+      if (config.advisor) advisorRef = config.advisor;
+      if (config.executorEffort) executorEffortRef = config.executorEffort;
+      if (config.advisorEffort) advisorEffortRef = config.advisorEffort;
+      return path;
+    } catch {
+      // Ignore malformed config and keep looking for a valid fallback.
+    }
+  }
+  return null;
+};
+
+export const saveConfig = (ctx: ExtensionContext) => {
+  const project = join(ctx.cwd, CONFIG_DIR_NAME, "advisor.json");
+  const path = ctx.isProjectTrusted() && existsSync(project) ? project : join(getAgentDir(), "advisor.json");
+  const data = {
+    executor: executorRef,
+    advisor: advisorRef,
+    executorEffort: executorEffortRef,
+    advisorEffort: advisorEffortRef,
+  };
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+  return path;
+};
+
+export const parseArgs = (args: string) => {
+  for (const token of args.trim().split(/\s+/).filter(Boolean)) {
+    const [key, value] = token.split("=");
+    if (key === "executor" && value) executorRef = value;
+    if (key === "advisor" && value) advisorRef = value;
+  }
+};

package/src/conversation.ts

@@ -0,0 +1,52 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const textFrom = (content: unknown): string => {
+  return (typeof content === "string" ? [content] : Array.isArray(content) ? content : [])
+    .map((part: unknown) =>
+      typeof part === "string"
+        ? part
+        : (part as { type?: string; text?: string })?.type === "text"
+        ? (part as { text?: string }).text ?? ""
+        : ""
+    )
+    .join("\n")
+    .trim();
+};
+
+export const recentConversation = (ctx: ExtensionContext, maxChars = 15000): string => {
+  const entries: string[] = [];
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry.type === "message") {
+      const msg = entry.message;
+      if (msg.role === "user") {
+        const text = textFrom(msg.content);
+        if (text) entries.push(`User: ${text}`);
+      } else if (msg.role === "assistant") {
+        const parts: string[] = [];
+        const text = textFrom(msg.content);
+        if (text) parts.push(text);
+        if (Array.isArray(msg.content)) {
+          for (const part of msg.content) {
+            if (part && typeof part === "object" && part.type === "toolCall") {
+              const tc = part as { name?: string; arguments?: unknown };
+              const argsStr = JSON.stringify(tc.arguments);
+              parts.push(`[Tool Call: ${tc.name}(${argsStr})]`);
+            }
+          }
+        }
+        if (parts.length > 0) {
+          entries.push(`Executor: ${parts.join("\n")}`);
+        }
+      } else if (msg.role === "toolResult" || (msg as any).role === "tool") {
+        const tr = msg as { toolName?: string; isError?: boolean; content?: unknown };
+        const text = textFrom(tr.content);
+        const status = tr.isError ? "Error " : "";
+        entries.push(`[Tool Result for ${tr.toolName || "unknown"}] (${status}output):\n${text}`);
+      }
+    } else if (entry.type === "compaction") {
+      entries.push(`[System Compaction Summary]: ${entry.summary}`);
+    }
+  }
+  const joined = entries.join("\n\n");
+  return joined.length > maxChars ? joined.slice(-maxChars) : joined;
+};

package/src/tools.ts

@@ -0,0 +1,141 @@
+import { stream, type Message, type AssistantMessage } from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Box, Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { advisorRef, advisorEffortRef, loadConfig, splitRef } from "./config.js";
+import { recentConversation, textFrom } from "./conversation.js";
+
+export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export const ADVISOR_SYSTEM = [
+  "You are the Advisor: a senior engineer consulted by an autonomous coding agent.",
+  "You do not act — you advise. Give concise, high-signal guidance: identify risks,",
+  "the smallest correct next step, and wrong assumptions. No preamble.",
+].join(" ");
+
+export const consult = async (
+  ctx: ExtensionContext,
+  question: string,
+  signal?: AbortSignal,
+  onChunk?: (thinking: string, text: string) => void,
+) => {
+  loadConfig(ctx);
+  const [provider, modelId] = splitRef(advisorRef);
+  const model = ctx.modelRegistry.find(provider, modelId);
+  if (!model) throw new Error(`Advisor model not found: ${advisorRef}`);
+  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth.ok) throw new Error((auth as { error: string }).error);
+  if (!auth.apiKey) throw new Error(`No API key for ${advisorRef}`);
+
+  const conversation = recentConversation(ctx);
+  const messages: Message[] = [{
+    role: "user",
+    content: [{ type: "text", text: `${conversation ? `<conversation>\n${conversation}\n</conversation>\n\n` : ""}Question from the Executor:\n${question}` }],
+    timestamp: Date.now(),
+  }];
+
+  let thinkingText = "";
+  let responseText = "";
+
+  const eventStream = stream(model, { systemPrompt: ADVISOR_SYSTEM, messages }, {
+    apiKey: auth.apiKey,
+    headers: auth.headers,
+    env: auth.env,
+    signal,
+    reasoning: advisorEffortRef as any,
+  });
+
+  for await (const event of eventStream) {
+    if (event.type === "thinking_delta") {
+      thinkingText += event.delta;
+      onChunk?.(thinkingText, responseText);
+    } else if (event.type === "text_delta") {
+      responseText += event.delta;
+      onChunk?.(thinkingText, responseText);
+    }
+  }
+
+  const response = await eventStream.result();
+  const lastAssistant = [response].find((m): m is AssistantMessage => m.role === "assistant");
+  const advice = lastAssistant?.content
+    .filter((part): part is { type: "text"; text: string } => part.type === "text")
+    .map((part) => part.text)
+    .join("\n")
+    .trim() || responseText;
+
+  if (!advice) throw new Error("Advisor returned no advice.");
+  return { advice, thinkingText };
+};
+
+export const registerAdvisorTool = (pi: ExtensionAPI) => {
+  pi.registerTool({
+    name: "ask_advisor",
+    label: "Ask Advisor",
+    description: "Consult the on-demand Advisor model for strategic guidance, a second opinion, or a sanity check.",
+    promptSnippet: "Consult the Advisor model for a second opinion",
+    promptGuidelines: [
+      "You MUST call `ask_advisor` in each of these scenarios:",
+      "1. PLAN GATE: You MUST call `ask_advisor` BEFORE selecting or implementing a plan when multiple materially different approaches exist, requirements are ambiguous, or the decision has architectural, security, data-loss, compatibility, or difficult-to-reverse consequences.",
+      "2. FAILURE GATE: You MUST call `ask_advisor` after two consecutive materially equivalent failed attempts, when an attempted fix recreates an earlier failure, or when two consecutive actions produce no measurable progress. Do NOT attempt another materially equivalent fix before consulting.",
+      "3. COMPLETION GATE: You MUST call `ask_advisor` with the goal, changed files, key decisions, tests performed, results, and remaining risks BEFORE declaring success or calling `goal_complete`. You MAY skip this only for demonstrably trivial, low-risk work with no meaningful trade-offs or failures.",
+      "Do NOT use `ask_advisor` for routine decisions outside these three gates.",
+    ],
+    parameters: Type.Object({ question: Type.String({ description: "The specific question or decision to get advice on." }) }),
+    renderShell: "self",
+    renderCall(args, theme, context) {
+      const box = context.lastComponent instanceof Box ? context.lastComponent : new Box(1, 1);
+      box.setBgFn((text) => `\x1b[48;2;25;32;45m${text}\x1b[0m`);
+      box.clear();
+      if (!context.state.timerId) {
+        context.state.timerId = setInterval(() => context.invalidate(), 80);
+      }
+      const frame = SPINNER_FRAMES[Math.floor(Date.now() / 80) % SPINNER_FRAMES.length];
+      box.addChild(new Text(`${theme.fg("warning", theme.bold(`◆ ADVISOR ${frame}`))} ${theme.fg("dim", `· ${args.question}`)}`, 0, 0));
+      return box;
+    },
+    renderResult(result, { isPartial }, theme, context) {
+      const box = context.lastComponent instanceof Box ? context.lastComponent : new Box(1, 1);
+      box.setBgFn((text) => `\x1b[48;2;25;32;45m${text}\x1b[0m`);
+      box.clear();
+      if (isPartial) {
+        if (!context.state.timerId) {
+          context.state.timerId = setInterval(() => context.invalidate(), 80);
+        }
+        const frame = SPINNER_FRAMES[Math.floor(Date.now() / 80) % SPINNER_FRAMES.length];
+        const d = result.details as { thinking?: string; text?: string } | undefined;
+        const lines: string[] = [`${theme.fg("warning", theme.bold(`◆ ADVISOR ${frame}`))} ${theme.fg("dim", "· Working…")}`];
+        if (d?.thinking) {
+          const snippet = d.thinking.length > 200 ? d.thinking.slice(-200) : d.thinking;
+          lines.push(theme.fg("thinkingText", `  💭 ${snippet.replace(/\n/g, " ")}`));
+        }
+        if (d?.text) lines.push(theme.fg("text", d.text));
+        box.addChild(new Text(lines.join("\n"), 0, 0));
+      } else {
+        if (context.state.timerId) {
+          clearInterval(context.state.timerId);
+          delete context.state.timerId;
+        }
+        const d = result.details as { thinking?: string; text?: string } | undefined;
+        const lines: string[] = [theme.fg("warning", theme.bold("◆ ADVISOR"))];
+        if (d?.thinking) {
+          lines.push(theme.fg("thinkingText", `  💭 ${d.thinking.replace(/\n/g, " ").slice(0, 300)}${d.thinking.length > 300 ? "…" : ""}`));
+        }
+        lines.push(textFrom(result.content) || "(Advisor returned no advice.)");
+        box.addChild(new Text(lines.join("\n"), 0, 0));
+      }
+      return box;
+    },
+    async execute(_id, params, signal, onUpdate, ctx) {
+      const { advice, thinkingText } = await consult(ctx, params.question, signal, (t, tx) => {
+        onUpdate?.({
+          content: [{ type: "text", text: tx }],
+          details: { thinking: t, text: tx, advisor: advisorRef, question: params.question },
+        });
+      });
+      return {
+        content: [{ type: "text", text: `Advisor (${advisorRef})\n\n${advice}` }],
+        details: { thinking: thinkingText, text: advice, advisor: advisorRef, question: params.question },
+      };
+    },
+  });
+};

package/src/ui.ts

@@ -0,0 +1,95 @@
+import { Input, fuzzyFilter, type Component, type Focusable } from "@earendil-works/pi-tui";
+import { Box, Text } from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+
+export class SearchableModelSelector implements Component, Focusable {
+  private tui: any;
+  private searchInput: Input;
+  private allOptions: string[];
+  private filteredOptions: string[];
+  private selectedIndex = 0;
+  private title: string;
+  private onSelect: (value: string) => void;
+  private onCancel: () => void;
+  private theme: Theme;
+  private keybindings: any;
+  private _focused = false;
+
+  public get focused(): boolean { return this._focused; }
+  public set focused(val: boolean) {
+    this._focused = val;
+    this.searchInput.focused = val;
+  }
+
+  constructor(options: {
+    tui: any;
+    title: string;
+    allOptions: string[];
+    theme: Theme;
+    keybindings: any;
+    onSelect: (value: string) => void;
+    onCancel: () => void;
+  }) {
+    this.tui = options.tui;
+    this.title = options.title;
+    this.allOptions = options.allOptions;
+    this.theme = options.theme;
+    this.keybindings = options.keybindings;
+    this.onSelect = options.onSelect;
+    this.onCancel = options.onCancel;
+    this.searchInput = new Input();
+    this.filteredOptions = this.allOptions;
+  }
+
+  invalidate(): void { this.searchInput.invalidate(); }
+
+  render(width: number): string[] {
+    const lines: string[] = ["═".repeat(width)];
+    lines.push(`  ${this.theme.fg("accent", this.theme.bold(this.title))}`);
+    const inputLines = this.searchInput.render(width - 12);
+    lines.push(`  ${this.theme.fg("accent", "Search: ")}${inputLines[0] || ""}`);
+    lines.push("");
+
+    const query = this.searchInput.getValue().trim();
+    this.filteredOptions = query ? fuzzyFilter(this.allOptions, query, (item) => item) : this.allOptions;
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredOptions.length - 1));
+
+    const maxVisible = 10;
+    const total = this.filteredOptions.length;
+    if (total === 0) {
+      lines.push("  " + this.theme.fg("muted", "No matching models found."));
+    } else {
+      const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), total - maxVisible));
+      const endIndex = Math.min(startIndex + maxVisible, total);
+      for (let i = startIndex; i < endIndex; i++) {
+        const item = this.filteredOptions[i];
+        if (i === this.selectedIndex) lines.push(`  ${this.theme.fg("accent", "→ ")}${this.theme.fg("accent", item)}`);
+        else lines.push(`    ${this.theme.fg("text", item)}`);
+      }
+      if (total > maxVisible) lines.push("  " + this.theme.fg("muted", `  (${this.selectedIndex + 1}/${total})`));
+    }
+    lines.push("");
+    lines.push(`  ${this.theme.fg("muted", "Type to search · ↑↓: navigate · Enter: select · Esc: cancel")}`);
+    lines.push("═".repeat(width));
+    return lines;
+  }
+
+  handleInput(keyData: string): void {
+    const kb = this.keybindings;
+    if (kb.matches(keyData, "tui.select.up") || keyData === "\u001b[A") {
+      if (this.filteredOptions.length > 0) this.selectedIndex = this.selectedIndex === 0 ? this.filteredOptions.length - 1 : this.selectedIndex - 1;
+      this.tui.requestRender();
+    } else if (kb.matches(keyData, "tui.select.down") || keyData === "\u001b[B") {
+      if (this.filteredOptions.length > 0) this.selectedIndex = this.selectedIndex === this.filteredOptions.length - 1 ? 0 : this.selectedIndex + 1;
+      this.tui.requestRender();
+    } else if (kb.matches(keyData, "tui.select.confirm") || keyData === "\n" || keyData === "\r") {
+      if (this.filteredOptions.length > 0) this.onSelect(this.filteredOptions[this.selectedIndex]);
+    } else if (kb.matches(keyData, "tui.select.cancel") || keyData === "\u001b") {
+      this.onCancel();
+    } else {
+      this.searchInput.handleInput(keyData);
+      this.selectedIndex = 0;
+      this.tui.requestRender();
+    }
+  }
+}