@oh-my-pi/pi-tui 18.2.4 → 18.2.5

package/src/overlays/model-picker.ts

@@ -0,0 +1,285 @@
+/**
+ * Compact session-model picker (alt+p / `/switch`): a bottom-anchored
+ * floating overlay hosting just a {@link ModelBrowser} — no provider sidebar.
+ * Model entries switch the current session only; a search beginning with `@`
+ * exposes the configured ctrl+p quick roles.
+ */
+import type { Model } from "@oh-my-pi/pi-ai";
+import { addKeyAliases, canonicalKeyId } from "../keybindings";
+import { type KeyId, parseKey } from "../keys";
+import type { Component, TUI } from "../tui";
+import { type ThemeColor, theme } from "../theme/theme";
+import { buildSessionModelScope, ModelBrowser, type ModelBrowserItem } from "./model-browser";
+import type { ModelBrowserRegistry, ModelBrowserSource } from "./model-browser";
+import type { ConfiguredThinkingLevel } from "../thinking";
+import type { ScopedModelItem } from "./model-hub";
+import { bottomBorder, row, topBorder } from "../chrome/overlay-box";
+import { resolveSegmentPalette } from "../chrome/segment-track";
+
+/** Configured role resolved to a concrete model. */
+export interface ResolvedRoleModel {
+	role: string;
+	model: Model;
+	thinkingLevel?: ConfiguredThinkingLevel;
+	explicitThinkingLevel: boolean;
+}
+
+/** Catalog refresh capability used by the session picker. */
+export interface ModelPickerRegistry extends ModelBrowserRegistry {
+	refresh(strategy: "offline"): Promise<void>;
+}
+
+export interface ModelPickerCallbacks {
+	/**
+	 * A model was chosen for a session-only switch. `selector` is `provider/id`.
+	 * `overContext` is true when the session transcript exceeds the model's
+	 * context window — the host must compact before switching.
+	 */
+	onPick: (model: Model, selector: string, meta: { overContext: boolean }) => void;
+	/** A configured ctrl+p quick role was chosen. */
+	onPickRole?: (entry: ResolvedRoleModel) => void;
+	/**
+	 * A model was chosen for Task subagents (task mode, toggled by pressing the
+	 * picker shortcut again). Session-only: the host applies a runtime override.
+	 */
+	onPickTask?: (model: Model, selector: string) => void;
+	/** The picker was dismissed. */
+	onCancel: () => void;
+}
+
+export interface ModelPickerOptions {
+	/** Session token count; models with smaller context windows are grayed and compact-first on pick. */
+	currentContextTokens?: number;
+	/** `provider/id` of the session's active model; highlighted and preselected. */
+	currentSelector?: string;
+	/** Resolved role models in the same order used by the ctrl+p quick-role cycle. */
+	quickRoles?: ReadonlyArray<ResolvedRoleModel>;
+	/** Complete ctrl+p order, including unavailable roles, to preserve segment colors. */
+	quickRoleOrder?: ReadonlyArray<string>;
+	/** Active quick role, highlighted when the search begins with `@`. */
+	currentQuickRole?: string;
+	/** Keys that toggle task-subagent mode while the picker is open; typically the alt+p binding. */
+	taskModeKeys?: readonly KeyId[];
+	/** Human-readable label for the toggle key, shown in footer hints (e.g. "alt+p"). */
+	taskModeKeyLabel?: string;
+	/** `provider/id` highlighted and preselected in task mode (current Task subagent model). */
+	taskSelector?: string;
+}
+
+/** Fixed chrome rows: top border, status row, footer, bottom border. */
+const CHROME_ROWS = 4;
+/** Rows the browser renders around its list window (search + blank, blank + two detail rows). */
+export const BROWSER_FRAME_ROWS = 5;
+/** Minimum rows for the browser list window on short terminals. */
+const MIN_VISIBLE = 5;
+/** Fraction of the terminal height the floating overlay occupies. */
+const HEIGHT_FRACTION = 0.4;
+
+const STATUS_HINT = "Session-only switch — role models stay unchanged";
+const QUICK_ROLE_STATUS_HINT = "Quick role switch — applies its model and thinking for this session";
+const TASK_STATUS_HINT = "Task subagent switch — spawned task agents use this model (session-only)";
+const FOOTER_HINT = "↑/↓ models · Enter use for this session · type to search · @ quick roles · Esc close";
+const QUICK_ROLE_FOOTER_HINT = "↑/↓ roles · Enter apply role model · type to search · Esc close";
+const TASK_FOOTER_HINT = "↑/↓ models · Enter use for Task subagents · type to search · Esc close";
+
+/**
+ * The alt+p picker component. Hosted as a non-fullscreen bottom-anchored
+ * overlay (`ui.showOverlay(..., { anchor: "bottom-center" })`); keyboard-only,
+ * since mouse tracking is reserved for fullscreen overlays.
+ */
+export class ModelPickerComponent implements Component {
+	#tui: TUI;
+	#settings: ModelBrowserSource;
+	#registry: ModelPickerRegistry;
+	#scopedModels: ReadonlyArray<ScopedModelItem>;
+	#browser: ModelBrowser;
+	#configError: string | undefined;
+	#currentSelector: string | undefined;
+	#currentQuickRoleSelector: string | undefined;
+	#modelItems: ModelBrowserItem[] = [];
+	#quickRoleItems: ModelBrowserItem[] = [];
+	#quickRoles = new Map<string, ResolvedRoleModel>();
+	#roleMode = false;
+	#taskMode = false;
+	#taskMatchKeys = new Set<string>();
+	#taskModeKeyLabel: string;
+	#taskSelector: string | undefined;
+
+	constructor(
+		tui: TUI,
+		settings: ModelBrowserSource,
+		registry: ModelPickerRegistry,
+		scopedModels: ReadonlyArray<ScopedModelItem>,
+		callbacks: ModelPickerCallbacks,
+		options: ModelPickerOptions = {},
+	) {
+		this.#tui = tui;
+		this.#settings = settings;
+		this.#registry = registry;
+		this.#scopedModels = scopedModels;
+		this.#currentSelector = options.currentSelector;
+		this.#currentQuickRoleSelector = options.currentQuickRole ? `@${options.currentQuickRole}` : undefined;
+		this.#taskSelector = options.taskSelector;
+		this.#taskModeKeyLabel = options.taskModeKeyLabel ?? "alt+p";
+		if (callbacks.onPickTask) {
+			for (const key of options.taskModeKeys ?? []) addKeyAliases(this.#taskMatchKeys, key);
+		}
+		this.#quickRoleItems = this.#buildQuickRoleItems(
+			options.quickRoles ?? [],
+			options.quickRoleOrder ?? options.quickRoles?.map(entry => entry.role) ?? [],
+		);
+
+		this.#browser = new ModelBrowser(settings, {
+			currentContextTokens: options.currentContextTokens,
+			markOverContext: true,
+			emptyText: () => (this.#roleMode ? "  No quick roles in the Ctrl+P cycle" : undefined),
+		});
+		this.#browser.onActivate = item => {
+			const quickRole = this.#quickRoles.get(item.selector);
+			if (quickRole) {
+				callbacks.onPickRole?.(quickRole);
+				return;
+			}
+			if (this.#taskMode) {
+				callbacks.onPickTask?.(item.model, item.selector);
+				return;
+			}
+			callbacks.onPick(item.model, item.selector, { overContext: this.#browser.isOverContext(item) });
+		};
+		this.#browser.onCancel = () => callbacks.onCancel();
+		this.#browser.onQueryChange = query => this.#syncItemsForQuery(query);
+
+		// Hydrate synchronously from the current registry snapshot so the first
+		// Enter after opening acts on cached models instead of being dropped
+		// while the offline refresh promise is still pending.
+		this.#syncFromRegistryState();
+		if (options.currentSelector) {
+			this.#browser.selectSelector(options.currentSelector);
+		}
+
+		// Reconcile with cached discovery state in the background. A --models
+		// scope is registry-independent, so the offline reload would only repeat
+		// the synchronous hydration above.
+		if (this.#scopedModels.length === 0) {
+			this.#registry
+				.refresh("offline")
+				.then(() => this.#syncFromRegistryState())
+				.catch(error => {
+					this.#configError = error instanceof Error ? error.message : String(error);
+				})
+				.finally(() => this.#tui.requestRender());
+		}
+	}
+
+	invalidate(): void {}
+
+	/** Rebuild model items and role chips from the registry's in-memory state. */
+	#syncFromRegistryState(): void {
+		const scope = buildSessionModelScope(
+			this.#settings,
+			this.#registry,
+			this.#scopedModels.map(s => s.model),
+		);
+		this.#configError = scope.error;
+		this.#modelItems = scope.items;
+		this.#browser.setRoles(scope.roles);
+		this.#browser.setMruOrder(scope.mruOrder);
+		this.#browser.setPerfStats(this.#settings.modelPerf);
+		this.#syncItemsForQuery(this.#browser.query, true);
+	}
+
+	/** Build virtual `@role` rows, colored by their ctrl+p segment position. */
+	#buildQuickRoleItems(
+		quickRoles: ReadonlyArray<ResolvedRoleModel>,
+		quickRoleOrder: ReadonlyArray<string>,
+	): ModelBrowserItem[] {
+		const order = quickRoleOrder.length > 0 ? quickRoleOrder : quickRoles.map(entry => entry.role);
+		const palette = resolveSegmentPalette(order.length);
+		return quickRoles.map((entry, index) => {
+			const selector = `@${entry.role}`;
+			this.#quickRoles.set(selector, entry);
+			const orderIndex = order.indexOf(entry.role);
+			return {
+				provider: "",
+				id: selector,
+				model: entry.model,
+				selector,
+				labelColor: palette[(orderIndex >= 0 ? orderIndex : index) % palette.length],
+			};
+		});
+	}
+
+	/** Switch browser content only when a leading `@` changes the search mode. */
+	#syncItemsForQuery(query: string, refresh = false): void {
+		const roleMode = query.startsWith("@") && !this.#taskMode;
+		const modeChanged = roleMode !== this.#roleMode;
+		if (!modeChanged && !refresh) return;
+
+		this.#roleMode = roleMode;
+		this.#browser.setShowProvider(!roleMode);
+		this.#browser.setMarkOverContext(!roleMode && !this.#taskMode);
+		this.#browser.setPreserveQueryOrder(roleMode);
+		const currentSelector = roleMode
+			? this.#currentQuickRoleSelector
+			: this.#taskMode
+				? this.#taskSelector
+				: this.#currentSelector;
+		this.#browser.setCurrentSelector(currentSelector);
+		this.#browser.setItems(roleMode ? this.#quickRoleItems : this.#modelItems);
+		if (modeChanged && currentSelector) {
+			this.#browser.selectSelector(currentSelector);
+		}
+	}
+
+	handleInput(data: string): void {
+		// Mouse tracking is off outside fullscreen overlays; drop any stray SGR
+		// reports instead of feeding them to the search input.
+		if (data.startsWith("\x1b[<")) return;
+		if (this.#taskMatchKeys.size > 0) {
+			const parsed = parseKey(data);
+			const canonical = parsed !== undefined ? canonicalKeyId(parsed) : undefined;
+			if (canonical !== undefined && this.#taskMatchKeys.has(canonical)) {
+				this.#toggleTaskMode();
+				return;
+			}
+		}
+		this.#browser.handleInput(data);
+	}
+	/** Flip between session-model and Task-subagent targets, repointing the highlight. */
+	#toggleTaskMode(): void {
+		this.#taskMode = !this.#taskMode;
+		this.#syncItemsForQuery(this.#browser.query, true);
+		const target = this.#taskMode ? this.#taskSelector : this.#currentSelector;
+		if (target) this.#browser.selectSelector(target);
+		this.#tui.requestRender();
+	}
+
+	render(width: number): string[] {
+		const termRows = Math.max(16, this.#tui.terminal?.rows || process.stdout.rows || 40);
+		const listBudget = Math.floor(termRows * HEIGHT_FRACTION) - CHROME_ROWS - BROWSER_FRAME_ROWS;
+		this.#browser.setMaxVisible(Math.max(MIN_VISIBLE, listBudget));
+
+		const inner = Math.max(1, width - 4);
+		const status = this.#configError
+			? theme.fg("error", ` ${this.#configError}`)
+			: this.#taskMode
+				? theme.fg("error", ` ${TASK_STATUS_HINT}`)
+				: theme.fg("muted", ` ${this.#roleMode ? QUICK_ROLE_STATUS_HINT : STATUS_HINT}`);
+
+		const borderColor: ThemeColor | undefined = this.#taskMode ? "error" : undefined;
+		let footer = this.#taskMode ? TASK_FOOTER_HINT : this.#roleMode ? QUICK_ROLE_FOOTER_HINT : FOOTER_HINT;
+		if (this.#taskMatchKeys.size > 0 && !this.#roleMode) {
+			footer += ` · ${this.#taskModeKeyLabel} ${this.#taskMode ? "session model" : "task model"}`;
+		}
+
+		const out: string[] = [];
+		out.push(topBorder(width, this.#taskMode ? "Switch Task Model" : "Switch Model", borderColor));
+		out.push(row(status, width, borderColor));
+		for (const line of this.#browser.render(inner)) {
+			out.push(row(line, width, borderColor));
+		}
+		out.push(row(theme.fg("dim", footer), width, borderColor));
+		out.push(bottomBorder(width, borderColor));
+		return out;
+	}
+}

package/src/overlays/model-selector.ts

@@ -0,0 +1,107 @@
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core/thinking";
+import { AUTO_THINKING, type ConfiguredThinkingLevel, parseThinkingLevel } from "../thinking";
+
+/** Opt-in selectors that can otherwise be literal model-id suffixes. */
+export interface ThinkingSuffixOptions {
+	allowMaxSuffix?: boolean;
+	allowAutoAlias?: boolean;
+}
+
+/** Selector parsing options with authoritative literal-model lookup. */
+export interface ModelStringParseOptions extends ThinkingSuffixOptions {
+	isLiteralModelId?: (provider: string, id: string) => boolean;
+}
+// Suffix recognition for the model-pattern parser: `:max` is a real thinking
+// level and `:auto` maps to the auto sentinel. Both are gated behind flags
+// (and the literal-id / exact-match guards on the callers) because real model
+// ids end in `:max` (e.g. `glm-4.7:max`) — an ungated split would silently
+// reinterpret them as a thinking suffix.
+/** Recognize all configured effort selectors after literal-id matching. */
+export const MAX_THINKING_SUFFIX_OPTIONS: ThinkingSuffixOptions = { allowMaxSuffix: true, allowAutoAlias: true };
+
+/** Parse a suffix while preserving selectors not explicitly enabled. */
+export function parseThinkingSuffix(
+	value: string,
+	options?: ThinkingSuffixOptions,
+): ConfiguredThinkingLevel | undefined {
+	const level = parseThinkingLevel(value);
+	if (level === ThinkingLevel.Max) return options?.allowMaxSuffix === true ? level : undefined;
+	if (level !== undefined) return level;
+	if (options?.allowAutoAlias === true && value === AUTO_THINKING) return AUTO_THINKING;
+	return undefined;
+}
+
+/**
+ * Split a trailing `:<level>` thinking selector off a model pattern.
+ *
+ * `level` is set when the suffix parses as a concrete thinking level (or, when
+ * the caller opts in via `allowMaxSuffix`/`allowAutoAlias`, the guarded `:max`
+ * level / `:auto` sentinel); `base` then has the suffix stripped. Otherwise
+ * `base` is the input.
+ * `minColonIndex` requires the colon to appear strictly after that index —
+ * role-alias callers pass the matched alias prefix length.
+ */
+export function splitThinkingSuffix(
+	pattern: string,
+	minColonIndex = -1,
+	options?: ThinkingSuffixOptions,
+): { base: string; level?: ConfiguredThinkingLevel } {
+	const colonIdx = pattern.lastIndexOf(":");
+	if (colonIdx <= minColonIndex) return { base: pattern };
+	const level = parseThinkingSuffix(pattern.slice(colonIdx + 1), options);
+	return level ? { base: pattern.slice(0, colonIdx), level } : { base: pattern };
+}
+
+/**
+ * Parse a model string in "provider/modelId" format.
+ * Returns undefined if the format is invalid.
+ */
+export function parseModelString(
+	modelStr: string,
+	options?: ModelStringParseOptions,
+): { provider: string; id: string; thinkingLevel?: ConfiguredThinkingLevel } | undefined {
+	const slashIdx = modelStr.indexOf("/");
+	if (slashIdx <= 0) return undefined;
+	const id = modelStr.slice(slashIdx + 1);
+	const provider = modelStr.slice(0, slashIdx);
+	// Strip strict thinking level suffixes first (e.g. "claude-sonnet-4-6:high" -> id "claude-sonnet-4-6", thinkingLevel "high").
+	const strict = splitThinkingSuffix(id);
+	if (strict.level) return { provider, id: strict.base, thinkingLevel: strict.level };
+	// `max` is a real thinking level, but real model IDs can also end in
+	// `:max`. Context-aware callers pass a literal lookup so those models win.
+	const maxAlias = splitThinkingSuffix(id, -1, options);
+	if (maxAlias.level) {
+		return options?.isLiteralModelId?.(provider, id) === true
+			? { provider, id }
+			: { provider, id: maxAlias.base, thinkingLevel: maxAlias.level };
+	}
+	return { provider, id };
+}
+
+export function formatModelSelectorValue(selector: string, thinkingLevel: ConfiguredThinkingLevel | undefined): string {
+	return thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit ? `${selector}:${thinkingLevel}` : selector;
+}
+
+/** Bare slug (`cerebras`) or tiered/regional slug (`google-ai-studio/priority`, `google-vertex/global/flex`). */
+const UPSTREAM_ROUTING_SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*$/i;
+
+/**
+ * Split a trailing `@<upstream>` provider-routing selector off a model pattern.
+ *
+ * `openrouter/z-ai/glm-4.7@cerebras` -> base `openrouter/z-ai/glm-4.7`, upstream
+ * `cerebras`. Tiered upstreams keep their path (`...@google-ai-studio/priority`).
+ * A `:thinking` suffix after the slug is kept on the base
+ * (`...@cerebras:high` -> base `...:high`). Returns undefined when there is no
+ * `@` or the suffix is not a bare provider slug, so model ids that legitimately
+ * contain `@` (`claude-opus-4-8@default`, `workers-ai/@cf/...`) are never split.
+ */
+export function splitUpstreamRouting(pattern: string): { base: string; upstream: string } | undefined {
+	const at = pattern.lastIndexOf("@");
+	if (at <= 0) return undefined;
+	const rest = pattern.slice(at + 1);
+	const colon = rest.indexOf(":");
+	const upstream = colon === -1 ? rest : rest.slice(0, colon);
+	if (!UPSTREAM_ROUTING_SLUG.test(upstream)) return undefined;
+	const trailing = colon === -1 ? "" : rest.slice(colon);
+	return { base: pattern.slice(0, at) + trailing, upstream };
+}

package/src/overlays/move-overlay.ts

@@ -0,0 +1,197 @@
+/**
+ * `/move` overlay: a path input with live directory autocomplete.
+ *
+ * Rendered as a centered modal via `showHookCustom(..., { overlay: true })`.
+ * The user types a path, Tab autocompletes the highlighted directory, and Enter
+ * confirms — yielding the resolved directory string (or `undefined` on cancel).
+ */
+import { type Component, type Focusable, Key, matchesKey } from "../index";
+import { theme } from "../theme/theme";
+import { matchesSelectCancel, matchesSelectDown, matchesSelectUp } from "../keybinding-matchers";
+import { formTheme } from "../chrome/form-theme";
+import { bottomBorder, row, topBorder } from "../chrome/overlay-box";
+import { TextFormField } from "../components/form";
+
+export interface MoveOverlayResult {
+	directory: string;
+}
+
+/** Directory suggestion displayed by the move dialog. */
+export interface MoveDirectoryEntry {
+	/** Full absolute path. */
+	value: string;
+	/** Display label (basename + trailing slash). */
+	label: string;
+}
+
+/** Directory autocomplete supplied by the host. */
+export interface MoveDirectorySource {
+	search(prefix: string, cwd: string, max: number): MoveDirectoryEntry[];
+}
+
+const MAX_RESULTS = 15;
+
+/**
+ * Overlay component for `/move`: a single-line path input with a live-filtered
+ * list of matching directories. Tab accepts the highlighted suggestion; Enter
+ * confirms the current input (or the highlighted suggestion if the input is
+ * empty); Escape cancels.
+ */
+export class MoveOverlay implements Component, Focusable {
+	#field: TextFormField;
+	#focused = false;
+	#selectedIndex = 0;
+	#results: MoveDirectoryEntry[] = [];
+	#cwd: string;
+	#source: MoveDirectorySource;
+	#done: (result: MoveOverlayResult | undefined) => void;
+	#revision = 0;
+	#renderMemo:
+		| { width: number; fieldLines: readonly string[]; revision: number; lines: readonly string[] }
+		| undefined;
+
+	constructor(cwd: string, done: (result: MoveOverlayResult | undefined) => void, source: MoveDirectorySource) {
+		this.#cwd = cwd;
+		this.#source = source;
+		this.#done = done;
+		this.#field = new TextFormField({
+			theme: formTheme,
+			prompt: theme.fg("dim", "Path: "),
+			empty: "submit",
+			spaceBeforeControl: false,
+			spaceAfterControl: false,
+			onSubmit: () => this.#confirm(),
+			onCancel: () => this.#done(undefined),
+		});
+		this.#field.focused = this.#focused;
+		this.#updateResults();
+	}
+
+	get focused(): boolean {
+		return this.#focused;
+	}
+
+	set focused(value: boolean) {
+		this.#focused = value;
+		this.#field.focused = value;
+	}
+
+	setUseTerminalCursor(useTerminalCursor: boolean): void {
+		this.#field.setUseTerminalCursor(useTerminalCursor);
+	}
+
+	pasteText(text: string): void {
+		this.#field.pasteText(text);
+		this.#selectedIndex = 0;
+		this.#updateResults();
+	}
+
+	handleInput(data: string): void {
+		if (matchesSelectCancel(data) || matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+			this.#done(undefined);
+			return;
+		}
+		if (matchesKey(data, Key.enter) || matchesKey(data, Key.return)) {
+			this.#field.submit();
+			return;
+		}
+		if (matchesSelectUp(data) || matchesKey(data, Key.up)) {
+			if (this.#results.length > 0) {
+				const next = Math.max(0, this.#selectedIndex - 1);
+				if (next !== this.#selectedIndex) {
+					this.#selectedIndex = next;
+					this.#revision++;
+				}
+			}
+			return;
+		}
+		if (matchesSelectDown(data) || matchesKey(data, Key.down)) {
+			if (this.#results.length > 0) {
+				const next = Math.min(this.#results.length - 1, this.#selectedIndex + 1);
+				if (next !== this.#selectedIndex) {
+					this.#selectedIndex = next;
+					this.#revision++;
+				}
+			}
+			return;
+		}
+		if (matchesKey(data, Key.tab)) {
+			const selected = this.#results[this.#selectedIndex];
+			if (selected) {
+				this.#field.setValue(selected.value);
+				this.#selectedIndex = 0;
+				this.#updateResults();
+			}
+			return;
+		}
+		const before = this.#field.getValue();
+		this.#field.handleInput(data);
+		if (this.#field.getValue() !== before) {
+			this.#selectedIndex = 0;
+			this.#updateResults();
+		}
+	}
+
+	render(width: number): readonly string[] {
+		const w = width;
+		const innerWidth = Math.max(1, w - 4);
+		const fieldLines = this.#field.render(innerWidth);
+		const memo = this.#renderMemo;
+		if (memo?.width === w && memo.fieldLines === fieldLines && memo.revision === this.#revision) {
+			return memo.lines;
+		}
+		const lines: string[] = [];
+
+		lines.push(topBorder(w, "Move to directory"));
+		for (const fieldLine of fieldLines) {
+			lines.push(row(fieldLine, w));
+		}
+		lines.push(row("", w));
+
+		if (this.#results.length === 0 && this.#field.getValue().length > 0) {
+			lines.push(row(theme.fg("dim", "No matching directories"), w));
+		} else {
+			for (let i = 0; i < Math.min(this.#results.length, MAX_RESULTS); i++) {
+				const item = this.#results[i]!;
+				const selected = i === this.#selectedIndex;
+				const marker = selected ? theme.fg("accent", "▶ ") : "  ";
+				const label = selected ? theme.fg("accent", item.label) : theme.fg("text", item.label);
+				lines.push(row(`${marker}${label}`, w));
+			}
+		}
+
+		lines.push(row("", w));
+		lines.push(row(theme.fg("dim", "Type to filter · ↑↓ navigate · Tab accept · Enter confirm · Esc cancel"), w));
+		lines.push(bottomBorder(w));
+		this.#renderMemo = { width: w, fieldLines, revision: this.#revision, lines };
+		return lines;
+	}
+
+	invalidate(): void {
+		this.#field.input.prompt = theme.fg("dim", "Path: ");
+		this.#field.invalidate();
+		this.#revision++;
+		this.#renderMemo = undefined;
+	}
+
+	#updateResults(): void {
+		this.#results = this.#source.search(this.#field.getValue(), this.#cwd, MAX_RESULTS + 5);
+		this.#revision++;
+		if (this.#selectedIndex >= this.#results.length) {
+			this.#selectedIndex = Math.max(0, this.#results.length - 1);
+		}
+	}
+
+	#confirm(): void {
+		const selected = this.#results[this.#selectedIndex];
+		if (selected) {
+			this.#done({ directory: selected.value });
+			return;
+		}
+		if (this.#field.getValue().trim().length > 0) {
+			this.#done({ directory: this.#field.getValue().trim() });
+			return;
+		}
+		this.#done(undefined);
+	}
+}