@oh-my-pi/pi-coding-agent 3.15.1 → 3.20.0

package/src/modes/interactive/interactive-mode.ts

@@ -25,12 +25,14 @@ import {
 } from "@oh-my-pi/pi-tui";
 import { getAuthPath, getDebugLogPath } from "../../config";
 import type { AgentSession, AgentSessionEvent } from "../../core/agent-session";
-import type { CustomToolSessionEvent, LoadedCustomTool } from "../../core/custom-tools/index";
-import type { HookUIContext } from "../../core/hooks/index";
-import { createCompactionSummaryMessage } from "../../core/messages";
+import type { ExtensionUIContext } from "../../core/extensions/index";
+import { type CustomMessage, createCompactionSummaryMessage } from "../../core/messages";
 import { getRecentSessions, type SessionContext, SessionManager } from "../../core/session-manager";
+import { loadSlashCommands } from "../../core/slash-commands";
+import { detectNotificationProtocol, isNotificationSuppressed, sendNotification } from "../../core/terminal-notify";
 import { generateSessionTitle, setTerminalTitle } from "../../core/title-generator";
 import type { TruncationResult } from "../../core/tools/truncate";
+import { VoiceSupervisor } from "../../core/voice-supervisor";
 import { disableProvider, enableProvider } from "../../discovery";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog";
 import { copyToClipboard, readImageFromClipboard } from "../../utils/clipboard";
@@ -42,11 +44,11 @@ import { BorderedLoader } from "./components/bordered-loader";
 import { BranchSummaryMessageComponent } from "./components/branch-summary-message";
 import { CompactionSummaryMessageComponent } from "./components/compaction-summary-message";
 import { CustomEditor } from "./components/custom-editor";
+import { CustomMessageComponent } from "./components/custom-message";
 import { DynamicBorder } from "./components/dynamic-border";
 import { ExtensionDashboard } from "./components/extensions";
 import { HookEditorComponent } from "./components/hook-editor";
 import { HookInputComponent } from "./components/hook-input";
-import { HookMessageComponent } from "./components/hook-message";
 import { HookSelectorComponent } from "./components/hook-selector";
 import { ModelSelectorComponent } from "./components/model-selector";
 import { OAuthSelectorComponent } from "./components/oauth-selector";
@@ -80,6 +82,10 @@ function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
 
+const VOICE_PROGRESS_DELAY_MS = 15000;
+const VOICE_PROGRESS_MIN_CHARS = 160;
+const VOICE_PROGRESS_DELTA_CHARS = 120;
+
 export class InteractiveMode {
 	private session: AgentSession;
 	private ui: TUI;
@@ -115,6 +121,9 @@ export class InteractiveMode {
 	// Thinking block visibility state
 	private hideThinkingBlock = false;
 
+	// Background mode flag (no UI, no interactive prompts)
+	private isBackgrounded = false;
+
 	// Agent subscription unsubscribe function
 	private unsubscribe?: () => void;
 
@@ -133,6 +142,14 @@ export class InteractiveMode {
 	// Track pending images from clipboard paste (attached to next message)
 	private pendingImages: ImageContent[] = [];
 
+	// Voice mode state
+	private voiceSupervisor: VoiceSupervisor;
+	private voiceAutoModeEnabled = false;
+	private voiceProgressTimer: ReturnType<typeof setTimeout> | undefined = undefined;
+	private voiceProgressSpoken = false;
+	private voiceProgressLastLength = 0;
+	private lastVoiceInterruptAt = 0;
+
 	// Auto-compaction state
 	private autoCompactionLoader: Loader | undefined = undefined;
 	private autoCompactionEscapeHandler?: () => void;
@@ -146,9 +163,6 @@ export class InteractiveMode {
 	private hookInput: HookInputComponent | undefined = undefined;
 	private hookEditor: HookEditorComponent | undefined = undefined;
 
-	// Custom tools for custom rendering
-	private customTools: Map<string, LoadedCustomTool>;
-
 	// Convenience accessors
 	private get agent() {
 		return this.session.agent;
@@ -164,8 +178,7 @@ export class InteractiveMode {
 		session: AgentSession,
 		version: string,
 		changelogMarkdown: string | undefined = undefined,
-		customTools: LoadedCustomTool[] = [],
-		private setToolUIContext: (uiContext: HookUIContext, hasUI: boolean) => void = () => {},
+		private setToolUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void = () => {},
 		private lspServers:
 			| Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }>
 			| undefined = undefined,
@@ -174,7 +187,6 @@ export class InteractiveMode {
 		this.session = session;
 		this.version = version;
 		this.changelogMarkdown = changelogMarkdown;
-		this.customTools = new Map(customTools.map((ct) => [ct.tool.name, ct]));
 		this.ui = new TUI(new ProcessTerminal());
 		this.chatContainer = new Container();
 		this.pendingMessagesContainer = new Container();
@@ -185,6 +197,26 @@ export class InteractiveMode {
 		this.editorContainer.addChild(this.editor);
 		this.statusLine = new StatusLineComponent(session);
 		this.statusLine.setAutoCompactEnabled(session.autoCompactionEnabled);
+		this.voiceSupervisor = new VoiceSupervisor(this.session.modelRegistry, {
+			onSendToAgent: async (text) => {
+				await this.submitVoiceText(text);
+			},
+			onInterruptAgent: async (reason) => {
+				await this.handleVoiceInterrupt(reason);
+			},
+			onStatus: (status) => {
+				this.setVoiceStatus(status);
+			},
+			onError: (error) => {
+				this.showError(error.message);
+				this.voiceAutoModeEnabled = false;
+				void this.voiceSupervisor.stop();
+				this.setVoiceStatus(undefined);
+			},
+			onWarning: (message) => {
+				this.showWarning(message);
+			},
+		});
 
 		// Define slash commands for autocomplete
 		const slashCommands: SlashCommand[] = [
@@ -204,6 +236,8 @@ export class InteractiveMode {
 			{ name: "logout", description: "Logout from OAuth provider" },
 			{ name: "new", description: "Start a new session" },
 			{ name: "compact", description: "Manually compact the session context" },
+			{ name: "background", description: "Detach UI and continue running in background" },
+			{ name: "bg", description: "Alias for /background" },
 			{ name: "resume", description: "Resume a different session" },
 			{ name: "exit", description: "Exit the application" },
 		];
@@ -211,14 +245,15 @@ export class InteractiveMode {
 		// Load hide thinking block setting
 		this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
 
-		// Convert file commands to SlashCommand format
-		const fileSlashCommands: SlashCommand[] = this.session.fileCommands.map((cmd) => ({
+		// Load and convert file commands to SlashCommand format
+		const fileCommands = loadSlashCommands({ cwd: process.cwd() });
+		const fileSlashCommands: SlashCommand[] = fileCommands.map((cmd) => ({
 			name: cmd.name,
 			description: cmd.description,
 		}));
 
 		// Convert hook commands to SlashCommand format
-		const hookCommands: SlashCommand[] = (this.session.hookRunner?.getRegisteredCommands() ?? []).map((cmd) => ({
+		const hookCommands: SlashCommand[] = (this.session.extensionRunner?.getRegisteredCommands() ?? []).map((cmd) => ({
 			name: cmd.name,
 			description: cmd.description ?? "(hook command)",
 		}));
@@ -308,6 +343,10 @@ export class InteractiveMode {
 		this.ui.start();
 		this.isInitialized = true;
 
+		// Set terminal title
+		const cwdBasename = path.basename(process.cwd());
+		this.ui.terminal.setTitle(`pi - ${cwdBasename}`);
+
 		// Initialize hooks with TUI-based UI context
 		await this.initHooksAndCustomTools();
 
@@ -340,12 +379,14 @@ export class InteractiveMode {
 	 */
 	private async initHooksAndCustomTools(): Promise<void> {
 		// Create and set hook & tool UI context
-		const uiContext: HookUIContext = {
+		const uiContext: ExtensionUIContext = {
 			select: (title, options) => this.showHookSelector(title, options),
 			confirm: (title, message) => this.showHookConfirm(title, message),
 			input: (title, placeholder) => this.showHookInput(title, placeholder),
 			notify: (message, type) => this.showHookNotify(message, type),
 			setStatus: (key, text) => this.setHookStatus(key, text),
+			setWidget: (key, content) => this.setHookWidget(key, content),
+			setTitle: (title) => setTerminalTitle(title),
 			custom: (factory) => this.showHookCustom(factory),
 			setEditorText: (text) => this.editor.setText(text),
 			getEditorText: () => this.editor.getText(),
@@ -356,37 +397,34 @@ export class InteractiveMode {
 		};
 		this.setToolUIContext(uiContext, true);
 
-		// Notify custom tools of session start
-		await this.emitCustomToolSessionEvent({
-			reason: "start",
-			previousSessionFile: undefined,
-		});
-
-		const hookRunner = this.session.hookRunner;
-		if (!hookRunner) {
+		const extensionRunner = this.session.extensionRunner;
+		if (!extensionRunner) {
 			return; // No hooks loaded
 		}
 
-		hookRunner.initialize({
+		extensionRunner.initialize({
 			getModel: () => this.session.model,
-			sendMessageHandler: (message, triggerTurn) => {
+			sendMessageHandler: (message, options) => {
 				const wasStreaming = this.session.isStreaming;
 				this.session
-					.sendHookMessage(message, triggerTurn)
+					.sendCustomMessage(message, options)
 					.then(() => {
 						// For non-streaming cases with display=true, update UI
 						// (streaming cases update via message_end event)
-						if (!wasStreaming && message.display) {
+						if (!this.isBackgrounded && !wasStreaming && message.display) {
 							this.rebuildChatFromMessages();
 						}
 					})
 					.catch((err) => {
-						this.showError(`Hook sendMessage failed: ${err instanceof Error ? err.message : String(err)}`);
+						this.showError(`Extension sendMessage failed: ${err instanceof Error ? err.message : String(err)}`);
 					});
 			},
 			appendEntryHandler: (customType, data) => {
 				this.sessionManager.appendCustomEntry(customType, data);
 			},
+			getActiveToolsHandler: () => this.session.getActiveToolNames(),
+			getAllToolsHandler: () => this.session.getAllToolNames(),
+			setActiveToolsHandler: (toolNames: string[]) => this.session.setActiveToolsByName(toolNames),
 			newSessionHandler: async (options) => {
 				// Stop any loading animation
 				if (this.loadingAnimation) {
@@ -456,41 +494,204 @@ export class InteractiveMode {
 			abort: () => {
 				this.session.abort();
 			},
-			hasQueuedMessages: () => this.session.queuedMessageCount > 0,
+			hasPendingMessages: () => this.session.queuedMessageCount > 0,
 			uiContext,
 			hasUI: true,
 		});
 
-		// Subscribe to hook errors
-		hookRunner.onError((error) => {
-			this.showHookError(error.hookPath, error.error);
+		// Subscribe to extension errors
+		extensionRunner.onError((error) => {
+			this.showExtensionError(error.extensionPath, error.error);
 		});
 
 		// Emit session_start event
-		await hookRunner.emit({
+		await extensionRunner.emit({
 			type: "session_start",
 		});
 	}
 
 	/**
-	 * Emit session event to all custom tools.
+	 * Set extension widget content.
+	 */
+	private setHookWidget(key: string, content: unknown): void {
+		this.statusLine.setHookStatus(key, String(content));
+		this.ui.requestRender();
+	}
+
+	private initializeHookRunner(uiContext: ExtensionUIContext, hasUI: boolean): void {
+		const extensionRunner = this.session.extensionRunner;
+		if (!extensionRunner) {
+			return;
+		}
+
+		extensionRunner.initialize({
+			getModel: () => this.session.model,
+			sendMessageHandler: (message, options) => {
+				const wasStreaming = this.session.isStreaming;
+				this.session
+					.sendCustomMessage(message, options)
+					.then(() => {
+						// For non-streaming cases with display=true, update UI
+						// (streaming cases update via message_end event)
+						if (!this.isBackgrounded && !wasStreaming && message.display) {
+							this.rebuildChatFromMessages();
+						}
+					})
+					.catch((err: Error) => {
+						const errorText = `Extension sendMessage failed: ${err instanceof Error ? err.message : String(err)}`;
+						if (this.isBackgrounded) {
+							console.error(errorText);
+							return;
+						}
+						this.showError(errorText);
+					});
+			},
+			appendEntryHandler: (customType, data) => {
+				this.sessionManager.appendCustomEntry(customType, data);
+			},
+			getActiveToolsHandler: () => this.session.getActiveToolNames(),
+			getAllToolsHandler: () => this.session.getAllToolNames(),
+			setActiveToolsHandler: (toolNames) => this.session.setActiveToolsByName(toolNames),
+			newSessionHandler: async (options) => {
+				if (this.isBackgrounded) {
+					return { cancelled: true };
+				}
+				// Stop any loading animation
+				if (this.loadingAnimation) {
+					this.loadingAnimation.stop();
+					this.loadingAnimation = undefined;
+				}
+				this.statusContainer.clear();
+
+				// Create new session
+				const success = await this.session.newSession({ parentSession: options?.parentSession });
+				if (!success) {
+					return { cancelled: true };
+				}
+
+				// Call setup callback if provided
+				if (options?.setup) {
+					await options.setup(this.sessionManager);
+				}
+
+				// Clear UI state
+				this.chatContainer.clear();
+				this.pendingMessagesContainer.clear();
+				this.streamingComponent = undefined;
+				this.streamingMessage = undefined;
+				this.pendingTools.clear();
+
+				this.chatContainer.addChild(new Spacer(1));
+				this.chatContainer.addChild(
+					new Text(`${theme.fg("accent", `${theme.status.success} New session started`)}`, 1, 1),
+				);
+				this.ui.requestRender();
+
+				return { cancelled: false };
+			},
+			branchHandler: async (entryId) => {
+				if (this.isBackgrounded) {
+					return { cancelled: true };
+				}
+				const result = await this.session.branch(entryId);
+				if (result.cancelled) {
+					return { cancelled: true };
+				}
+
+				// Update UI
+				this.chatContainer.clear();
+				this.renderInitialMessages();
+				this.editor.setText(result.selectedText);
+				this.showStatus("Branched to new session");
+
+				return { cancelled: false };
+			},
+			navigateTreeHandler: async (targetId, options) => {
+				if (this.isBackgrounded) {
+					return { cancelled: true };
+				}
+				const result = await this.session.navigateTree(targetId, { summarize: options?.summarize });
+				if (result.cancelled) {
+					return { cancelled: true };
+				}
+
+				// Update UI
+				this.chatContainer.clear();
+				this.renderInitialMessages();
+				if (result.editorText) {
+					this.editor.setText(result.editorText);
+				}
+				this.showStatus("Navigated to selected point");
+
+				return { cancelled: false };
+			},
+			isIdle: () => !this.session.isStreaming,
+			waitForIdle: () => this.session.agent.waitForIdle(),
+			abort: () => {
+				this.session.abort();
+			},
+			hasPendingMessages: () => this.session.queuedMessageCount > 0,
+			uiContext,
+			hasUI,
+		});
+	}
+
+	private createBackgroundUiContext(): ExtensionUIContext {
+		return {
+			select: async (_title: string, _options: string[]) => undefined,
+			confirm: async (_title: string, _message: string) => false,
+			input: async (_title: string, _placeholder?: string) => undefined,
+			notify: () => {},
+			setStatus: () => {},
+			setWidget: () => {},
+			setTitle: () => {},
+			custom: async <T>(
+				_factory: (
+					tui: TUI,
+					theme: Theme,
+					done: (result: T) => void,
+				) => (Component & { dispose?(): void }) | Promise<Component & { dispose?(): void }>,
+			) => undefined as T,
+			setEditorText: () => {},
+			getEditorText: () => "",
+			editor: async () => undefined,
+			get theme() {
+				return theme;
+			},
+		};
+	}
+
+	/**
+	 * Emit session event to all extension tools.
 	 */
-	private async emitCustomToolSessionEvent(event: CustomToolSessionEvent): Promise<void> {
-		for (const { tool } of this.customTools.values()) {
-			if (tool.onSession) {
+	private async emitCustomToolSessionEvent(
+		reason: "start" | "switch" | "branch" | "tree" | "shutdown",
+		previousSessionFile?: string,
+	): Promise<void> {
+		const event = { reason, previousSessionFile };
+		const uiContext = this.session.extensionRunner?.getUIContext();
+		if (!uiContext) {
+			return;
+		}
+		for (const registeredTool of this.session.extensionRunner?.getAllRegisteredTools() ?? []) {
+			if (registeredTool.definition.onSession) {
 				try {
-					await tool.onSession(event, {
+					await registeredTool.definition.onSession(event, {
+						ui: uiContext,
+						hasUI: !this.isBackgrounded,
+						cwd: this.sessionManager.getCwd(),
 						sessionManager: this.session.sessionManager,
 						modelRegistry: this.session.modelRegistry,
 						model: this.session.model,
 						isIdle: () => !this.session.isStreaming,
+						hasPendingMessages: () => this.session.queuedMessageCount > 0,
 						hasQueuedMessages: () => this.session.queuedMessageCount > 0,
 						abort: () => {
 							this.session.abort();
 						},
 					});
 				} catch (err) {
-					this.showToolError(tool.name, err instanceof Error ? err.message : String(err));
+					this.showToolError(registeredTool.definition.name, err instanceof Error ? err.message : String(err));
 				}
 			}
 		}
@@ -500,6 +701,10 @@ export class InteractiveMode {
 	 * Show a tool error in the chat.
 	 */
 	private showToolError(toolName: string, error: string): void {
+		if (this.isBackgrounded) {
+			console.error(`Tool "${toolName}" error: ${error}`);
+			return;
+		}
 		const errorText = new Text(theme.fg("error", `Tool "${toolName}" error: ${error}`), 1, 0);
 		this.chatContainer.addChild(errorText);
 		this.ui.requestRender();
@@ -509,6 +714,9 @@ export class InteractiveMode {
 	 * Set hook status text in the footer.
 	 */
 	private setHookStatus(key: string, text: string | undefined): void {
+		if (this.isBackgrounded) {
+			return;
+		}
 		this.statusLine.setHookStatus(key, text);
 		this.ui.requestRender();
 	}
@@ -679,10 +887,10 @@ export class InteractiveMode {
 	}
 
 	/**
-	 * Show a hook error in the UI.
+	 * Show an extension error in the UI.
 	 */
-	private showHookError(hookPath: string, error: string): void {
-		const errorText = new Text(theme.fg("error", `Hook "${hookPath}" error: ${error}`), 1, 0);
+	private showExtensionError(extensionPath: string, error: string): void {
+		const errorText = new Text(theme.fg("error", `Extension "${extensionPath}" error: ${error}`), 1, 0);
 		this.chatContainer.addChild(errorText);
 		this.ui.requestRender();
 	}
@@ -700,7 +908,7 @@ export class InteractiveMode {
 			if (this.loadingAnimation) {
 				// Abort and restore queued messages to editor
 				const queuedMessages = this.session.clearQueue();
-				const queuedText = queuedMessages.join("\n\n");
+				const queuedText = [...queuedMessages.steering, ...queuedMessages.followUp].join("\n\n");
 				const currentText = this.editor.getText();
 				const combinedText = [queuedText, currentText].filter((t) => t.trim()).join("\n\n");
 				this.editor.setText(combinedText);
@@ -713,10 +921,14 @@ export class InteractiveMode {
 				this.isBashMode = false;
 				this.updateEditorBorderColor();
 			} else if (!this.editor.getText().trim()) {
-				// Double-escape with empty editor triggers /branch
+				// Double-escape with empty editor triggers /tree or /branch based on setting
 				const now = Date.now();
 				if (now - this.lastEscapeTime < 500) {
-					this.showUserMessageSelector();
+					if (this.settingsManager.getDoubleEscapeAction() === "tree") {
+						this.showTreeSelector();
+					} else {
+						this.showUserMessageSelector();
+					}
 					this.lastEscapeTime = 0;
 				} else {
 					this.lastEscapeTime = now;
@@ -730,6 +942,7 @@ export class InteractiveMode {
 		this.editor.onShiftTab = () => this.cycleThinkingLevel();
 		this.editor.onCtrlP = () => this.cycleModel("forward");
 		this.editor.onShiftCtrlP = () => this.cycleModel("backward");
+		this.editor.onCtrlY = () => this.cycleRoleModel();
 
 		// Global debug handler on TUI (works regardless of focus)
 		this.ui.onDebug = () => this.handleDebugCommand();
@@ -737,9 +950,15 @@ export class InteractiveMode {
 		this.editor.onCtrlO = () => this.toggleToolOutputExpansion();
 		this.editor.onCtrlT = () => this.toggleThinkingBlockVisibility();
 		this.editor.onCtrlG = () => this.openExternalEditor();
+		this.editor.onCtrlY = () => {
+			void this.toggleVoiceListening();
+		};
 		this.editor.onQuestionMark = () => this.handleHotkeysCommand();
 		this.editor.onCtrlV = () => this.handleImagePaste();
 
+		// Wire up extension shortcuts
+		this.registerExtensionShortcuts();
+
 		this.editor.onChange = (text: string) => {
 			const wasBashMode = this.isBashMode;
 			this.isBashMode = text.trimStart().startsWith("!");
@@ -747,6 +966,25 @@ export class InteractiveMode {
 				this.updateEditorBorderColor();
 			}
 		};
+
+		this.editor.onAltEnter = async (text: string) => {
+			text = text.trim();
+			if (!text) return;
+
+			// Alt+Enter queues a follow-up message (waits until agent finishes)
+			// This handles extension commands (execute immediately), prompt template expansion, and queueing
+			if (this.session.isStreaming) {
+				this.editor.addToHistory(text);
+				this.editor.setText("");
+				await this.session.prompt(text, { streamingBehavior: "followUp" });
+				this.updatePendingMessagesDisplay();
+				this.ui.requestRender();
+			}
+			// If not streaming, Alt+Enter acts like regular Enter (trigger onSubmit)
+			else if (this.editor.onSubmit) {
+				this.editor.onSubmit(text);
+			}
+		};
 	}
 
 	private setupEditorSubmitHandler(): void {
@@ -801,7 +1039,11 @@ export class InteractiveMode {
 				return;
 			}
 			if (text === "/branch") {
-				this.showUserMessageSelector();
+				if (this.settingsManager.getDoubleEscapeAction() === "tree") {
+					this.showTreeSelector();
+				} else {
+					this.showUserMessageSelector();
+				}
 				this.editor.setText("");
 				return;
 			}
@@ -836,6 +1078,11 @@ export class InteractiveMode {
 				}
 				return;
 			}
+			if (text === "/background" || text === "/bg") {
+				this.editor.setText("");
+				this.handleBackgroundCommand();
+				return;
+			}
 			if (text === "/debug") {
 				this.handleDebugCommand();
 				this.editor.setText("");
@@ -857,9 +1104,10 @@ export class InteractiveMode {
 				return;
 			}
 
-			// Handle bash command
+			// Handle bash command (! for normal, !! for excluded from context)
 			if (text.startsWith("!")) {
-				const command = text.slice(1).trim();
+				const isExcluded = text.startsWith("!!");
+				const command = isExcluded ? text.slice(2).trim() : text.slice(1).trim();
 				if (command) {
 					if (this.session.isBashRunning) {
 						this.showWarning("A bash command is already running. Press Esc to cancel it first.");
@@ -867,7 +1115,7 @@ export class InteractiveMode {
 						return;
 					}
 					this.editor.addToHistory(text);
-					await this.handleBashCommand(command);
+					await this.handleBashCommand(command, isExcluded);
 					this.isBashMode = false;
 					this.updateEditorBorderColor();
 					return;
@@ -879,39 +1127,13 @@ export class InteractiveMode {
 				return;
 			}
 
-			// Hook commands always run immediately, even during streaming
-			// (if they need to interact with LLM, they use pi.sendMessage which handles queueing)
-			if (text.startsWith("/") && this.session.hookRunner) {
-				const spaceIndex = text.indexOf(" ");
-				const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
-				const command = this.session.hookRunner.getCommand(commandName);
-				if (command) {
-					this.editor.addToHistory(text);
-					this.editor.setText("");
-					await this.session.prompt(text);
-					return;
-				}
-			}
-
-			// Custom commands (TypeScript slash commands) - route through session.prompt()
-			if (text.startsWith("/") && this.session.customCommands.length > 0) {
-				const spaceIndex = text.indexOf(" ");
-				const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
-				const hasCustomCommand = this.session.customCommands.some((c) => c.command.name === commandName);
-				if (hasCustomCommand) {
-					this.editor.addToHistory(text);
-					this.editor.setText("");
-					await this.session.prompt(text);
-					return;
-				}
-			}
-
-			// Queue regular messages if agent is streaming
+			// If streaming, use prompt() with steer behavior
+			// This handles extension commands (execute immediately), prompt template expansion, and queueing
 			if (this.session.isStreaming) {
-				await this.session.queueMessage(text);
-				this.updatePendingMessagesDisplay();
 				this.editor.addToHistory(text);
 				this.editor.setText("");
+				await this.session.prompt(text, { streamingBehavior: "steer" });
+				this.updatePendingMessagesDisplay();
 				this.ui.requestRender();
 				return;
 			}
@@ -973,11 +1195,12 @@ export class InteractiveMode {
 					getSymbolTheme().spinnerFrames,
 				);
 				this.statusContainer.addChild(this.loadingAnimation);
+				this.startVoiceProgressTimer();
 				this.ui.requestRender();
 				break;
 
 			case "message_start":
-				if (event.message.role === "hookMessage") {
+				if (event.message.role === "hookMessage" || event.message.role === "custom") {
 					this.addMessageToChat(event.message);
 					this.ui.requestRender();
 				} else if (event.message.role === "user") {
@@ -1003,14 +1226,16 @@ export class InteractiveMode {
 						if (content.type === "toolCall") {
 							if (!this.pendingTools.has(content.id)) {
 								this.chatContainer.addChild(new Text("", 0, 0));
+								const tool = this.session.getToolByName(content.name);
 								const component = new ToolExecutionComponent(
 									content.name,
 									content.arguments,
 									{
 										showImages: this.settingsManager.getShowImages(),
 									},
-									this.customTools.get(content.name)?.tool,
+									tool,
 									this.ui,
+									this.sessionManager.getCwd(),
 								);
 								component.setExpanded(this.toolOutputExpanded);
 								this.chatContainer.addChild(component);
@@ -1071,14 +1296,16 @@ export class InteractiveMode {
 
 			case "tool_execution_start": {
 				if (!this.pendingTools.has(event.toolCallId)) {
+					const tool = this.session.getToolByName(event.toolName);
 					const component = new ToolExecutionComponent(
 						event.toolName,
 						event.args,
 						{
 							showImages: this.settingsManager.getShowImages(),
 						},
-						this.customTools.get(event.toolName)?.tool,
+						tool,
 						this.ui,
+						this.sessionManager.getCwd(),
 					);
 					component.setExpanded(this.toolOutputExpanded);
 					this.chatContainer.addChild(component);
@@ -1108,6 +1335,7 @@ export class InteractiveMode {
 			}
 
 			case "agent_end":
+				this.stopVoiceProgressTimer();
 				if (this.loadingAnimation) {
 					this.loadingAnimation.stop();
 					this.loadingAnimation = undefined;
@@ -1119,7 +1347,17 @@ export class InteractiveMode {
 					this.streamingMessage = undefined;
 				}
 				this.pendingTools.clear();
+				if (this.settingsManager.getVoiceEnabled() && this.voiceAutoModeEnabled) {
+					const lastAssistant = this.findLastAssistantMessage();
+					if (lastAssistant && lastAssistant.stopReason !== "aborted" && lastAssistant.stopReason !== "error") {
+						const text = this.extractAssistantText(lastAssistant);
+						if (text) {
+							this.voiceSupervisor.notifyResult(text);
+						}
+					}
+				}
 				this.ui.requestRender();
+				this.sendCompletionNotification();
 				break;
 
 			case "auto_compaction_start": {
@@ -1232,6 +1470,14 @@ export class InteractiveMode {
 		}
 	}
 
+	private sendCompletionNotification(): void {
+		if (isNotificationSuppressed()) return;
+		const method = this.settingsManager.getNotificationOnComplete();
+		if (method === "off") return;
+		const protocol = method === "auto" ? detectNotificationProtocol() : method;
+		sendNotification(protocol, "Agent complete");
+	}
+
 	/** Extract text content from a user message */
 	private getUserMessageText(message: Message): string {
 		if (message.role !== "user") return "";
@@ -1249,6 +1495,9 @@ export class InteractiveMode {
 	 * we update the previous status line instead of appending new ones to avoid log spam.
 	 */
 	private showStatus(message: string): void {
+		if (this.isBackgrounded) {
+			return;
+		}
 		const children = this.chatContainer.children;
 		const last = children.length > 0 ? children[children.length - 1] : undefined;
 		const secondLast = children.length > 1 ? children[children.length - 2] : undefined;
@@ -1271,7 +1520,7 @@ export class InteractiveMode {
 	private addMessageToChat(message: AgentMessage, options?: { populateHistory?: boolean }): void {
 		switch (message.role) {
 			case "bashExecution": {
-				const component = new BashExecutionComponent(message.command, this.ui);
+				const component = new BashExecutionComponent(message.command, this.ui, message.excludeFromContext);
 				if (message.output) {
 					component.appendOutput(message.output);
 				}
@@ -1284,10 +1533,12 @@ export class InteractiveMode {
 				this.chatContainer.addChild(component);
 				break;
 			}
-			case "hookMessage": {
+			case "hookMessage":
+			case "custom": {
 				if (message.display) {
-					const renderer = this.session.hookRunner?.getMessageRenderer(message.customType);
-					this.chatContainer.addChild(new HookMessageComponent(message, renderer));
+					const renderer = this.session.extensionRunner?.getMessageRenderer(message.customType);
+					// Both HookMessage and CustomMessage have the same structure, cast for compatibility
+					this.chatContainer.addChild(new CustomMessageComponent(message as CustomMessage<unknown>, renderer));
 				}
 				break;
 			}
@@ -1363,12 +1614,14 @@ export class InteractiveMode {
 				// Render tool call components
 				for (const content of message.content) {
 					if (content.type === "toolCall") {
+						const tool = this.session.getToolByName(content.name);
 						const component = new ToolExecutionComponent(
 							content.name,
 							content.arguments,
 							{ showImages: this.settingsManager.getShowImages() },
-							this.customTools.get(content.name)?.tool,
+							tool,
 							this.ui,
+							this.sessionManager.getCwd(),
 						);
 						component.setExpanded(this.toolOutputExpanded);
 						this.chatContainer.addChild(component);
@@ -1455,18 +1708,13 @@ export class InteractiveMode {
 	 * Emits shutdown event to hooks and tools, then exits.
 	 */
 	private async shutdown(): Promise<void> {
+		this.voiceAutoModeEnabled = false;
+		await this.voiceSupervisor.stop();
+
 		// Flush pending session writes before shutdown
 		await this.sessionManager.flush();
 
 		// Emit shutdown event to hooks
-		const hookRunner = this.session.hookRunner;
-		if (hookRunner?.hasHandlers("session_shutdown")) {
-			await hookRunner.emit({
-				type: "session_shutdown",
-			});
-		}
-
-		// Emit shutdown event to custom tools
 		await this.session.emitCustomToolSessionEvent("shutdown");
 
 		this.stop();
@@ -1487,6 +1735,72 @@ export class InteractiveMode {
 		process.kill(0, "SIGTSTP");
 	}
 
+	private handleBackgroundCommand(): void {
+		if (this.isBackgrounded) {
+			this.showStatus("Background mode already enabled");
+			return;
+		}
+		if (!this.session.isStreaming && this.session.queuedMessageCount === 0) {
+			this.showWarning("Agent is idle; nothing to background");
+			return;
+		}
+
+		this.isBackgrounded = true;
+		const backgroundUiContext = this.createBackgroundUiContext();
+
+		// Background mode disables interactive UI so tools like ask fail fast.
+		this.setToolUIContext(backgroundUiContext, false);
+		this.initializeHookRunner(backgroundUiContext, false);
+
+		if (this.loadingAnimation) {
+			this.loadingAnimation.stop();
+			this.loadingAnimation = undefined;
+		}
+		if (this.autoCompactionLoader) {
+			this.autoCompactionLoader.stop();
+			this.autoCompactionLoader = undefined;
+		}
+		if (this.retryLoader) {
+			this.retryLoader.stop();
+			this.retryLoader = undefined;
+		}
+		this.statusContainer.clear();
+		this.statusLine.dispose();
+
+		if (this.unsubscribe) {
+			this.unsubscribe();
+		}
+		this.unsubscribe = this.session.subscribe(async (event) => {
+			await this.handleBackgroundEvent(event);
+		});
+
+		// Backgrounding keeps the current process to preserve in-flight agent state.
+		if (this.isInitialized) {
+			this.ui.stop();
+			this.isInitialized = false;
+		}
+
+		process.stdout.write("Background mode enabled. Run `bg` to continue in background.\n");
+
+		if (process.platform === "win32" || !process.stdout.isTTY) {
+			process.stdout.write("Backgrounding requires POSIX job control; continuing in foreground.\n");
+			return;
+		}
+
+		process.kill(0, "SIGTSTP");
+	}
+
+	private async handleBackgroundEvent(event: AgentSessionEvent): Promise<void> {
+		if (event.type !== "agent_end") {
+			return;
+		}
+		if (this.session.queuedMessageCount > 0 || this.session.isStreaming) {
+			return;
+		}
+		this.sendCompletionNotification();
+		await this.shutdown();
+	}
+
 	/**
 	 * Handle Ctrl+V for image paste from clipboard.
 	 * Returns true if an image was found and added, false otherwise.
@@ -1516,6 +1830,138 @@ export class InteractiveMode {
 		}
 	}
 
+	private setVoiceStatus(text: string | undefined): void {
+		this.statusLine.setHookStatus("voice", text);
+		this.ui.requestRender();
+	}
+
+	private async handleVoiceInterrupt(reason?: string): Promise<void> {
+		const now = Date.now();
+		if (now - this.lastVoiceInterruptAt < 200) return;
+		this.lastVoiceInterruptAt = now;
+		if (this.session.isBashRunning) {
+			this.session.abortBash();
+		}
+		if (this.session.isStreaming) {
+			await this.session.abort();
+		}
+		if (reason) {
+			this.showStatus(reason);
+		}
+	}
+
+	private stopVoiceProgressTimer(): void {
+		if (this.voiceProgressTimer) {
+			clearTimeout(this.voiceProgressTimer);
+			this.voiceProgressTimer = undefined;
+		}
+	}
+
+	private startVoiceProgressTimer(): void {
+		this.stopVoiceProgressTimer();
+		if (!this.settingsManager.getVoiceEnabled() || !this.voiceAutoModeEnabled) return;
+		this.voiceProgressSpoken = false;
+		this.voiceProgressLastLength = 0;
+		this.voiceProgressTimer = setTimeout(() => {
+			void this.maybeSpeakProgress();
+		}, VOICE_PROGRESS_DELAY_MS);
+	}
+
+	private async maybeSpeakProgress(): Promise<void> {
+		if (!this.session.isStreaming || this.voiceProgressSpoken || !this.voiceAutoModeEnabled) return;
+		const streaming = this.streamingMessage;
+		if (!streaming) return;
+		const text = this.extractAssistantText(streaming);
+		if (!text || text.length < VOICE_PROGRESS_MIN_CHARS) {
+			if (this.session.isStreaming) {
+				this.voiceProgressTimer = setTimeout(() => {
+					void this.maybeSpeakProgress();
+				}, VOICE_PROGRESS_DELAY_MS);
+			}
+			return;
+		}
+
+		const delta = text.length - this.voiceProgressLastLength;
+		if (delta < VOICE_PROGRESS_DELTA_CHARS) {
+			if (this.session.isStreaming) {
+				this.voiceProgressTimer = setTimeout(() => {
+					void this.maybeSpeakProgress();
+				}, VOICE_PROGRESS_DELAY_MS);
+			}
+			return;
+		}
+
+		this.voiceProgressLastLength = text.length;
+		this.voiceProgressSpoken = true;
+		this.voiceSupervisor.notifyProgress(text);
+	}
+
+	private async toggleVoiceListening(): Promise<void> {
+		if (!this.settingsManager.getVoiceEnabled()) {
+			this.settingsManager.setVoiceEnabled(true);
+			this.showStatus("Voice mode enabled.");
+		}
+
+		if (this.voiceAutoModeEnabled) {
+			this.voiceAutoModeEnabled = false;
+			this.stopVoiceProgressTimer();
+			await this.voiceSupervisor.stop();
+			this.setVoiceStatus(undefined);
+			this.showStatus("Voice mode disabled.");
+			return;
+		}
+
+		this.voiceAutoModeEnabled = true;
+		try {
+			await this.voiceSupervisor.start();
+		} catch (error) {
+			this.voiceAutoModeEnabled = false;
+			this.setVoiceStatus(undefined);
+			this.showError(error instanceof Error ? error.message : String(error));
+		}
+	}
+
+	private async submitVoiceText(text: string): Promise<void> {
+		const cleaned = text.trim();
+		if (!cleaned) {
+			this.showWarning("No speech detected. Try again.");
+			return;
+		}
+		const toSend = cleaned;
+		this.editor.addToHistory(toSend);
+
+		if (this.session.isStreaming) {
+			await this.session.abort();
+			await this.session.steer(toSend);
+			this.updatePendingMessagesDisplay();
+			return;
+		}
+
+		if (this.onInputCallback) {
+			this.onInputCallback({ text: toSend });
+		}
+	}
+
+	private findLastAssistantMessage(): AssistantMessage | undefined {
+		for (let i = this.session.messages.length - 1; i >= 0; i--) {
+			const message = this.session.messages[i];
+			if (message?.role === "assistant") {
+				return message as AssistantMessage;
+			}
+		}
+		return undefined;
+	}
+
+	private extractAssistantText(message: AssistantMessage): string {
+		let text = "";
+		for (const content of message.content) {
+			if (content.type === "text") {
+				text += content.text;
+			}
+		}
+		return text.trim();
+	}
+
 	private updateEditorBorderColor(): void {
 		if (this.isBashMode) {
 			this.editor.borderColor = theme.getBashModeBorderColor();
@@ -1562,6 +2008,25 @@ export class InteractiveMode {
 		}
 	}
 
+	private async cycleRoleModel(): Promise<void> {
+		try {
+			const result = await this.session.cycleRoleModels(["slow", "default", "smol"]);
+			if (!result) {
+				this.showStatus("Only one role model available");
+				return;
+			}
+
+			this.statusLine.invalidate();
+			this.updateEditorBorderColor();
+			const roleLabel = result.role === "default" ? "default" : result.role;
+			const thinkingStr =
+				result.model.reasoning && result.thinkingLevel !== "off" ? ` (thinking: ${result.thinkingLevel})` : "";
+			this.showStatus(`Switched to ${roleLabel}: ${result.model.name || result.model.id}${thinkingStr}`);
+		} catch (error) {
+			this.showError(error instanceof Error ? error.message : String(error));
+		}
+	}
+
 	private toggleToolOutputExpansion(): void {
 		this.toolOutputExpanded = !this.toolOutputExpanded;
 		for (const child of this.chatContainer.children) {
@@ -1643,18 +2108,29 @@ export class InteractiveMode {
 	// =========================================================================
 
 	clearEditor(): void {
+		if (this.isBackgrounded) {
+			return;
+		}
 		this.editor.setText("");
 		this.pendingImages = [];
 		this.ui.requestRender();
 	}
 
 	showError(errorMessage: string): void {
+		if (this.isBackgrounded) {
+			console.error(`Error: ${errorMessage}`);
+			return;
+		}
 		this.chatContainer.addChild(new Spacer(1));
 		this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), 1, 0));
 		this.ui.requestRender();
 	}
 
 	showWarning(warningMessage: string): void {
+		if (this.isBackgrounded) {
+			console.error(`Warning: ${warningMessage}`);
+			return;
+		}
 		this.chatContainer.addChild(new Spacer(1));
 		this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
 		this.ui.requestRender();
@@ -1680,10 +2156,13 @@ export class InteractiveMode {
 	private updatePendingMessagesDisplay(): void {
 		this.pendingMessagesContainer.clear();
 		const queuedMessages = this.session.getQueuedMessages();
-		if (queuedMessages.length > 0) {
+		const steeringMessages = queuedMessages.steering.map((message) => ({ message, label: "Steer" }));
+		const followUpMessages = queuedMessages.followUp.map((message) => ({ message, label: "Follow-up" }));
+		const allMessages = [...steeringMessages, ...followUpMessages];
+		if (allMessages.length > 0) {
 			this.pendingMessagesContainer.addChild(new Spacer(1));
-			for (const message of queuedMessages) {
-				const queuedText = theme.fg("dim", `Queued: ${message}`);
+			for (const entry of allMessages) {
+				const queuedText = theme.fg("dim", `${entry.label}: ${entry.message}`);
 				this.pendingMessagesContainer.addChild(new TruncatedText(queuedText, 1, 0));
 			}
 		}
@@ -1804,8 +2283,11 @@ export class InteractiveMode {
 				this.session.setAutoCompactionEnabled(value as boolean);
 				this.statusLine.setAutoCompactEnabled(value as boolean);
 				break;
-			case "queueMode":
-				this.session.setQueueMode(value as "all" | "one-at-a-time");
+			case "steeringMode":
+				this.session.setSteeringMode(value as "all" | "one-at-a-time");
+				break;
+			case "followUpMode":
+				this.session.setFollowUpMode(value as "all" | "one-at-a-time");
 				break;
 			case "interruptMode":
 				this.session.setInterruptMode(value as "immediate" | "wait");
@@ -1851,6 +2333,15 @@ export class InteractiveMode {
 				this.ui.invalidate();
 				break;
 			}
+			case "voiceEnabled": {
+				if (!value) {
+					this.voiceAutoModeEnabled = false;
+					this.stopVoiceProgressTimer();
+					void this.voiceSupervisor.stop();
+					this.setVoiceStatus(undefined);
+				}
+				break;
+			}
 			case "statusLinePreset":
 			case "statusLineSeparator":
 			case "statusLineShowHooks":
@@ -2157,7 +2648,7 @@ export class InteractiveMode {
 								},
 							});
 							// Refresh models to pick up new baseUrl (e.g., github-copilot)
-							this.session.modelRegistry.refresh();
+							await this.session.modelRegistry.refresh();
 							this.chatContainer.addChild(new Spacer(1));
 							this.chatContainer.addChild(
 								new Text(
@@ -2175,9 +2666,9 @@ export class InteractiveMode {
 						}
 					} else {
 						try {
-							this.session.modelRegistry.authStorage.logout(providerId);
+							await this.session.modelRegistry.authStorage.logout(providerId);
 							// Refresh models to reset baseUrl
-							this.session.modelRegistry.refresh();
+							await this.session.modelRegistry.refresh();
 							this.chatContainer.addChild(new Spacer(1));
 							this.chatContainer.addChild(
 								new Text(
@@ -2209,8 +2700,17 @@ export class InteractiveMode {
 	// =========================================================================
 
 	private openInBrowser(urlOrPath: string): void {
-		const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-		Bun.spawn([openCmd, urlOrPath], { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+		try {
+			const args =
+				process.platform === "darwin"
+					? ["open", urlOrPath]
+					: process.platform === "win32"
+						? ["cmd", "/c", "start", "", urlOrPath]
+						: ["xdg-open", urlOrPath];
+			Bun.spawn(args, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+		} catch {
+			// Best-effort: browser opening is non-critical
+		}
 	}
 
 	private async handleExportCommand(text: string): Promise<void> {
@@ -2379,7 +2879,7 @@ export class InteractiveMode {
 		const stats = this.session.getSessionStats();
 
 		let info = `${theme.bold("Session Info")}\n\n`;
-		info += `${theme.fg("dim", "File:")} ${stats.sessionFile}\n`;
+		info += `${theme.fg("dim", "File:")} ${stats.sessionFile ?? "In-memory"}\n`;
 		info += `${theme.fg("dim", "ID:")} ${stats.sessionId}\n\n`;
 		info += `${theme.bold("Messages")}\n`;
 		info += `${theme.fg("dim", "User:")} ${stats.userMessages}\n`;
@@ -2429,6 +2929,31 @@ export class InteractiveMode {
 		this.ui.requestRender();
 	}
 
+	/**
+	 * Register extension-defined keyboard shortcuts with the editor.
+	 */
+	private registerExtensionShortcuts(): void {
+		const runner = this.session.extensionRunner;
+		if (!runner) return;
+
+		const shortcuts = runner.getShortcuts();
+		for (const [keyId, shortcut] of shortcuts) {
+			this.editor.setCustomKeyHandler(keyId, () => {
+				const ctx = runner.createCommandContext();
+				try {
+					shortcut.handler(ctx);
+				} catch (err) {
+					runner.emitError({
+						extensionPath: shortcut.extensionPath,
+						event: "shortcut",
+						error: err instanceof Error ? err.message : String(err),
+						stack: err instanceof Error ? err.stack : undefined,
+					});
+				}
+			});
+		}
+	}
+
 	private handleHotkeysCommand(): void {
 		const hotkeys = `
 **Navigation**
@@ -2458,6 +2983,7 @@ export class InteractiveMode {
 | \`Ctrl+Z\` | Suspend to background |
 | \`Shift+Tab\` | Cycle thinking level |
 | \`Ctrl+P\` | Cycle models |
+| \`Ctrl+Y\` | Cycle role models (slow/default/smol) |
 | \`Ctrl+O\` | Toggle tool output expansion |
 | \`Ctrl+T\` | Toggle thinking block visibility |
 | \`Ctrl+G\` | Edit message in external editor |
@@ -2544,9 +3070,9 @@ export class InteractiveMode {
 		this.ui.requestRender();
 	}
 
-	private async handleBashCommand(command: string): Promise<void> {
+	private async handleBashCommand(command: string, excludeFromContext = false): Promise<void> {
 		const isDeferred = this.session.isStreaming;
-		this.bashComponent = new BashExecutionComponent(command, this.ui);
+		this.bashComponent = new BashExecutionComponent(command, this.ui, excludeFromContext);
 
 		if (isDeferred) {
 			// Show in pending area when agent is streaming
@@ -2559,12 +3085,16 @@ export class InteractiveMode {
 		this.ui.requestRender();
 
 		try {
-			const result = await this.session.executeBash(command, (chunk) => {
-				if (this.bashComponent) {
-					this.bashComponent.appendOutput(chunk);
-					this.ui.requestRender();
-				}
-			});
+			const result = await this.session.executeBash(
+				command,
+				(chunk) => {
+					if (this.bashComponent) {
+						this.bashComponent.appendOutput(chunk);
+						this.ui.requestRender();
+					}
+				},
+				{ excludeFromContext },
+			);
 
 			if (this.bashComponent) {
 				this.bashComponent.setComplete(