@gajae-code/coding-agent 0.11.1 → 0.11.3

package/src/main.ts

@@ -23,6 +23,7 @@ import chalk from "chalk";
 import type { Args } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
 import { buildInitialMessage } from "./cli/initial-message";
+import { resolveLaunchDisposition } from "./cli/launch-disposition";
 import { runListModelsCommand } from "./cli/list-models";
 import { selectSession } from "./cli/session-picker";
 import { findConfigFile } from "./config";
@@ -57,6 +58,7 @@ import type { AgentSession } from "./session/agent-session";
 import {
 	type ResumeSessionIdentity,
 	resolveResumableSession,
+	type SessionDirectoryMigrationPolicy,
 	type SessionInfo,
 	SessionManager,
 	type StrictSessionOpenResult,
@@ -281,7 +283,7 @@ export function resolveAcpStartupOptions(
 }
 
 async function readPipedInput(): Promise<string | undefined> {
-	if (process.stdin.isTTY !== false) return undefined;
+	if (process.stdin.isTTY === true) return undefined;
 	try {
 		const text = await Bun.stdin.text();
 		if (text.trim().length === 0) return undefined;
@@ -291,6 +293,30 @@ async function readPipedInput(): Promise<string | undefined> {
 	}
 }
 
+async function readPipedInputIfReady(): Promise<string | undefined> {
+	if (process.stdin.isTTY === true) return undefined;
+
+	const ready = Promise.withResolvers<void>();
+	const onReadable = () => ready.resolve();
+	const onEnd = () => ready.resolve();
+	const onError = () => ready.resolve();
+	process.stdin.once("readable", onReadable);
+	process.stdin.once("end", onEnd);
+	process.stdin.once("error", onError);
+	await Promise.race([ready.promise, new Promise<void>(resolve => setImmediate(resolve))]);
+	process.stdin.removeListener("readable", onReadable);
+	process.stdin.removeListener("end", onEnd);
+	process.stdin.removeListener("error", onError);
+
+	const chunks: Buffer[] = [];
+	for (let chunk = process.stdin.read(); chunk !== null; chunk = process.stdin.read()) {
+		chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	}
+	if (chunks.length === 0) return undefined;
+	const text = Buffer.concat(chunks).toString("utf8");
+	return text.trim() ? text : undefined;
+}
+
 export interface InteractiveModeNotify {
 	kind: "warn" | "error" | "info";
 	message: string;
@@ -510,6 +536,7 @@ type SelectResumeSession = (sessions: SessionInfo[]) => Promise<SessionSelection
 type OpenExistingSessionStrict = (
 	identity: ResumeSessionIdentity,
 	sessionDir?: string,
+	migrationPolicy?: SessionDirectoryMigrationPolicy,
 ) => Promise<StrictSessionOpenResult>;
 
 export const BARE_RESUME_CONFLICT_ERROR =
@@ -694,6 +721,7 @@ export async function createSessionManager(
 	cwd: string,
 	activeSettings: Settings = settings,
 ): Promise<SessionManager | undefined> {
+	const migrationPolicy = activeSettings.get("session.directoryMigration") === "disabled" ? "disabled" : "copy-retain";
 	if (parsed.resume === true) {
 		return undefined;
 	}
@@ -703,13 +731,13 @@ export async function createSessionManager(
 		}
 		const forkSource = parsed.fork;
 		if (forkSource.includes("/") || forkSource.includes("\\") || forkSource.endsWith(".jsonl")) {
-			return await SessionManager.forkFrom(forkSource, cwd, parsed.sessionDir);
+			return await SessionManager.forkFrom(forkSource, cwd, parsed.sessionDir, undefined, migrationPolicy);
 		}
 		const match = await resolveResumableSession(forkSource, cwd, parsed.sessionDir);
 		if (!match) {
 			throw new Error(`Session "${forkSource}" not found.`);
 		}
-		return await SessionManager.forkFrom(match.session.path, cwd, parsed.sessionDir);
+		return await SessionManager.forkFrom(match.session.path, cwd, parsed.sessionDir, undefined, migrationPolicy);
 	}
 
 	if (parsed.noSession) {
@@ -718,7 +746,7 @@ export async function createSessionManager(
 	if (typeof parsed.resume === "string") {
 		const sessionArg = parsed.resume;
 		if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
-			return await SessionManager.open(sessionArg, parsed.sessionDir);
+			return await SessionManager.open(sessionArg, parsed.sessionDir, undefined, migrationPolicy);
 		}
 		const match = await resolveResumableSession(sessionArg, cwd, parsed.sessionDir);
 		if (!match) {
@@ -732,13 +760,19 @@ export async function createSessionManager(
 				if (!shouldFork) {
 					throw new Error(`Session "${sessionArg}" is in another project (${match.session.cwd}).`);
 				}
-				return await SessionManager.forkFrom(match.session.path, cwd, parsed.sessionDir);
+				return await SessionManager.forkFrom(
+					match.session.path,
+					cwd,
+					parsed.sessionDir,
+					undefined,
+					migrationPolicy,
+				);
 			}
 		}
-		return await SessionManager.open(match.session.path, parsed.sessionDir);
+		return await SessionManager.open(match.session.path, parsed.sessionDir, undefined, migrationPolicy);
 	}
 	if (parsed.continue) {
-		return await SessionManager.continueRecent(cwd, parsed.sessionDir);
+		return await SessionManager.continueRecent(cwd, parsed.sessionDir, undefined, migrationPolicy);
 	}
 	// --resume without value is handled separately (needs picker UI)
 	// If --session-dir provided without --continue/--resume, create new session there
@@ -761,7 +795,7 @@ export async function createSessionManager(
 	// buildSessionOptions restores the session's model/thinking instead of
 	// overriding them with CLI defaults.
 	if (activeSettings.get("autoResume")) {
-		const manager = await SessionManager.continueRecent(cwd, parsed.sessionDir);
+		const manager = await SessionManager.continueRecent(cwd, parsed.sessionDir, undefined, migrationPolicy);
 		if (manager.getEntries().length > 0) {
 			parsed.continue = true;
 		}
@@ -1005,6 +1039,7 @@ export interface RunRootCommandDependencies {
 	startupUpdate?: { check: () => Promise<string | undefined> };
 	initTheme?: typeof initTheme;
 	readPipedInput?: typeof readPipedInput;
+	stdinIsTTY?: boolean;
 	runStartupCredentialAutoImportIfNeeded?: typeof runStartupCredentialAutoImportIfNeeded;
 	getChangelogForDisplay?: typeof getChangelogForDisplay;
 	createInteractiveMode?: CreateInteractiveMode;
@@ -1014,6 +1049,7 @@ export interface RunRootCommandDependencies {
 	selectResumeSession?: SelectResumeSession;
 	openExistingSessionStrict?: OpenExistingSessionStrict;
 	initializeSettings?: typeof Settings.init;
+	loadSettingsForScope?: typeof Settings.loadForScope;
 }
 
 export async function runRootCommand(
@@ -1054,15 +1090,25 @@ export async function runRootCommand(
 			process.stdout.write(`${chalk.dim("No sessions found")}\n`);
 			return;
 		}
-		const selection = await (deps.selectResumeSession ?? selectSession)(sessions);
+		const selection = deps.selectResumeSession
+			? await deps.selectResumeSession(sessions)
+			: await selectSession(sessions, parsedArgs.sessionDir);
 		if (selection.kind === "cancelled") {
 			return;
 		}
+		const resumeMigrationPolicy =
+			(await (deps.loadSettingsForScope ?? Settings.loadForScope)({ cwd: resumeCwd })).get(
+				"session.directoryMigration",
+			) === "disabled"
+				? "disabled"
+				: "copy-retain";
 		let opened: StrictSessionOpenResult;
 		try {
 			opened = await (deps.openExistingSessionStrict ?? SessionManager.openExistingStrict)(
 				selection.identity,
 				parsedArgs.sessionDir,
+				undefined,
+				resumeMigrationPolicy,
 			);
 		} catch {
 			process.stderr.write(`${BARE_RESUME_OPEN_ERROR}\n`);
@@ -1144,8 +1190,16 @@ export async function runRootCommand(
 	if (parsedArgs.noTitle || parsedArgs.mode === "acp") {
 		Bun.env.PI_NO_TITLE = "1";
 	}
+	const hasPreparedInput = parsedArgs.messages.length > 0 || parsedArgs.fileArgs.length > 0;
 	const { pipedInput, fileText, fileImages } = await logger.time("prepareInitialMessage", async () => {
-		const pipedInput = await (deps.readPipedInput ?? readPipedInput)();
+		const pipedInput =
+			parsedArgs.mode === "acp"
+				? undefined
+				: deps.readPipedInput
+					? await deps.readPipedInput()
+					: hasPreparedInput
+						? await readPipedInputIfReady()
+						: await readPipedInput();
 		if (parsedArgs.fileArgs.length === 0) {
 			return { pipedInput, fileText: undefined, fileImages: undefined };
 		}
@@ -1160,14 +1214,25 @@ export async function runRootCommand(
 		fileImages,
 		stdinContent: pipedInput,
 	});
-	const autoPrint = pipedInput !== undefined && !parsedArgs.print && parsedArgs.mode === undefined;
+	const disposition = resolveLaunchDisposition({
+		stdinIsTTY: deps.stdinIsTTY ?? process.stdin.isTTY,
+		pipedInput,
+		hasPreparedInput,
+		print: Boolean(parsedArgs.print),
+		mode: parsedArgs.mode,
+	});
+	if (disposition.nonInteractiveError) {
+		process.stderr.write(`${chalk.red(disposition.nonInteractiveError)}\n`);
+		process.exit(1);
+	}
+	const autoPrint = disposition.autoPrint;
 	const startupUpdateRoute = classifyStartupUpdateRoute(parsedArgs, autoPrint);
 	const startupUpdate = new StartupUpdateOrchestrator(
 		startupUpdateRoute,
 		() => settingsInstance.get("startup.checkUpdate"),
 		deps.startupUpdate?.check ?? (() => checkForNewVersion(VERSION)),
 	);
-	const isInteractive = startupUpdateRoute === "interactive";
+	const isInteractive = disposition.isInteractive;
 	const mode = parsedArgs.mode || "text";
 
 	// Initialize discovery system with settings for provider persistence
@@ -1299,6 +1364,7 @@ export async function runRootCommand(
 	sessionOptions.modelRegistry = modelRegistry;
 	sessionOptions.hasUI = isInteractive;
 	sessionOptions.notificationHostModeSupported = isInteractive;
+	sessionOptions.sdkHostModeSupported = isInteractive;
 	sessionOptions.settings = settingsInstance;
 	const hasRootStartupProfile = Boolean(settingsInstance.get("modelProfile.default") || parsedArgs.mpreset);
 
@@ -1331,6 +1397,30 @@ export async function runRootCommand(
 		applyCliRuntimeApiKeyOverride(authStorage, parsedArgs.apiKey, sessionOptions.model);
 	}
 
+	if (
+		!deps.suppressProcessExit &&
+		deps.createAgentSession === undefined &&
+		parsedArgs.noSession === true &&
+		!parsedArgs.continue &&
+		parsedArgs.resume === undefined &&
+		parsedArgs.fork === undefined &&
+		!isInteractive &&
+		mode !== "acp" &&
+		!hasRootStartupProfile &&
+		!sessionOptions.model &&
+		!sessionOptions.modelPattern &&
+		modelRegistry.getAvailable().length === 0
+	) {
+		process.stderr.write(`${chalk.red(`No models available. ${formatModelOnboardingGuidance()}`)}\n`);
+		process.stderr.write(
+			`${chalk.yellow(`\nAdvanced manual config remains available at ${ModelsConfigFile.path()}`)}\n`,
+		);
+		process.exitCode = 1;
+		authStorage.close();
+		stopThemeWatcher();
+		await postmortem.cleanup();
+		return;
+	}
 	const createAgentSessionImpl = deps.createAgentSession ?? createAgentSession;
 	const createSession: CreateSessionForMain = async (options, context): Promise<CreateAgentSessionResult> => {
 		const result = await logger.time("createAgentSession", createAgentSessionImpl, options);
@@ -1345,10 +1435,16 @@ export async function runRootCommand(
 	};
 
 	if (mode === "acp") {
-		await (deps.runAcpMode ?? (await import("./modes/acp")).runAcpMode)({
-			agentDir: settingsInstance.getAgentDir(),
-			...(acpStartupOptions ? { startupOptions: acpStartupOptions } : {}),
-		});
+		try {
+			await (deps.runAcpMode ?? (await import("./modes/acp")).runAcpMode)({
+				agentDir: settingsInstance.getAgentDir(),
+				...(acpStartupOptions ? { startupOptions: acpStartupOptions } : {}),
+			});
+		} finally {
+			authStorage.close();
+			stopThemeWatcher();
+			if (!deps.suppressProcessExit) await postmortem.cleanup();
+		}
 	} else {
 		const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager, eventBus } = await createSession(
 			sessionOptions,
@@ -1483,20 +1579,21 @@ export async function runRootCommand(
 			}
 		} else {
 			const runPrint = deps.runPrintMode ?? (await import("./modes/print-mode")).runPrintMode;
-			await runPrint(session, {
-				mode,
-				messages: parsedArgs.messages,
-				initialMessage,
-				initialImages,
-				suppressProcessExit: deps.suppressProcessExit,
-			});
-			if ($env.PI_TIMING) {
-				logger.printTimings();
-			}
-			stopThemeWatcher();
-			if (!deps.suppressProcessExit) {
-				const exitCode = typeof process.exitCode === "number" ? process.exitCode : 0;
-				await postmortem.quit(exitCode);
+			try {
+				await runPrint(session, {
+					mode,
+					messages: parsedArgs.messages,
+					initialMessage,
+					initialImages,
+					suppressProcessExit: deps.suppressProcessExit,
+				});
+				if ($env.PI_TIMING) {
+					logger.printTimings();
+				}
+			} finally {
+				stopThemeWatcher();
+				authStorage.close();
+				if (!deps.suppressProcessExit) await postmortem.cleanup();
 			}
 		}
 	}

package/src/memories/index.ts

@@ -249,6 +249,7 @@ async function runPhase1(options: {
 
 		const claims = claimStage1Jobs(db, {
 			nowSec,
+			cwd: session.sessionManager.getCwd(),
 			threadScanLimit: config.threadScanLimit,
 			maxRolloutsPerStartup: config.maxRolloutsPerStartup,
 			maxRolloutAgeDays: config.maxRolloutAgeDays,

package/src/memories/storage.ts

@@ -137,6 +137,7 @@ export function claimStage1Jobs(
 	db: Database,
 	params: {
 		nowSec: number;
+		cwd: string;
 		threadScanLimit: number;
 		maxRolloutsPerStartup: number;
 		maxRolloutAgeDays: number;
@@ -149,6 +150,7 @@ export function claimStage1Jobs(
 ): Stage1Claim[] {
 	const {
 		nowSec,
+		cwd,
 		threadScanLimit,
 		maxRolloutsPerStartup,
 		maxRolloutAgeDays,
@@ -168,8 +170,10 @@ export function claimStage1Jobs(
 	let runningCount = runningCountRow?.count ?? 0;
 	if (runningCount >= runningConcurrencyCap) return [];
 	const candidateRows = db
-		.prepare("SELECT id, updated_at, rollout_path, cwd, source_kind FROM threads ORDER BY updated_at DESC LIMIT ?")
-		.all(threadScanLimit) as Array<{
+		.prepare(
+			"SELECT id, updated_at, rollout_path, cwd, source_kind FROM threads WHERE cwd = ? ORDER BY updated_at DESC LIMIT ?",
+		)
+		.all(cwd, threadScanLimit) as Array<{
 		id: string;
 		updated_at: number;
 		rollout_path: string;

package/src/modes/action-registry.ts

@@ -0,0 +1,165 @@
+import type { AppKeybinding } from "../config/keybindings";
+
+export type FocusDomain = "composer" | "selector" | "overlay" | "global";
+
+export interface ActionMetadata {
+	id: AppKeybinding;
+	title: string;
+	category: string;
+	bindingId?: AppKeybinding;
+	domains: readonly FocusDomain[];
+	exclusiveGroup?: string | false;
+}
+
+const action = (
+	id: AppKeybinding,
+	title: string,
+	category: string,
+	domains: FocusDomain[],
+	exclusiveGroup?: string | false,
+): ActionMetadata => ({
+	id,
+	title,
+	category,
+	bindingId: id,
+	domains,
+	exclusiveGroup,
+});
+
+export const APP_ACTION_METADATA: readonly ActionMetadata[] = [
+	action("app.interrupt", "Interrupt", "Session", ["global"], false),
+	action("app.clear", "Clear", "Session", ["global"]),
+	action("app.exit", "Exit", "Session", ["global"]),
+	action("app.suspend", "Suspend", "Session", ["global"]),
+	action("app.thinking.cycle", "Cycle thinking level", "Thinking", ["composer"]),
+	action("app.thinking.toggle", "Toggle thinking", "Thinking", ["composer"]),
+	action("app.commandPalette.open", "Open command palette", "Navigation", ["composer"]),
+	action("app.model.cycleForward", "Next model", "Model", ["composer"]),
+	action("app.model.cycleBackward", "Previous model", "Model", ["composer"]),
+	action("app.model.select", "Select model", "Model", ["composer"]),
+	action("app.model.selectTemporary", "Select temporary model", "Model", ["composer"]),
+	action("app.tools.expand", "Toggle tool expansion", "Tools", ["composer"]),
+	action("app.tool.backgroundFold", "Fold foreground tool", "Tools", ["composer"]),
+	action("app.editor.external", "Open external editor", "Editor", ["composer"]),
+	action("app.message.followUp", "Send follow-up", "Messages", ["composer"]),
+	action("app.message.queue", "Queue message", "Messages", ["composer"]),
+	action("app.message.dequeue", "Edit queued message", "Messages", ["composer"]),
+	action("app.clipboard.pasteImage", "Paste image", "Clipboard", ["composer"]),
+	action("app.clipboard.copyLine", "Copy line", "Clipboard", ["composer"]),
+	action("app.clipboard.copyPrompt", "Copy prompt", "Clipboard", ["composer"]),
+	action("app.session.new", "New session", "Session", ["composer"]),
+	action("app.session.tree", "Session tree", "Session", ["composer"]),
+	action("app.session.fork", "Fork session", "Session", ["composer"]),
+	action("app.session.resume", "Resume session", "Session", ["composer"]),
+	action("app.session.observe", "Observe sessions", "Session", ["composer"]),
+	action("app.session.dashboard", "Show sessions dashboard", "Session", ["composer"]),
+	action("app.jobs.open", "Open jobs", "Jobs", ["composer"]),
+	action("app.session.togglePath", "Toggle session path", "Session", ["selector"]),
+	action("app.session.toggleSort", "Toggle session sort", "Session", ["selector"]),
+	action("app.session.rename", "Rename session", "Session", ["selector"]),
+	action("app.session.delete", "Delete session", "Session", ["selector"]),
+	action("app.session.deleteNoninvasive", "Delete selected session", "Session", ["selector"]),
+	action("app.tree.foldOrUp", "Fold tree item", "Session", ["selector"]),
+	action("app.tree.unfoldOrDown", "Unfold tree item", "Session", ["selector"]),
+	action("app.plan.toggle", "Toggle plan mode", "Mode", ["composer"]),
+	action("app.history.search", "Search history", "Navigation", ["composer"]),
+	action("app.stt.toggle", "Toggle speech-to-text", "Speech", ["composer"]),
+	action("app.irc.sidebar.toggle", "Toggle IRC sidebar", "IRC", ["composer"]),
+	action("app.transcript.browse", "Browse transcript", "Transcript", ["composer"]),
+	action("app.transcript.prevTurn", "Previous transcript turn", "Transcript", ["composer"]),
+	action("app.transcript.nextTurn", "Next transcript turn", "Transcript", ["composer"]),
+	action("app.mode.cycle", "Cycle mode", "Mode", ["composer"]),
+	action("app.tasks.toggle", "Toggle tasks pane", "Jobs", ["composer"]),
+	action("app.queue.togglePane", "Toggle queue pane", "Messages", ["composer"]),
+	action("app.message.sendNow", "Send message now", "Messages", ["composer"]),
+];
+
+export interface ActionDefinition<Context> extends ActionMetadata {
+	availability(context: Context): boolean;
+	execute(context: Context): void | Promise<void>;
+}
+
+export interface ActionRegistryOptions<Context> {
+	context: Context;
+	showError(error: string): void;
+}
+
+export class ActionRegistry<Context> {
+	readonly #actions = new Map<AppKeybinding, ActionDefinition<Context>>();
+	readonly #busy = new Set<AppKeybinding>();
+	readonly #busyGroups = new Set<string>();
+	readonly #availability = new Map<AppKeybinding, boolean>();
+	#availabilityResetQueued = false;
+
+	constructor(private readonly options: ActionRegistryOptions<Context>) {}
+
+	register(action: ActionDefinition<Context>): void {
+		if (this.#actions.has(action.id)) throw new Error(`Action already registered: ${action.id}`);
+		this.#actions.set(action.id, action);
+	}
+
+	get(id: AppKeybinding): ActionDefinition<Context> | undefined {
+		return this.#actions.get(id);
+	}
+	all(): readonly ActionDefinition<Context>[] {
+		return [...this.#actions.values()];
+	}
+
+	#reportError(id: AppKeybinding, phase: "availability" | "execution", error: unknown): void {
+		const cause = error instanceof Error ? error.message : String(error);
+		try {
+			this.options.showError(`Action ${id} ${phase} failed: ${cause}`);
+		} catch {
+			// Error reporting must not escape an action dispatch.
+		}
+	}
+
+	#evaluateAvailability(id: AppKeybinding, action: ActionDefinition<Context>): boolean {
+		const cached = this.#availability.get(id);
+		if (cached !== undefined) return cached;
+		let available: boolean;
+		try {
+			available = Boolean(action.availability(this.options.context));
+		} catch (error) {
+			this.#reportError(id, "availability", error);
+			available = false;
+		}
+		this.#availability.set(id, available);
+		if (!this.#availabilityResetQueued) {
+			this.#availabilityResetQueued = true;
+			queueMicrotask(() => {
+				this.#availability.clear();
+				this.#availabilityResetQueued = false;
+			});
+		}
+		return available;
+	}
+
+	#exclusiveGroup(action: ActionDefinition<Context>): string | undefined {
+		return action.exclusiveGroup === false ? undefined : (action.exclusiveGroup ?? "default");
+	}
+
+	isAvailable(id: AppKeybinding): boolean {
+		const action = this.#actions.get(id);
+		return action ? this.#evaluateAvailability(id, action) : false;
+	}
+
+	async execute(id: AppKeybinding): Promise<boolean> {
+		const current = this.#actions.get(id);
+		if (!current || this.#busy.has(id) || !this.#evaluateAvailability(id, current)) return false;
+		const group = this.#exclusiveGroup(current);
+		if (group && this.#busyGroups.has(group)) return false;
+		this.#busy.add(id);
+		if (group) this.#busyGroups.add(group);
+		try {
+			await current.execute(this.options.context);
+			return true;
+		} catch (error) {
+			this.#reportError(id, "execution", error);
+			return false;
+		} finally {
+			this.#busy.delete(id);
+			if (group) this.#busyGroups.delete(group);
+		}
+	}
+}

package/src/modes/components/chrome.ts

@@ -0,0 +1,40 @@
+import { Container, type SelectItem, SelectList, Text } from "@gajae-code/tui";
+import { getSelectListTheme, theme } from "../../modes/theme/theme";
+import { DynamicBorder } from "./dynamic-border";
+
+export interface FramedSelectOptions {
+	maxVisible?: number;
+	selectedValue?: string;
+	onSelect?: (item: SelectItem) => void;
+	onCancel?: () => void;
+	onSelectionChange?: (item: SelectItem) => void;
+}
+
+export interface FramedSelect {
+	container: Container;
+	selectList: SelectList;
+}
+
+/** Build the shared border/list selector chrome used by compact mode selectors. */
+export function FramedSelect(
+	title: string | undefined,
+	items: ReadonlyArray<SelectItem>,
+	opts: FramedSelectOptions = {},
+): FramedSelect {
+	const container = new Container();
+	container.addChild(new DynamicBorder());
+	if (title) {
+		container.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
+	}
+
+	const selectList = new SelectList(items, opts.maxVisible ?? Math.min(items.length, 10), getSelectListTheme());
+	const selectedIndex =
+		opts.selectedValue === undefined ? -1 : items.findIndex(item => item.value === opts.selectedValue);
+	if (selectedIndex !== -1) selectList.setSelectedIndex(selectedIndex);
+	selectList.onSelect = item => opts.onSelect?.(item);
+	selectList.onCancel = () => opts.onCancel?.();
+	if (opts.onSelectionChange) selectList.onSelectionChange = opts.onSelectionChange;
+	container.addChild(selectList);
+	container.addChild(new DynamicBorder());
+	return { container, selectList };
+}