@gajae-code/coding-agent 0.12.10 → 0.12.12

package/src/main.ts

@@ -76,20 +76,13 @@ import { persistTaskTokenLog, resolveTaskTokenLogDir, taskTokenLogFromUsage } fr
 import type { LspStartupServerInfo } from "./tools";
 import { getDisplayChangelogEntries, getInstalledVersionChangelogEntry, getNewEntries } from "./utils/changelog";
 import type { EventBus } from "./utils/event-bus";
+import { fetchLatestPackageVersion } from "./utils/npm-registry";
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
 	try {
-		const response = await fetch("https://registry.npmjs.org/@gajae-code/coding-agent/latest");
-		if (!response.ok) return undefined;
-
-		const data = (await response.json()) as { version?: string };
-		const latestVersion = data.version;
-
-		if (latestVersion && Bun.semver.order(latestVersion, currentVersion) > 0) {
-			return latestVersion;
-		}
-
-		return undefined;
+		// Resolved from npm config so mirrored/firewalled networks are checked too.
+		const { version } = await fetchLatestPackageVersion("@gajae-code/coding-agent");
+		return Bun.semver.order(version, currentVersion) > 0 ? version : undefined;
 	} catch {
 		return undefined;
 	}
@@ -406,6 +399,7 @@ type StartupModelProfileArgs = {
 	parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
 	startupModel?: CreateAgentSessionOptions["model"];
 	startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+	preferCachedModels?: boolean;
 };
 
 async function applyStartupModelProfilesWithPolicy(
@@ -416,16 +410,17 @@ async function applyStartupModelProfilesWithPolicy(
 		profileName: string,
 		persistDefault: boolean,
 		options: { thinkingLevelOverride?: CreateAgentSessionOptions["thinkingLevel"] } = {},
-	): Promise<void> => {
+	): Promise<boolean> => {
 		try {
 			await activateModelProfile(
 				{ session: args.session, modelRegistry: args.modelRegistry, settings: args.settings, profileName },
 				{ persistDefault, thinkingLevelOverride: options.thinkingLevelOverride },
 			);
+			return true;
 		} catch (error) {
 			if (onCredentialError && error instanceof ModelProfileCredentialError) {
 				onCredentialError(error);
-				return;
+				return false;
 			}
 			throw error;
 		}
@@ -436,19 +431,40 @@ async function applyStartupModelProfilesWithPolicy(
 	// deferred `--model <pattern>` path resolved inside createAgentSession.
 	const explicitModel = args.parsedArgs.model ? (args.startupModel ?? args.session.model) : undefined;
 	const defaultProfile = args.settings.get("modelProfile.default");
-	if (defaultProfile || args.parsedArgs.mpreset) {
-		await args.modelRegistry.refresh("online-if-uncached");
-	}
+	const preferCachedProfiles = args.preferCachedModels === true && args.parsedArgs.mpreset !== undefined;
+	const applyConfiguredProfiles = async (): Promise<boolean> => {
+		let applied = true;
+		if (defaultProfile) {
+			applied =
+				(await applyProfile(defaultProfile, false, {
+					thinkingLevelOverride: args.settings.has("defaultThinkingLevel")
+						? args.settings.get("defaultThinkingLevel")
+						: undefined,
+				})) && applied;
+		}
+		if (args.parsedArgs.mpreset) {
+			applied = (await applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true)) && applied;
+		}
+		return applied;
+	};
 
-	if (defaultProfile) {
-		await applyProfile(defaultProfile, false, {
-			thinkingLevelOverride: args.settings.has("defaultThinkingLevel")
-				? args.settings.get("defaultThinkingLevel")
-				: undefined,
-		});
-	}
-	if (args.parsedArgs.mpreset) {
-		await applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true);
+	if (preferCachedProfiles) {
+		let applied: boolean;
+		let refreshedOnline = false;
+		try {
+			applied = await applyConfiguredProfiles();
+		} catch (error) {
+			if (error instanceof ModelProfileCredentialError) throw error;
+			await args.modelRegistry.refresh("online-if-uncached");
+			refreshedOnline = true;
+			applied = await applyConfiguredProfiles();
+		}
+		if (applied && !refreshedOnline) args.modelRegistry.refreshInBackground();
+	} else {
+		if (defaultProfile || args.parsedArgs.mpreset) {
+			await args.modelRegistry.refresh("online-if-uncached");
+		}
+		await applyConfiguredProfiles();
 	}
 
 	// Explicit CLI --model/--thinking must win over any activated or skipped profile.
@@ -509,20 +525,52 @@ export async function applyStartupModelProfilesForRoot(
 		resumeAction: "continue-tail" | "open-idle" | undefined;
 	},
 ): Promise<{ recoverableErrors: string[] }> {
+	const policyArgs = { ...args, preferCachedModels: args.isInteractive };
 	if (!isStartupModelProfileCredentialRecoveryEligible(args)) {
-		await applyStartupModelProfilesOrExit(args);
+		try {
+			await applyStartupModelProfilesWithPolicy(policyArgs);
+		} catch (error) {
+			await exitForStartupModelProfileError(args, error);
+		}
 		return { recoverableErrors: [] };
 	}
 
 	const recoverableErrors: string[] = [];
 	try {
-		await applyStartupModelProfilesWithPolicy(args, error => recoverableErrors.push(error.message));
+		await applyStartupModelProfilesWithPolicy(policyArgs, error => recoverableErrors.push(error.message));
 	} catch (error) {
 		await exitForStartupModelProfileError(args, error);
 	}
 	return { recoverableErrors };
 }
 
+type DeferredModelProfileStartup = () => Promise<{ recoverableErrors: string[] }>;
+class DeferredModelProfileStartupError extends Error {
+	readonly profileError: unknown;
+
+	constructor(profileError: unknown) {
+		super("Deferred model profile startup failed");
+		this.profileError = profileError;
+	}
+}
+
+async function applyDeferredStartupModelProfilesForRoot(
+	args: StartupModelProfileArgs & {
+		isInteractive: boolean;
+		hasInteractiveTerminal: boolean;
+		initialMessage: string | undefined;
+		initialMessages: readonly string[];
+		resumeAction: "continue-tail" | "open-idle" | undefined;
+	},
+): Promise<{ recoverableErrors: string[] }> {
+	const recoverableErrors: string[] = [];
+	const onCredentialError = isStartupModelProfileCredentialRecoveryEligible(args)
+		? (error: ModelProfileCredentialError) => recoverableErrors.push(error.message)
+		: undefined;
+	await applyStartupModelProfilesWithPolicy({ ...args, preferCachedModels: true }, onCredentialError);
+	return { recoverableErrors };
+}
+
 interface InteractiveModeFactoryOptions {
 	session: AgentSession;
 	version: string;
@@ -616,6 +664,8 @@ export async function runInteractiveMode(
 	initialImages?: ImageContent[],
 	createInteractiveMode?: CreateInteractiveMode,
 	resumeAction?: "continue-tail" | "open-idle",
+	startDeferredMcpConfig?: CreateAgentSessionResult["startDeferredMcpConfig"],
+	startDeferredModelProfiles?: DeferredModelProfileStartup,
 ): Promise<void> {
 	const mode = createInteractiveMode
 		? createInteractiveMode({
@@ -659,45 +709,98 @@ export async function runInteractiveMode(
 			mode.showStatus(notify.message);
 		}
 	}
+	if (startDeferredMcpConfig) {
+		mode.showStatus("Connecting MCP tools…");
+		void startDeferredMcpConfig()
+			.then(result => {
+				if (result.hasErrors) {
+					mode.showWarning(
+						result.loadedToolCount > 0 ? "Some MCP tools could not be loaded." : "MCP tools could not be loaded.",
+					);
+					return;
+				}
+				mode.showStatus(`${result.loadedToolCount} MCP tool${result.loadedToolCount === 1 ? "" : "s"} connected`);
+			})
+			.catch(() => {
+				logger.warn("Deferred MCP startup failed.");
+				mode.showError("MCP tools could not be loaded.");
+			});
+	}
+	let deferredModelProfileFailure: Promise<never> | undefined;
+	if (startDeferredModelProfiles) {
+		mode.showStatus("Loading model profile…");
+		deferredModelProfileFailure = startDeferredModelProfiles().then(
+			result => {
+				for (const error of result.recoverableErrors) mode.showError(error);
+				mode.showStatus("Model profile ready");
+				return Promise.withResolvers<never>().promise;
+			},
+			error => {
+				const message = error instanceof Error ? error.message : "Model profile could not be loaded.";
+				mode.showError(message);
+				throw new DeferredModelProfileStartupError(error);
+			},
+		);
+	}
 
-	const hasStartupInput = initialMessage !== undefined || initialMessages.length > 0;
-	if (!hasStartupInput && resumeAction === "continue-tail") {
-		try {
-			await session.continuePersistedHistory();
-		} catch (error: unknown) {
-			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-			mode.showError(errorMessage);
+	const runStartupInputAndPromptLoop = async (): Promise<never> => {
+		const hasStartupInput = initialMessage !== undefined || initialMessages.length > 0;
+		if (!hasStartupInput && resumeAction === "continue-tail") {
+			try {
+				await session.continuePersistedHistory();
+			} catch (error: unknown) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+				mode.showError(errorMessage);
+			}
 		}
-	}
 
-	if (initialMessage !== undefined) {
-		try {
-			await session.prompt(initialMessage, { images: initialImages });
-		} catch (error: unknown) {
-			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-			mode.showError(errorMessage);
+		if (initialMessage !== undefined) {
+			try {
+				await session.prompt(initialMessage, { images: initialImages });
+			} catch (error: unknown) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+				mode.showError(errorMessage);
+			}
 		}
-	}
 
-	for (const message of initialMessages) {
-		try {
-			let text = message;
-			const slashResult = await executeBuiltinSlashCommand(text, {
-				ctx: mode,
-				handleBackgroundCommand: () => mode.handleBackgroundCommand(),
-			});
-			if (slashResult === true) continue;
-			if (typeof slashResult === "string") text = slashResult;
-			await session.prompt(text);
-		} catch (error: unknown) {
-			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-			mode.showError(errorMessage);
+		for (const message of initialMessages) {
+			try {
+				let text = message;
+				const slashResult = await executeBuiltinSlashCommand(text, {
+					ctx: mode,
+					handleBackgroundCommand: () => mode.handleBackgroundCommand(),
+				});
+				if (slashResult === true) continue;
+				if (typeof slashResult === "string") text = slashResult;
+				await session.prompt(text);
+			} catch (error: unknown) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+				mode.showError(errorMessage);
+			}
 		}
-	}
 
-	while (true) {
-		const input = await mode.getUserInput();
-		await submitInteractiveInput(mode, session, input);
+		while (true) {
+			const input = await mode.getUserInput();
+			await submitInteractiveInput(mode, session, input);
+		}
+	};
+
+	const inputLoop = runStartupInputAndPromptLoop();
+	if (!deferredModelProfileFailure) {
+		await inputLoop;
+		return;
+	}
+	try {
+		await Promise.race([inputLoop, deferredModelProfileFailure]);
+	} catch (error) {
+		if (!(error instanceof DeferredModelProfileStartupError)) throw error;
+		try {
+			await mode.shutdown();
+		} finally {
+			mode.stop();
+		}
+		await inputLoop.catch(() => {});
+		throw error.profileError;
 	}
 }
 
@@ -1494,7 +1597,13 @@ export async function runRootCommand(
 	sessionOptions.notificationHostModeSupported = isInteractive;
 	sessionOptions.sdkHostModeSupported = isInteractive;
 	sessionOptions.settings = settingsInstance;
+	if (isInteractive && sessionOptions.mcpConfigPath) {
+		sessionOptions.deferMcpConfigStartup = true;
+	}
 	const hasRootStartupProfile = Boolean(settingsInstance.get("modelProfile.default") || parsedArgs.mpreset);
+	const deferMemoryBackendStartup =
+		hasRootStartupProfile && !(parsedArgs.authBootstrap === true && isInteractive) && mode !== "acp";
+	sessionOptions.deferMemoryBackendStartup = deferMemoryBackendStartup;
 
 	// Research-mode (RLM) preset: augment session options before session creation.
 	deps.rlmPreset?.applyOptions(sessionOptions, settingsInstance);
@@ -1574,10 +1683,16 @@ export async function runRootCommand(
 			if (!deps.suppressProcessExit) await postmortem.cleanup();
 		}
 	} else {
-		const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager, eventBus } = await createSession(
-			sessionOptions,
-			{ skipPostCreateModelRefresh: hasRootStartupProfile },
-		);
+		const {
+			session,
+			setToolUIContext,
+			modelFallbackMessage,
+			lspServers,
+			mcpManager,
+			startDeferredMcpConfig,
+			startDeferredMemoryBackend,
+			eventBus,
+		} = await createSession(sessionOptions, { skipPostCreateModelRefresh: hasRootStartupProfile });
 		applyCliRuntimeApiKeyOverride(authStorage, parsedArgs.apiKey, session.model);
 
 		// Research-mode (RLM) preset: hard tool-boundary assertion after the registry is assembled.
@@ -1594,8 +1709,9 @@ export async function runRootCommand(
 			}
 		}
 
+		let startDeferredModelProfiles: DeferredModelProfileStartup | undefined;
 		if (!(parsedArgs.authBootstrap === true && isInteractive)) {
-			const { recoverableErrors } = await applyStartupModelProfilesForRoot({
+			const profileArgs = {
 				session,
 				settings: settingsInstance,
 				modelRegistry,
@@ -1607,9 +1723,27 @@ export async function runRootCommand(
 				initialMessage,
 				initialMessages: parsedArgs.messages,
 				resumeAction: bareResumeAction,
-			});
-			for (const recoverableError of recoverableErrors) {
-				notifs.push({ kind: "error", message: recoverableError });
+			};
+			if (isInteractive && parsedArgs.mpreset) {
+				const ready = Promise.withResolvers<void>();
+				session.extendStartupTurnBarrier(ready.promise);
+				startDeferredModelProfiles = async () => {
+					try {
+						const result = await applyDeferredStartupModelProfilesForRoot(profileArgs);
+						startDeferredMemoryBackend?.();
+						ready.resolve();
+						return result;
+					} catch (error) {
+						ready.reject(error);
+						throw error;
+					}
+				};
+			} else {
+				const { recoverableErrors } = await applyStartupModelProfilesForRoot(profileArgs);
+				startDeferredMemoryBackend?.();
+				for (const recoverableError of recoverableErrors) {
+					notifs.push({ kind: "error", message: recoverableError });
+				}
 			}
 		}
 
@@ -1690,6 +1824,8 @@ export async function runRootCommand(
 						initialImages,
 						deps.createInteractiveMode,
 						bareResumeAction,
+						startDeferredMcpConfig,
+						startDeferredModelProfiles,
 					);
 				}
 			} catch (error) {

package/src/modes/DESIGN.md

@@ -63,9 +63,11 @@ visible-width-aligned column capped at 30 cells, two spaces, then a truncated
 value. The selected row uses the themed cursor; unselected rows reserve two
 spaces. It centers the selected item inside its `maxVisible` window, reports
 scroll position as `(current/total)`, places a blank row before the selected
-item description, and ends with the dim
-`Enter/Space to change · Esc to cancel` hint. Hosts that need stable height
-reserve fixed description rows; the status-line custom editor reserves two.
+item description, and ends with a dim keyboard hint. Printable text starts a
+case-insensitive label search shown above the list; Backspace removes one
+grapheme, and Escape clears a non-empty search before a later Escape cancels
+the list. Hosts that need stable height reserve fixed description rows; the
+status-line custom editor reserves two.
 
 Submenus are a content replacement, not a modal overlay: a bold accent title,
 optional muted description, optional preview, a spacer, a select/list control,
@@ -82,8 +84,9 @@ empty space and list density for an operational setup flow.
 ### Focus, cursor, keyboard, and input behavior
 
 - Up/Down wrap within selector lists. Enter and Space activate the current
-  action. Escape follows the current component's cancel path before the parent
-  is allowed to close.
+  action. Printable text filters settings by label. Escape first clears an
+  active filter, then follows the current component's cancel path before the
+  parent is allowed to close.
 - The parent routes Tab/Left/Right to the tab bar except while a text input is
   active. Text entry owns arrow keys and Tab in that state.
 - `Input` has a visible `> ` prompt, a zero-width hardware cursor marker only

package/src/modes/components/footer.ts

@@ -116,24 +116,16 @@ export class FooterComponent implements Component {
 	render(width: number): string[] {
 		const state = this.session.state;
 
-		// Calculate cumulative usage from ALL session entries (not just post-compaction messages)
-		let totalInput = 0;
-		let totalOutput = 0;
-		let totalCacheRead = 0;
-		let totalCacheWrite = 0;
-		let totalCost = 0;
-		let totalPremiumRequests = 0;
-
-		for (const entry of this.session.sessionManager.getEntries()) {
-			if (entry.type === "message" && entry.message.role === "assistant") {
-				totalInput += entry.message.usage.input;
-				totalOutput += entry.message.usage.output;
-				totalCacheRead += entry.message.usage.cacheRead;
-				totalCacheWrite += entry.message.usage.cacheWrite;
-				totalCost += entry.message.usage.cost.total;
-				totalPremiumRequests += entry.message.usage.premiumRequests ?? 0;
-			}
-		}
+		// Use the session manager's cumulative index so parent and task usage are
+		// accounted for consistently without rescanning persisted entries here.
+		const {
+			input: totalInput,
+			output: totalOutput,
+			cacheRead: totalCacheRead,
+			cacheWrite: totalCacheWrite,
+			cost: totalCost,
+			premiumRequests: totalPremiumRequests,
+		} = this.session.sessionManager.getUsageStatistics();
 
 		// Calculate context usage from session (handles compaction correctly).
 		// After compaction, tokens are unknown until the next LLM response.

package/src/modes/components/session-selector.ts

@@ -197,7 +197,7 @@ export class SessionSelectorComponent extends Container {
 
 	constructor(
 		sessions: SessionInfo[],
-		private readonly onSelect: (sessionPath: string) => void,
+		private readonly onSelect: (sessionPath: string) => void | Promise<void>,
 		private readonly onCancel: () => void,
 		private readonly onExit: () => void,
 		private readonly onDelete?: (session: SessionInfo) => Promise<boolean>,
@@ -214,7 +214,7 @@ export class SessionSelectorComponent extends Container {
 		this.#sessionList = new SessionList(sessions);
 		this.#sessionList.onSelect = session => {
 			if (this.inspector) void this.#inspect(session);
-			else this.onSelect(session.path);
+			else this.#dispatchSelect(session.path);
 		};
 		this.#sessionList.onCancel = () => this.#cancel();
 		this.#sessionList.onExit = () => this.#exit();
@@ -241,6 +241,29 @@ export class SessionSelectorComponent extends Container {
 		this.#onRequestRender?.();
 	}
 
+	/**
+	 * Observe async `onSelect` handlers. Callers (e.g. resume) may return a
+	 * Promise; leaving it unobserved turns preparation/switch failures into
+	 * process-killing unhandled rejections. Inline recovery keeps the picker
+	 * usable when the host has not already closed it.
+	 */
+	#dispatchSelect(sessionPath: string): void {
+		void Promise.resolve(this.onSelect(sessionPath)).catch((error: unknown) => {
+			if (this.#state.kind === "settled") {
+				// Host already closed the picker (interactive resume path). Surface the
+				// message only if we still have a render surface; controller catch is
+				// the primary recovery path after `done()`.
+				this.#showError(error instanceof Error ? error.message : String(error));
+				this.#requestRender();
+				return;
+			}
+			this.#state = { kind: "browsing" };
+			this.#sessionList.setInputFrozen(false);
+			this.#showError(error instanceof Error ? error.message : String(error));
+			this.#requestRender();
+		});
+	}
+
 	#settle(selection: SessionSelectionResult): void {
 		if (this.#state.kind === "settled") return;
 		this.#state = { kind: "settled" };
@@ -249,7 +272,7 @@ export class SessionSelectorComponent extends Container {
 		this.#confirmationDialog = null;
 		if (dialog) this.removeChild(dialog);
 		if (this.onSelection) this.onSelection(selection);
-		else if (selection.kind === "selected") this.onSelect(selection.path);
+		else if (selection.kind === "selected") this.#dispatchSelect(selection.path);
 		else this.onCancel();
 	}
 	#cancel(): void {

package/src/modes/components/status-line/gh.ts

@@ -1,6 +1,26 @@
 import { type RunGh, runGhDefault } from "../../../utils/gh";
 
 const STATUS_LINE_GH_TIMEOUT_MS = 5_000;
+const C0_C1_CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/;
+
+function canonicalPrUrl(value: unknown, number: number): string | null {
+	if (typeof value !== "string" || C0_C1_CONTROL_CHARACTERS.test(value)) return null;
+
+	try {
+		const url = new URL(value);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+		if (!url.hostname || url.username || url.password || url.search || url.hash) return null;
+
+		const suffix = `/pull/${number}`;
+		if (!url.pathname.endsWith(suffix)) return null;
+		const repositoryPath = url.pathname.slice(1, -suffix.length).split("/");
+		if (repositoryPath.length !== 2 || repositoryPath.some(component => component === "")) return null;
+
+		return url.href;
+	} catch {
+		return null;
+	}
+}
 
 export async function lookupCurrentPr(runGh: RunGh = runGhDefault): Promise<{ number: number; url: string } | null> {
 	try {
@@ -8,8 +28,9 @@ export async function lookupCurrentPr(runGh: RunGh = runGhDefault): Promise<{ nu
 		if (result.exitCode !== 0 || result.timedOut) return null;
 
 		const pr = JSON.parse(result.stdout) as { number?: unknown; url?: unknown };
-		if (typeof pr.number !== "number" || typeof pr.url !== "string") return null;
-		return { number: pr.number, url: pr.url };
+		if (typeof pr.number !== "number" || !Number.isSafeInteger(pr.number) || pr.number <= 0) return null;
+		const url = canonicalPrUrl(pr.url, pr.number);
+		return url ? { number: pr.number, url } : null;
 	} catch {
 		return null;
 	}

package/src/modes/controllers/event-controller.ts

@@ -32,6 +32,7 @@ import { computeIrcSplitWidths, getIrcSidebarSemanticToken } from "../components
 import type { IrcObservationRecord } from "../irc-observation-ledger";
 import { interruptHint } from "../shared";
 import { buildAbortDisplayMessage } from "../utils/abort-message";
+import { emitHostStatus } from "../utils/host-status";
 import { consumeInjectedOptimisticSignature } from "../utils/injected-user-submission";
 import { parseIrcMessage } from "../utils/irc-message";
 import { ringTerminalBell } from "../utils/terminal-bell";
@@ -298,6 +299,7 @@ export class EventController {
 	}
 
 	async #handleAgentStart(_event: Extract<AgentSessionEvent, { type: "agent_start" }>): Promise<void> {
+		emitHostStatus("working");
 		this.ctx.promptSuggestion?.onAgentStart();
 		this.#lastIntent = undefined;
 		this.#readToolCallArgs.clear();
@@ -924,6 +926,7 @@ export class EventController {
 		this.ctx.updateEditorBorderColor();
 		this.ctx.ui.requestRender();
 		this.#scheduleIdleCompaction();
+		emitHostStatus("finished");
 		this.sendCompletionNotification();
 		this.ctx.promptSuggestion?.onAgentEnd();
 	}

package/src/modes/controllers/extension-ui-controller.ts

@@ -40,6 +40,7 @@ import { createReadonlySessionManager } from "../../session/session-manager";
 import { parseThinkingLevel } from "../../thinking";
 import type { TodoPhase } from "../../tools/todo-write";
 import { setSessionTerminalTitle, setTerminalTitle } from "../../utils/title-generator";
+import { emitHostStatus } from "../utils/host-status";
 import { applyInjectedUserSubmission } from "../utils/injected-user-submission";
 import { classifyHookSelectorBellEvent, ringTerminalBell } from "../utils/terminal-bell";
 import { prepareTranscriptRebuild } from "../utils/ui-helpers";
@@ -1258,6 +1259,7 @@ export class ExtensionUiController {
 			computeBudget();
 
 		ringTerminalBell(classifyHookSelectorBellEvent(title));
+		emitHostStatus("attention");
 
 		this.ctx.hookSelector = new HookSelectorComponent(
 			title,

package/src/modes/controllers/input-controller.ts

@@ -822,6 +822,17 @@ export class InputController {
 		if (runner?.hasHandlers("input")) {
 			const result = await runner.emitInput(text, inputImages, "interactive");
 			if (result?.handled) {
+				const handledText = result.text === undefined ? "" : sanitizeText(result.text).trim();
+				if (handledText) {
+					this.ctx.addMessageToChat({
+						role: "custom",
+						customType: "extension-input-result",
+						content: handledText,
+						display: true,
+						timestamp: Date.now(),
+					});
+					this.ctx.ui.requestRender();
+				}
 				if (this.#canModifyComposer(composer)) {
 					this.ctx.editor.setText("");
 				}

package/src/modes/controllers/selector-controller.ts

@@ -2638,9 +2638,15 @@ export class SelectorController {
 		this.showSelector(done => {
 			const selector = new SessionSelectorComponent(
 				sessions,
-				async sessionPath => {
+				sessionPath => {
+					// `onSelect` is a void dispatch boundary: close the picker first, then
+					// observe resume failures so a managed-candidate race (or any other
+					// preparation/switch rejection) surfaces as UI error instead of an
+					// unhandled rejection that can kill the process. Do not auto-retry.
 					done();
-					await this.handleResumeSession(sessionPath);
+					void this.handleResumeSession(sessionPath).catch(error => {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					});
 				},
 				() => {
 					done();

package/src/modes/interactive-mode.ts

@@ -1036,9 +1036,15 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (this.session.getGoalModeState()?.mode === "exiting") {
 			await this.#goalModeController.beforeGetUserInput();
 		}
-		const { promise, resolve } = Promise.withResolvers<SubmittedUserInput>();
+		const { promise, resolve, reject } = Promise.withResolvers<SubmittedUserInput>();
+		let unsubscribeStop = () => {};
+		unsubscribeStop = this.onStop(() => {
+			this.onInputCallback = undefined;
+			reject(Object.assign(new Error("Interactive mode stopped"), { code: "cancelled" }));
+		});
 		this.onInputCallback = input => {
 			this.onInputCallback = undefined;
+			unsubscribeStop();
 			resolve(input);
 		};
 		this.#goalModeController.scheduleContinuation();