@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.1

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

@@ -834,45 +834,6 @@ export class InputController {
 			// First, move any pending bash components to chat
 			this.ctx.flushPendingBashComponents();
 
-			// AgentSession.prompt() consumes registered extension commands locally.
-			// Classify them here because title generation starts before prompt dispatch.
-			const extensionCommandSpace = text.indexOf(" ");
-			const isLocalExtensionCommand =
-				text.startsWith("/") &&
-				runner?.getCommand(extensionCommandSpace === -1 ? text.slice(1) : text.slice(1, extensionCommandSpace)) !==
-					undefined;
-
-			// Auto-generate a session title while the session is still unnamed.
-			// Greetings / acknowledgements / empty input carry no task, so they are
-			// skipped deterministically (no model invoked, no download-progress UI)
-			// and the session stays unnamed — the next user message gets a fresh
-			// chance, so titling defers past "hi" instead of latching onto it.
-			if (
-				!isLocalExtensionCommand &&
-				!this.ctx.sessionManager.getSessionName() &&
-				!$env.PI_NO_TITLE &&
-				!isLowSignalTitleInput(text)
-			) {
-				this.#showTinyTitleDownloadProgress(this.ctx.settings.get("providers.tinyModel"));
-				this.ctx.session
-					.generateTitle(text)
-					.then(async title => {
-						// Re-check: a concurrent attempt for an earlier message may have
-						// already named the session. Don't clobber it. Terminal title and
-						// accent updates fire from the onSessionNameChanged listener.
-						if (title && !this.ctx.sessionManager.getSessionName()) {
-							await this.ctx.sessionManager.setSessionName(title, "auto");
-						}
-					})
-					.catch(err => {
-						logger.warn("title-generator: uncaught auto-title error", {
-							sessionId: this.ctx.session.sessionId,
-							reason: "uncaught-auto-title-error",
-							error: err instanceof Error ? err.message : String(err),
-						});
-					});
-			}
-
 			if (this.ctx.onInputCallback) {
 				// Include any pending images from clipboard paste
 				this.ctx.editor.imageLinks = undefined;
@@ -892,6 +853,9 @@ export class InputController {
 					imageLinks: inputImageLinks,
 					streamingBehavior: "steer",
 				});
+				// Start titling only after the optimistic row painted, so the local
+				// tiny-title worker's subprocess spawn never blocks the first frame.
+				this.#maybeStartTitleGeneration(text);
 
 				this.ctx.onInputCallback(submission);
 			} else {
@@ -906,6 +870,7 @@ export class InputController {
 				const images = inputImages && inputImages.length > 0 ? [...inputImages] : undefined;
 				this.ctx.editor.pendingImages = [];
 				this.ctx.editor.pendingImageLinks = [];
+				this.#maybeStartTitleGeneration(text);
 				try {
 					await this.ctx.withLocalSubmission(
 						text,
@@ -935,6 +900,49 @@ export class InputController {
 		};
 	}
 
+	/**
+	 * Kick off session-title generation while the session is still unnamed.
+	 * Invoked AFTER the optimistic user row is painted so the local tiny-title
+	 * worker's subprocess spawn never lands ahead of the first frame (issue #6462).
+	 * Skips slash extension commands (consumed locally by AgentSession.prompt()),
+	 * already-named sessions, PI_NO_TITLE, and low-signal greetings — no model or
+	 * download UI for those.
+	 */
+	#maybeStartTitleGeneration(text: string): void {
+		const runner = this.ctx.session.extensionRunner;
+		const extensionCommandSpace = text.indexOf(" ");
+		const isLocalExtensionCommand =
+			text.startsWith("/") &&
+			runner?.getCommand(extensionCommandSpace === -1 ? text.slice(1) : text.slice(1, extensionCommandSpace)) !==
+				undefined;
+		if (
+			isLocalExtensionCommand ||
+			this.ctx.sessionManager.getSessionName() ||
+			$env.PI_NO_TITLE ||
+			isLowSignalTitleInput(text)
+		) {
+			return;
+		}
+		this.#showTinyTitleDownloadProgress(this.ctx.settings.get("providers.tinyModel"));
+		this.ctx.session
+			.generateTitle(text)
+			.then(async title => {
+				// Re-check: a concurrent attempt for an earlier message may have
+				// already named the session. Don't clobber it. Terminal title and
+				// accent updates fire from the onSessionNameChanged listener.
+				if (title && !this.ctx.sessionManager.getSessionName()) {
+					await this.ctx.sessionManager.setSessionName(title, "auto");
+				}
+			})
+			.catch(err => {
+				logger.warn("title-generator: uncaught auto-title error", {
+					sessionId: this.ctx.session.sessionId,
+					reason: "uncaught-auto-title-error",
+					error: err instanceof Error ? err.message : String(err),
+				});
+			});
+	}
+
 	/** Submit editor text to the focused subagent session (chat-only focus policy). */
 	async #submitToFocusedSession(text: string, streamingBehavior: "steer" | "followUp"): Promise<void> {
 		const target = this.ctx.viewSession;

package/src/modes/controllers/live-command-controller.ts

@@ -0,0 +1,255 @@
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
+import { LiveSessionController, type LiveTranscript } from "../../live/controller";
+import { LIVE_MODEL } from "../../live/protocol";
+import { LiveVisualizer } from "../../live/visualizer";
+import { vocalizer } from "../../tts/vocalizer";
+import type { AssistantMessageComponent } from "../components/assistant-message";
+import type { CustomEditor } from "../components/custom-editor";
+import { theme } from "../theme/theme";
+import type { InteractiveModeContext } from "../types";
+import { createAssistantMessageComponent } from "../utils/interactive-context-helpers";
+
+const ANIMATION_INTERVAL_MS = 80;
+
+const LIVE_MESSAGE_USAGE: AssistantMessage["usage"] = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+function errorFrom(cause: unknown): Error {
+	return cause instanceof Error ? cause : new Error(String(cause));
+}
+
+/** Owns the editor-replacing visualizer and realtime session lifecycle for `/live`. */
+export class LiveCommandController {
+	readonly #ctx: InteractiveModeContext;
+
+	#session: LiveSessionController | undefined;
+	#settling: Promise<void> | undefined;
+	#visualizer: LiveVisualizer | undefined;
+	#detachedEditor: CustomEditor | undefined;
+	#animationInterval: NodeJS.Timeout | undefined;
+	#previousShowHardwareCursor: boolean | undefined;
+	#previousUseTerminalCursor: boolean | undefined;
+	#resumeVocalizer: (() => void) | undefined;
+	#assistantTranscriptComponent: AssistantMessageComponent | undefined;
+	#assistantTranscriptTurn = 0;
+	#assistantTranscriptStartedAt = 0;
+
+	constructor(ctx: InteractiveModeContext) {
+		this.#ctx = ctx;
+	}
+
+	/** Whether a live session is connected, connecting, or closing. */
+	get active(): boolean {
+		return this.#session !== undefined || this.#settling !== undefined;
+	}
+
+	/** Start live mode, or stop the currently active session. */
+	async handleCommand(): Promise<void> {
+		if (this.#session) {
+			await this.stop();
+			return;
+		}
+		if (this.#settling) await this.#settling;
+		await this.#start();
+	}
+
+	/** Stop the active live session and restore the editor. */
+	async stop(): Promise<void> {
+		const session = this.#session;
+		if (!session) {
+			if (this.#settling) await this.#settling;
+			return;
+		}
+		try {
+			await session.stop();
+		} catch (cause) {
+			this.#finish(session, errorFrom(cause));
+		} finally {
+			this.#finish(session);
+		}
+	}
+
+	/** Release UI resources during synchronous InteractiveMode teardown. */
+	dispose(): void {
+		const session = this.#session;
+		if (session) {
+			this.#finish(session);
+			void session.stop().catch(cause => {
+				logger.debug("Live session teardown failed", { error: errorFrom(cause).message });
+			});
+		} else {
+			this.#restoreEditor();
+		}
+	}
+
+	async #start(): Promise<void> {
+		this.#assistantTranscriptTurn = 0;
+		this.#assistantTranscriptStartedAt = 0;
+		const visualizer = new LiveVisualizer({
+			onStop: () => {
+				void this.stop().catch(cause => this.#ctx.showError(errorFrom(cause).message));
+			},
+			onToggleMute: () => this.#session?.toggleMute(),
+		});
+		this.#mountVisualizer(visualizer);
+
+		let session: LiveSessionController;
+		session = new LiveSessionController({
+			session: this.#ctx.session,
+			extractAssistantText: message => this.#ctx.extractAssistantText(message),
+			callbacks: {
+				onPhase: phase => {
+					if (this.#visualizer !== visualizer) return;
+					visualizer.setPhase(phase);
+					this.#ctx.ui.requestComponentRender(visualizer);
+				},
+				onLevels: input => {
+					if (this.#visualizer !== visualizer) return;
+					visualizer.setInputLevel(input);
+					this.#ctx.ui.requestComponentRender(visualizer);
+				},
+				onTranscript: transcript => {
+					if (this.#visualizer !== visualizer) return;
+					if (!transcript) {
+						visualizer.clearTranscript();
+						this.#ctx.ui.requestComponentRender(visualizer);
+					} else if (transcript.role === "user") {
+						visualizer.setTranscript(transcript.text);
+						this.#ctx.ui.requestComponentRender(visualizer);
+					} else {
+						this.#presentAssistantTranscript(transcript);
+					}
+				},
+				onTerminal: error => this.#finish(session, error),
+			},
+		});
+		this.#session = session;
+
+		try {
+			await session.start();
+		} catch (cause) {
+			if (this.#session === session) {
+				await session.stop();
+				this.#finish(session, errorFrom(cause));
+			}
+		}
+	}
+
+	#presentAssistantTranscript(transcript: LiveTranscript): void {
+		if (
+			transcript.turn < this.#assistantTranscriptTurn ||
+			(transcript.turn === this.#assistantTranscriptTurn && !this.#assistantTranscriptComponent)
+		) {
+			return;
+		}
+		if (transcript.turn > this.#assistantTranscriptTurn) {
+			this.#finalizeAssistantTranscript();
+			this.#assistantTranscriptTurn = transcript.turn;
+		}
+
+		let component = this.#assistantTranscriptComponent;
+		if (!component) {
+			component = createAssistantMessageComponent(this.#ctx);
+			component.setTextColorTransform(text => theme.fg("borderAccent", text));
+			this.#assistantTranscriptComponent = component;
+			this.#assistantTranscriptStartedAt = Date.now();
+		}
+		const message: AssistantMessage = {
+			role: "assistant",
+			content: [{ type: "text", text: transcript.text }],
+			api: "openai-codex-responses",
+			provider: "openai-codex",
+			model: LIVE_MODEL,
+			usage: { ...LIVE_MESSAGE_USAGE },
+			stopReason: "stop",
+			timestamp: this.#assistantTranscriptStartedAt,
+		};
+		component.updateContent(message, { transient: !transcript.final });
+		if (transcript.final) {
+			component.markTranscriptBlockFinalized();
+			this.#assistantTranscriptComponent = undefined;
+			this.#assistantTranscriptStartedAt = 0;
+		}
+		if (!this.#ctx.chatContainer.children.includes(component)) {
+			this.#ctx.present(component);
+		} else {
+			this.#ctx.ui.requestComponentRender(component);
+		}
+	}
+
+	#finalizeAssistantTranscript(): void {
+		const component = this.#assistantTranscriptComponent;
+		if (!component) return;
+		component.markTranscriptBlockFinalized();
+		this.#assistantTranscriptComponent = undefined;
+		this.#assistantTranscriptStartedAt = 0;
+		this.#ctx.ui.requestComponentRender(component);
+	}
+
+	#mountVisualizer(visualizer: LiveVisualizer): void {
+		this.#visualizer = visualizer;
+		this.#detachedEditor = this.#ctx.editor;
+		this.#previousShowHardwareCursor = this.#ctx.ui.getShowHardwareCursor();
+		this.#previousUseTerminalCursor = this.#ctx.editor.getUseTerminalCursor();
+		this.#ctx.ui.setShowHardwareCursor(false);
+		this.#ctx.editor.setUseTerminalCursor(false);
+		this.#ctx.editorContainer.clear();
+		this.#ctx.editorContainer.addChild(visualizer);
+		this.#ctx.ui.setFocus(visualizer);
+		this.#resumeVocalizer = vocalizer.suspend();
+		let frame = 0;
+		this.#animationInterval = setInterval(() => {
+			if (this.#visualizer !== visualizer) return;
+			frame += 1;
+			visualizer.setFrame(frame);
+			this.#ctx.ui.requestComponentRender(visualizer);
+		}, ANIMATION_INTERVAL_MS);
+		this.#ctx.ui.requestRender();
+	}
+
+	#finish(session: LiveSessionController, error?: Error): void {
+		if (this.#session !== session) return;
+		this.#session = undefined;
+		this.#restoreEditor();
+		if (error) this.#ctx.showError(error.message);
+		const settling = session.stop().catch(cause => {
+			logger.debug("Live session cleanup failed", { error: errorFrom(cause).message });
+		});
+		this.#settling = settling;
+		void settling.finally(() => {
+			if (this.#settling === settling) this.#settling = undefined;
+		});
+	}
+
+	#restoreEditor(): void {
+		this.#finalizeAssistantTranscript();
+		if (this.#animationInterval) {
+			clearInterval(this.#animationInterval);
+			this.#animationInterval = undefined;
+		}
+		this.#resumeVocalizer?.();
+		this.#resumeVocalizer = undefined;
+		const editor = this.#detachedEditor;
+		this.#detachedEditor = undefined;
+		this.#visualizer = undefined;
+		if (!editor) return;
+		this.#ctx.editorContainer.clear();
+		this.#ctx.editorContainer.addChild(editor);
+		if (this.#previousShowHardwareCursor !== undefined) {
+			this.#ctx.ui.setShowHardwareCursor(this.#previousShowHardwareCursor);
+		}
+		if (this.#previousUseTerminalCursor !== undefined) {
+			editor.setUseTerminalCursor(this.#previousUseTerminalCursor);
+		}
+		this.#previousShowHardwareCursor = undefined;
+		this.#previousUseTerminalCursor = undefined;
+		this.#ctx.ui.setFocus(editor);
+		this.#ctx.ui.requestRender();
+	}
+}

package/src/modes/controllers/mcp-command-controller.ts

@@ -38,6 +38,7 @@ import {
 	getSmitheryApiKey,
 	getSmitheryLoginUrl,
 	pollSmitheryCliAuthSession,
+	type SmitheryCliPollResponse,
 	saveSmitheryApiKey,
 } from "../../mcp/smithery-auth";
 import { SmitheryConnectError } from "../../mcp/smithery-connect";
@@ -51,6 +52,7 @@ import type { MCPAuthChallenge, MCPAuthConfig, MCPServerConfig, MCPServerConnect
 import { shortenPath } from "../../tools/render-utils";
 import { urlHyperlinkAlways } from "../../tui";
 import { copyToClipboard } from "../../utils/clipboard";
+import { isTimeoutError } from "../../utils/fetch-timeout";
 import { openPath } from "../../utils/open";
 import { ChatBlock } from "../components/chat-block";
 import { MCPAddWizard } from "../components/mcp-add-wizard";
@@ -2121,7 +2123,14 @@ export class MCPCommandController {
 			if (Date.now() - startedAt >= timeoutMs) {
 				throw new Error("Smithery authorization timed out after 5 minutes.");
 			}
-			const response = await pollSmitheryCliAuthSession(sessionId, signal);
+			let response: SmitheryCliPollResponse;
+			try {
+				response = await pollSmitheryCliAuthSession(sessionId, signal);
+			} catch (error) {
+				// A single hung/slow poll aborts with TimeoutError; retry until the deadline.
+				if (isTimeoutError(error)) continue;
+				throw error;
+			}
 			if (response.status === "success" && response.apiKey) {
 				return response.apiKey;
 			}

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

@@ -192,56 +192,60 @@ export class OmfgController {
 
 	async #saveCandidate(request: OmfgRequest, candidate: OmfgCandidate): Promise<SaveCandidateResult> {
 		if (this.#shouldStop(request)) return { kind: "aborted" };
-		request.component.setStatus("saving", "Choose where to save or amend the TTSR rule…");
-		const location = await this.ctx.showHookSelector("Save TTSR rule where?", [
-			PROJECT_OPTION,
-			GLOBAL_OPTION,
-			AMEND_OPTION,
-		]);
-		if (!this.#isActiveRequest(request)) return { kind: "aborted" };
-		if (!location) {
-			request.component.markAborted();
-			this.#closeActiveRequest({ abort: false });
-			return { kind: "aborted" };
-		}
 
-		if (location === AMEND_OPTION) {
-			request.component.setStatus("confirming", "Describe how to amend the rule…");
-			const amendment = await this.ctx.showHookInput(
-				"Amend TTSR rule",
-				"e.g. Make it specific to Ruby string eval in tool:write(*.rb)",
-			);
+		for (;;) {
+			request.component.setStatus("saving", "Choose where to save or amend the TTSR rule…");
+			const location = await this.ctx.showHookSelector("Save TTSR rule where?", [
+				PROJECT_OPTION,
+				GLOBAL_OPTION,
+				AMEND_OPTION,
+			]);
 			if (!this.#isActiveRequest(request)) return { kind: "aborted" };
-			const feedback = amendment?.trim();
-			if (!feedback) {
+			if (!location) {
 				request.component.markAborted();
 				this.#closeActiveRequest({ abort: false });
 				return { kind: "aborted" };
 			}
-			return { kind: "amend", feedback };
-		}
 
-		const target = this.#resolveTarget(location, candidate.rule.name);
-		if (await Bun.file(target.filePath).exists()) {
-			const shouldOverwrite = await this.ctx.showHookConfirm(
-				"Overwrite TTSR rule?",
-				`${shortenPath(target.filePath)} already exists. Overwrite it?`,
-			);
-			if (!this.#isActiveRequest(request)) return { kind: "aborted" };
-			if (!shouldOverwrite) {
-				request.component.markRejected();
-				return { kind: "rejected" };
+			if (location === AMEND_OPTION) {
+				request.component.setStatus("confirming", "Describe how to amend the rule…");
+				const amendment = await this.ctx.showHookInput(
+					"Amend TTSR rule",
+					"e.g. Make it specific to Ruby string eval in tool:write(*.rb)",
+				);
+				if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+				const feedback = amendment?.trim();
+				if (!feedback) continue;
+				return { kind: "amend", feedback };
 			}
-		}
 
-		request.component.setStatus("saving", `Saving ${candidate.rule.name}…`);
-		await Bun.write(target.filePath, candidate.fileContent);
-		if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+			const target = this.#resolveTarget(location, candidate.rule.name);
+			if (await Bun.file(target.filePath).exists()) {
+				const shouldOverwrite = await this.ctx.showHookConfirm(
+					"Overwrite TTSR rule?",
+					`${shortenPath(target.filePath)} already exists. Overwrite it?`,
+				);
+				if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+				if (!shouldOverwrite) {
+					request.component.markRejected();
+					return { kind: "rejected" };
+				}
+			}
 
-		const savedRule = buildOmfgRuleForPath(candidate.rule.name, candidate.fileContent, target.filePath, target.level);
-		this.#registerLive(savedRule);
-		request.component.markSaved(shortenPath(target.filePath));
-		return { kind: "saved" };
+			request.component.setStatus("saving", `Saving ${candidate.rule.name}…`);
+			await Bun.write(target.filePath, candidate.fileContent);
+			if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+
+			const savedRule = buildOmfgRuleForPath(
+				candidate.rule.name,
+				candidate.fileContent,
+				target.filePath,
+				target.level,
+			);
+			this.#registerLive(savedRule);
+			request.component.markSaved(shortenPath(target.filePath));
+			return { kind: "saved" };
+		}
 	}
 
 	#resolveTarget(location: string, ruleName: string): { filePath: string; level: OmfgRuleSourceLevel } {

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

@@ -40,6 +40,7 @@ import {
 	theme,
 } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
+import type { SessionOAuthAccountList } from "../../session/agent-session-types";
 import type { ResetCreditAccountStatus, ResetCreditRedeemOutcome } from "../../session/auth-storage";
 import type { SessionInfo } from "../../session/session-listing";
 import { SessionManager } from "../../session/session-manager";
@@ -50,6 +51,7 @@ import {
 	type ResetUsageAccount,
 	toResetUsageAccounts,
 } from "../../slash-commands/helpers/reset-usage";
+import { toSessionPinAccounts } from "../../slash-commands/helpers/session-pin";
 import {
 	AUTO_THINKING,
 	type ConfiguredThinkingLevel,
@@ -57,12 +59,10 @@ import {
 	parseConfiguredThinkingLevel,
 } from "../../thinking";
 import {
-	isImageProviderPreference,
 	isSearchProviderId,
-	isSearchProviderPreference,
 	setExcludedSearchProviders,
-	setPreferredImageProvider,
-	setPreferredSearchProvider,
+	setImageProviderOrder,
+	setSearchProviderOrder,
 	type ToolSession,
 } from "../../tools";
 import { AskTool, type AskToolDetails, type AskToolInput } from "../../tools/ask";
@@ -86,6 +86,7 @@ import { OAuthSelectorComponent } from "../components/oauth-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
 import { ResetUsageSelectorComponent } from "../components/reset-usage-selector";
 import { renderSegmentTrack } from "../components/segment-track";
+import { SessionAccountSelectorComponent } from "../components/session-account-selector";
 import { SessionSelectorComponent } from "../components/session-selector";
 import { SettingsSelectorComponent } from "../components/settings-selector";
 import { ToolExecutionComponent } from "../components/tool-execution";
@@ -439,6 +440,16 @@ export class SelectorController {
 					this.ctx.showError(`Failed to apply personality: ${err}`);
 				});
 				break;
+			case "tools.xdevDocs":
+				void this.ctx.session.refreshBaseSystemPrompt().catch(err => {
+					this.ctx.showError(`Failed to apply xd:// prompt docs setting: ${err}`);
+				});
+				break;
+			case "memory.backend":
+				void this.ctx.session.applyMemoryBackend().catch(err => {
+					this.ctx.showError(`Failed to apply memory backend: ${err}`);
+				});
+				break;
 
 			case "autocompleteMaxVisible":
 				this.ctx.editor.setAutocompleteMaxVisible(typeof value === "number" ? value : Number(value));
@@ -609,9 +620,9 @@ export class SelectorController {
 			}
 
 			// Provider settings - update runtime preferences
-			case "providers.webSearch":
-				if (typeof value === "string" && isSearchProviderPreference(value)) {
-					setPreferredSearchProvider(value);
+			case "providers.webSearchOrder":
+				if (Array.isArray(value)) {
+					setSearchProviderOrder(value.filter(isSearchProviderId));
 				}
 				break;
 			case "providers.webSearchExclude":
@@ -619,9 +630,9 @@ export class SelectorController {
 					setExcludedSearchProviders(value.filter(isSearchProviderId));
 				}
 				break;
-			case "providers.image":
-				if (isImageProviderPreference(value)) {
-					setPreferredImageProvider(value);
+			case "providers.imageOrder":
+				if (Array.isArray(value)) {
+					setImageProviderOrder(value.filter((entry): entry is string => typeof entry === "string"));
 				}
 				break;
 
@@ -1735,6 +1746,65 @@ export class SelectorController {
 		});
 	}
 
+	async showSessionPinSelector(): Promise<void> {
+		const session = this.ctx.session;
+		if (session.isStreaming) {
+			this.ctx.showStatus("Cannot pin an account while the session is streaming.");
+			return;
+		}
+		this.ctx.showStatus("Loading provider accounts…", { dim: true });
+		let accountList: SessionOAuthAccountList | undefined;
+		try {
+			accountList = await session.listCurrentProviderOAuthAccounts();
+		} catch (error) {
+			this.ctx.showError(
+				`Could not load provider accounts: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return;
+		}
+		if (!accountList) {
+			this.ctx.showStatus("Select a model before pinning a provider account.");
+			return;
+		}
+		const provider = getOAuthProviders().find(candidate => candidate.id === accountList.provider);
+		const providerName = provider?.name ?? accountList.provider;
+		const accounts = toSessionPinAccounts(accountList.accounts);
+		if (accounts.length === 0) {
+			const source = session.modelRegistry.authStorage.describeCredentialSource(
+				accountList.provider,
+				session.sessionId,
+			);
+			this.ctx.showStatus(
+				source
+					? `No stored OAuth accounts for ${providerName}. Current auth comes from ${source}.`
+					: `No stored OAuth accounts for ${providerName}. Use /login to add one.`,
+			);
+			return;
+		}
+
+		this.showSelector(done => {
+			const selector = new SessionAccountSelectorComponent(
+				providerName,
+				accounts,
+				account => {
+					done();
+					if (!session.pinCurrentProviderOAuthAccount(account.credentialId)) {
+						this.ctx.showWarning(`${account.label} is no longer available to pin.`);
+						return;
+					}
+					this.ctx.showStatus(`Pinned ${account.label} to this session for ${providerName}.`);
+					this.ctx.statusLine.invalidate();
+					this.ctx.ui.requestRender();
+				},
+				() => {
+					done();
+					this.ctx.ui.requestRender();
+				},
+			);
+			return { component: selector, focus: selector };
+		});
+	}
+
 	async showResetUsageSelector(): Promise<void> {
 		const session = this.ctx.session;
 		this.ctx.showStatus("Checking saved rate-limit resets…", { dim: true });

package/src/modes/controllers/session-focus-controller.ts

@@ -12,6 +12,7 @@
 import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
 import { AgentRegistry, MAIN_AGENT_ID, type RegistryEvent } from "../../registry/agent-registry";
 import type { AgentSession } from "../../session/agent-session";
+import { setTerminalTitleState } from "../../utils/title-generator";
 import type { InteractiveModeContext } from "../types";
 
 export class SessionFocusController {
@@ -104,8 +105,12 @@ export class SessionFocusController {
 		});
 		this.ctx.statusLine.setSession(target, this.#focusedAgentId);
 		this.ctx.renderInitialMessages({ clearTerminalHistory: true });
-		// Mid-turn attach: no agent_start will arrive; arm the loader/turn state manually.
+		// Sync the run-state title to the attached target: a streaming target has no
+		// agent_start incoming, so arm the loader/working title manually; an idle
+		// target would otherwise inherit the previous session's stuck spinner, so
+		// reset it to idle (agent_end teardown already ran via clearTransientSessionUi).
 		if (target.isStreaming) await this.ctx.eventController.handleEvent({ type: "agent_start" });
+		else setTerminalTitleState("idle");
 		this.ctx.updateEditorBorderColor();
 		this.ctx.ui.requestRender();
 	}