@oh-my-pi/pi-coding-agent 14.0.4 → 14.1.0

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

@@ -13,6 +13,12 @@ import type { AgentSessionEvent } from "../../session/agent-session";
 import { calculatePromptTokens } from "../../session/compaction/compaction";
 import type { ExitPlanModeDetails } from "../../tools";
 
+type AgentSessionEventKind = AgentSessionEvent["type"];
+
+type AgentSessionEventHandlers = {
+	[E in AgentSessionEventKind]: (event: Extract<AgentSessionEvent, { type: E }>) => Promise<void>;
+};
+
 export class EventController {
 	#lastReadGroup: ReadToolGroupComponent | undefined = undefined;
 	#lastThinkingCount = 0;
@@ -23,7 +29,31 @@ export class EventController {
 	#readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
 	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
 	#idleCompactionTimer?: NodeJS.Timeout;
-	constructor(private ctx: InteractiveModeContext) {}
+	#handlers: AgentSessionEventHandlers;
+
+	constructor(private ctx: InteractiveModeContext) {
+		this.#handlers = {
+			agent_start: e => this.#handleAgentStart(e),
+			agent_end: e => this.#handleAgentEnd(e),
+			turn_start: async () => {},
+			turn_end: async () => {},
+			message_start: e => this.#handleMessageStart(e),
+			message_update: e => this.#handleMessageUpdate(e),
+			message_end: e => this.#handleMessageEnd(e),
+			tool_execution_start: e => this.#handleToolExecutionStart(e),
+			tool_execution_update: e => this.#handleToolExecutionUpdate(e),
+			tool_execution_end: e => this.#handleToolExecutionEnd(e),
+			auto_compaction_start: e => this.#handleAutoCompactionStart(e),
+			auto_compaction_end: e => this.#handleAutoCompactionEnd(e),
+			auto_retry_start: e => this.#handleAutoRetryStart(e),
+			auto_retry_end: e => this.#handleAutoRetryEnd(e),
+			retry_fallback_applied: e => this.#handleRetryFallbackApplied(e),
+			retry_fallback_succeeded: e => this.#handleRetryFallbackSucceeded(e),
+			ttsr_triggered: e => this.#handleTtsrTriggered(e),
+			todo_reminder: e => this.#handleTodoReminder(e),
+			todo_auto_clear: e => this.#handleTodoAutoClear(e),
+		} satisfies AgentSessionEventHandlers;
+	}
 
 	dispose(): void {
 		this.#cancelIdleCompaction();
@@ -98,203 +128,114 @@ export class EventController {
 		this.ctx.statusLine.invalidate();
 		this.ctx.updateEditorTopBorder();
 
-		switch (event.type) {
-			case "agent_start":
-				this.#lastIntent = undefined;
-				this.#readToolCallArgs.clear();
-				this.#readToolCallAssistantComponents.clear();
-				this.#lastAssistantComponent = undefined;
-				if (this.ctx.retryEscapeHandler) {
-					this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
-					this.ctx.retryEscapeHandler = undefined;
-				}
-				if (this.ctx.retryLoader) {
-					this.ctx.retryLoader.stop();
-					this.ctx.retryLoader = undefined;
-					this.ctx.statusContainer.clear();
-				}
-				this.#cancelIdleCompaction();
-				this.ctx.ensureLoadingAnimation();
-				this.ctx.ui.requestRender();
-				break;
-
-			case "message_start":
-				if (event.message.role === "hookMessage" || event.message.role === "custom") {
-					const signature = `${event.message.role}:${event.message.customType}:${event.message.timestamp}`;
-					if (this.#renderedCustomMessages.has(signature)) {
-						break;
-					}
-					this.#renderedCustomMessages.add(signature);
-					this.#resetReadGroup();
-					this.ctx.addMessageToChat(event.message);
-					this.ctx.ui.requestRender();
-				} else if (event.message.role === "user") {
-					const textContent = this.ctx.getUserMessageText(event.message);
-					const imageCount =
-						typeof event.message.content === "string"
-							? 0
-							: event.message.content.filter(content => content.type === "image").length;
-					const signature = `${textContent}\u0000${imageCount}`;
+		const run = this.#handlers[event.type] as (e: AgentSessionEvent) => Promise<void>;
+		await run(event);
+	}
 
-					this.#resetReadGroup();
-					if (this.ctx.optimisticUserMessageSignature !== signature) {
-						this.ctx.addMessageToChat(event.message);
-					}
-					this.ctx.optimisticUserMessageSignature = undefined;
+	async #handleAgentStart(_event: Extract<AgentSessionEvent, { type: "agent_start" }>): Promise<void> {
+		this.#lastIntent = undefined;
+		this.#readToolCallArgs.clear();
+		this.#readToolCallAssistantComponents.clear();
+		this.#lastAssistantComponent = undefined;
+		if (this.ctx.retryEscapeHandler) {
+			this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
+			this.ctx.retryEscapeHandler = undefined;
+		}
+		if (this.ctx.retryLoader) {
+			this.ctx.retryLoader.stop();
+			this.ctx.retryLoader = undefined;
+			this.ctx.statusContainer.clear();
+		}
+		this.#cancelIdleCompaction();
+		this.ctx.ensureLoadingAnimation();
+		this.ctx.ui.requestRender();
+	}
 
-					if (!event.message.synthetic) {
-						this.ctx.editor.setText("");
-						this.ctx.updatePendingMessagesDisplay();
-					}
-					this.ctx.ui.requestRender();
-				} else if (event.message.role === "fileMention") {
-					this.#resetReadGroup();
-					this.ctx.addMessageToChat(event.message);
-					this.ctx.ui.requestRender();
-				} else if (event.message.role === "assistant") {
-					this.#lastThinkingCount = 0;
-					this.#resetReadGroup();
-					this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock);
-					this.ctx.streamingMessage = event.message;
-					this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
-					this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
-					this.ctx.ui.requestRender();
-				}
-				break;
-
-			case "message_update":
-				if (this.ctx.streamingComponent && event.message.role === "assistant") {
-					this.ctx.streamingMessage = event.message;
-					this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
-
-					const thinkingCount = this.ctx.streamingMessage.content.filter(
-						content => content.type === "thinking" && content.thinking.trim(),
-					).length;
-					if (thinkingCount > this.#lastThinkingCount) {
-						this.#resetReadGroup();
-						this.#lastThinkingCount = thinkingCount;
-					}
+	async #handleMessageStart(event: Extract<AgentSessionEvent, { type: "message_start" }>): Promise<void> {
+		if (event.message.role === "hookMessage" || event.message.role === "custom") {
+			const signature = `${event.message.role}:${event.message.customType}:${event.message.timestamp}`;
+			if (this.#renderedCustomMessages.has(signature)) {
+				return;
+			}
+			this.#renderedCustomMessages.add(signature);
+			this.#resetReadGroup();
+			this.ctx.addMessageToChat(event.message);
+			this.ctx.ui.requestRender();
+		} else if (event.message.role === "user") {
+			const textContent = this.ctx.getUserMessageText(event.message);
+			const imageCount =
+				typeof event.message.content === "string"
+					? 0
+					: event.message.content.filter(content => content.type === "image").length;
+			const signature = `${textContent}\u0000${imageCount}`;
+
+			this.#resetReadGroup();
+			if (this.ctx.optimisticUserMessageSignature !== signature) {
+				this.ctx.addMessageToChat(event.message);
+			}
+			this.ctx.optimisticUserMessageSignature = undefined;
 
-					for (const content of this.ctx.streamingMessage.content) {
-						if (content.type !== "toolCall") continue;
-						if (content.name === "read") {
-							this.#trackReadToolCall(content.id, content.arguments);
-							const component = this.ctx.pendingTools.get(content.id);
-							if (component) {
-								component.updateArgs(content.arguments, content.id);
-							} else {
-								const group = this.#getReadGroup();
-								group.updateArgs(content.arguments, content.id);
-								this.ctx.pendingTools.set(content.id, group);
-							}
-							continue;
-						}
-
-						// Preserve the raw partial JSON for renderers that need to surface fields before the JSON object closes.
-						// Bash uses this to show inline env assignments during streaming instead of popping them in at completion.
-						const renderArgs =
-							"partialJson" in content
-								? { ...content.arguments, __partialJson: content.partialJson }
-								: content.arguments;
-						if (!this.ctx.pendingTools.has(content.id)) {
-							this.#resetReadGroup();
-							this.ctx.chatContainer.addChild(new Text("", 0, 0));
-							const tool = this.ctx.session.getToolByName(content.name);
-							const component = new ToolExecutionComponent(
-								content.name,
-								renderArgs,
-								{
-									showImages: settings.get("terminal.showImages"),
-									editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),
-									editAllowFuzzy: settings.get("edit.fuzzyMatch"),
-								},
-								tool,
-								this.ctx.ui,
-								this.ctx.sessionManager.getCwd(),
-							);
-							component.setExpanded(this.ctx.toolOutputExpanded);
-							this.ctx.chatContainer.addChild(component);
-							this.ctx.pendingTools.set(content.id, component);
-						} else {
-							const component = this.ctx.pendingTools.get(content.id);
-							if (component) {
-								component.updateArgs(renderArgs, content.id);
-							}
-						}
-					}
+			if (!event.message.synthetic) {
+				this.ctx.editor.setText("");
+				this.ctx.updatePendingMessagesDisplay();
+			}
+			this.ctx.ui.requestRender();
+		} else if (event.message.role === "fileMention") {
+			this.#resetReadGroup();
+			this.ctx.addMessageToChat(event.message);
+			this.ctx.ui.requestRender();
+		} else if (event.message.role === "assistant") {
+			this.#lastThinkingCount = 0;
+			this.#resetReadGroup();
+			this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock);
+			this.ctx.streamingMessage = event.message;
+			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
+			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+			this.ctx.ui.requestRender();
+		}
+	}
 
-					// Update working message with intent from streamed tool arguments
-					for (const content of this.ctx.streamingMessage.content) {
-						if (content.type !== "toolCall") continue;
-						const args = content.arguments;
-						if (!args || typeof args !== "object" || !(INTENT_FIELD in args)) continue;
-						this.#updateWorkingMessageFromIntent(args[INTENT_FIELD] as string | undefined);
-					}
+	async #handleMessageUpdate(event: Extract<AgentSessionEvent, { type: "message_update" }>): Promise<void> {
+		if (this.ctx.streamingComponent && event.message.role === "assistant") {
+			this.ctx.streamingMessage = event.message;
+			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+
+			const thinkingCount = this.ctx.streamingMessage.content.filter(
+				content => content.type === "thinking" && content.thinking.trim(),
+			).length;
+			if (thinkingCount > this.#lastThinkingCount) {
+				this.#resetReadGroup();
+				this.#lastThinkingCount = thinkingCount;
+			}
 
-					this.ctx.ui.requestRender();
-				}
-				break;
-
-			case "message_end":
-				if (event.message.role === "user") break;
-				if (this.ctx.streamingComponent && event.message.role === "assistant") {
-					this.ctx.streamingMessage = event.message;
-					let errorMessage: string | undefined;
-					if (this.ctx.streamingMessage.stopReason === "aborted" && !this.ctx.session.isTtsrAbortPending) {
-						const retryAttempt = this.ctx.session.retryAttempt;
-						errorMessage =
-							retryAttempt > 0
-								? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
-								: "Operation aborted";
-						this.ctx.streamingMessage.errorMessage = errorMessage;
-					}
-					if (this.ctx.session.isTtsrAbortPending && this.ctx.streamingMessage.stopReason === "aborted") {
-						const msgWithoutAbort = { ...this.ctx.streamingMessage, stopReason: "stop" as const };
-						this.ctx.streamingComponent.updateContent(msgWithoutAbort);
+			for (const content of this.ctx.streamingMessage.content) {
+				if (content.type !== "toolCall") continue;
+				if (content.name === "read") {
+					this.#trackReadToolCall(content.id, content.arguments);
+					const component = this.ctx.pendingTools.get(content.id);
+					if (component) {
+						component.updateArgs(content.arguments, content.id);
 					} else {
-						this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+						const group = this.#getReadGroup();
+						group.updateArgs(content.arguments, content.id);
+						this.ctx.pendingTools.set(content.id, group);
 					}
-
-					if (
-						this.ctx.streamingMessage.stopReason !== "aborted" &&
-						this.ctx.streamingMessage.stopReason !== "error"
-					) {
-						for (const [toolCallId, component] of this.ctx.pendingTools.entries()) {
-							component.setArgsComplete(toolCallId);
-						}
-					}
-					this.#lastAssistantComponent = this.ctx.streamingComponent;
-					this.#lastAssistantComponent.setUsageInfo(event.message.usage);
-					this.ctx.streamingComponent = undefined;
-					this.ctx.streamingMessage = undefined;
-					this.ctx.statusLine.invalidate();
-					this.ctx.updateEditorTopBorder();
+					continue;
 				}
-				this.ctx.ui.requestRender();
-				break;
-
-			case "tool_execution_start": {
-				this.#updateWorkingMessageFromIntent(event.intent);
-				if (!this.ctx.pendingTools.has(event.toolCallId)) {
-					if (event.toolName === "read") {
-						this.#trackReadToolCall(event.toolCallId, event.args);
-						const component = this.ctx.pendingTools.get(event.toolCallId);
-						if (component) {
-							component.updateArgs(event.args, event.toolCallId);
-						} else {
-							const group = this.#getReadGroup();
-							group.updateArgs(event.args, event.toolCallId);
-							this.ctx.pendingTools.set(event.toolCallId, group);
-						}
-						this.ctx.ui.requestRender();
-						break;
-					}
 
+				// Preserve the raw partial JSON for renderers that need to surface fields before the JSON object closes.
+				// Bash uses this to show inline env assignments during streaming instead of popping them in at completion.
+				const renderArgs =
+					"partialJson" in content
+						? { ...content.arguments, __partialJson: content.partialJson }
+						: content.arguments;
+				if (!this.ctx.pendingTools.has(content.id)) {
 					this.#resetReadGroup();
-					const tool = this.ctx.session.getToolByName(event.toolName);
+					this.ctx.chatContainer.addChild(new Text("", 0, 0));
+					const tool = this.ctx.session.getToolByName(content.name);
 					const component = new ToolExecutionComponent(
-						event.toolName,
-						event.args,
+						content.name,
+						renderArgs,
 						{
 							showImages: settings.get("terminal.showImages"),
 							editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),
@@ -306,274 +247,345 @@ export class EventController {
 					);
 					component.setExpanded(this.ctx.toolOutputExpanded);
 					this.ctx.chatContainer.addChild(component);
-					this.ctx.pendingTools.set(event.toolCallId, component);
-					this.ctx.ui.requestRender();
+					this.ctx.pendingTools.set(content.id, component);
+				} else {
+					const component = this.ctx.pendingTools.get(content.id);
+					if (component) {
+						component.updateArgs(renderArgs, content.id);
+					}
 				}
-				break;
 			}
 
-			case "tool_execution_update": {
-				const component = this.ctx.pendingTools.get(event.toolCallId);
-				if (component) {
-					const asyncState = (event.partialResult.details as { async?: { state?: string } } | undefined)?.async
-						?.state;
-					const isFinalAsyncState = asyncState === "completed" || asyncState === "failed";
-					component.updateResult(
-						{ ...event.partialResult, isError: asyncState === "failed" },
-						!isFinalAsyncState,
-						event.toolCallId,
-					);
-					if (isFinalAsyncState) {
-						this.ctx.pendingTools.delete(event.toolCallId);
-						this.#backgroundToolCallIds.delete(event.toolCallId);
-					}
-					this.ctx.ui.requestRender();
-				}
-				break;
+			// Update working message with intent from streamed tool arguments
+			for (const content of this.ctx.streamingMessage.content) {
+				if (content.type !== "toolCall") continue;
+				const args = content.arguments;
+				if (!args || typeof args !== "object" || !(INTENT_FIELD in args)) continue;
+				this.#updateWorkingMessageFromIntent(args[INTENT_FIELD] as string | undefined);
 			}
 
-			case "tool_execution_end": {
-				if (event.toolName === "read") {
-					if (this.#inlineReadToolImages(event.toolCallId, event.result)) {
-						const component = this.ctx.pendingTools.get(event.toolCallId);
-						if (component) {
-							component.updateResult({ ...event.result, isError: event.isError }, false, event.toolCallId);
-							this.ctx.pendingTools.delete(event.toolCallId);
-						}
-						const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
-						if (asyncState === "running") {
-							this.#backgroundToolCallIds.add(event.toolCallId);
-						} else {
-							this.#backgroundToolCallIds.delete(event.toolCallId);
-							this.#clearReadToolCall(event.toolCallId);
-						}
-						this.ctx.ui.requestRender();
-					} else {
-						let component = this.ctx.pendingTools.get(event.toolCallId);
-						if (!component) {
-							const group = this.#getReadGroup();
-							const args = this.#readToolCallArgs.get(event.toolCallId);
-							if (args) {
-								group.updateArgs(args, event.toolCallId);
-							}
-							component = group;
-							this.ctx.pendingTools.set(event.toolCallId, group);
-						}
-						const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
-						const isBackgroundRunning = asyncState === "running";
-						component.updateResult(
-							{ ...event.result, isError: event.isError },
-							isBackgroundRunning,
-							event.toolCallId,
-						);
-						if (isBackgroundRunning) {
-							this.#backgroundToolCallIds.add(event.toolCallId);
-						} else {
-							this.ctx.pendingTools.delete(event.toolCallId);
-							this.#backgroundToolCallIds.delete(event.toolCallId);
-							this.#clearReadToolCall(event.toolCallId);
-						}
-						this.ctx.ui.requestRender();
-					}
-				} else {
-					const component = this.ctx.pendingTools.get(event.toolCallId);
-					if (component) {
-						const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
-						const isBackgroundRunning = asyncState === "running";
-						component.updateResult(
-							{ ...event.result, isError: event.isError },
-							isBackgroundRunning,
-							event.toolCallId,
-						);
-						if (isBackgroundRunning) {
-							this.#backgroundToolCallIds.add(event.toolCallId);
-						} else {
-							this.ctx.pendingTools.delete(event.toolCallId);
-							this.#backgroundToolCallIds.delete(event.toolCallId);
-						}
-						this.ctx.ui.requestRender();
-					}
-				}
-				// Update todo display when todo_write tool completes
-				if (event.toolName === "todo_write" && !event.isError) {
-					const details = event.result.details as { phases?: TodoPhase[] } | undefined;
-					if (details?.phases) {
-						this.ctx.setTodos(details.phases);
-					}
-				} else if (event.toolName === "todo_write" && event.isError) {
-					const textContent = event.result.content.find(
-						(content: { type: string; text?: string }) => content.type === "text",
-					)?.text;
-					this.ctx.showWarning(
-						`Todo update failed${textContent ? `: ${textContent}` : ". Progress may be stale until todo_write succeeds."}`,
-					);
-				}
-				if (event.toolName === "exit_plan_mode" && !event.isError) {
-					const details = event.result.details as ExitPlanModeDetails | undefined;
-					if (details) {
-						await this.ctx.handleExitPlanModeTool(details);
-					}
-				}
-				break;
+			this.ctx.ui.requestRender();
+		}
+	}
+
+	async #handleMessageEnd(event: Extract<AgentSessionEvent, { type: "message_end" }>): Promise<void> {
+		if (event.message.role === "user") return;
+		if (this.ctx.streamingComponent && event.message.role === "assistant") {
+			this.ctx.streamingMessage = event.message;
+			let errorMessage: string | undefined;
+			if (this.ctx.streamingMessage.stopReason === "aborted" && !this.ctx.session.isTtsrAbortPending) {
+				const retryAttempt = this.ctx.session.retryAttempt;
+				errorMessage =
+					retryAttempt > 0
+						? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+						: "Operation aborted";
+				this.ctx.streamingMessage.errorMessage = errorMessage;
+			}
+			if (this.ctx.session.isTtsrAbortPending && this.ctx.streamingMessage.stopReason === "aborted") {
+				const msgWithoutAbort = { ...this.ctx.streamingMessage, stopReason: "stop" as const };
+				this.ctx.streamingComponent.updateContent(msgWithoutAbort);
+			} else {
+				this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
 			}
 
-			case "agent_end":
-				if (this.ctx.loadingAnimation) {
-					this.ctx.loadingAnimation.stop();
-					this.ctx.loadingAnimation = undefined;
-					this.ctx.statusContainer.clear();
-				}
-				if (this.ctx.streamingComponent) {
-					this.ctx.chatContainer.removeChild(this.ctx.streamingComponent);
-					this.ctx.streamingComponent = undefined;
-					this.ctx.streamingMessage = undefined;
+			if (this.ctx.streamingMessage.stopReason !== "aborted" && this.ctx.streamingMessage.stopReason !== "error") {
+				for (const [toolCallId, component] of this.ctx.pendingTools.entries()) {
+					component.setArgsComplete(toolCallId);
 				}
-				await this.ctx.flushPendingModelSwitch();
-				for (const toolCallId of Array.from(this.ctx.pendingTools.keys())) {
-					if (!this.#backgroundToolCallIds.has(toolCallId)) {
-						this.ctx.pendingTools.delete(toolCallId);
-					}
-				}
-				this.#backgroundToolCallIds = new Set(
-					Array.from(this.#backgroundToolCallIds).filter(toolCallId => this.ctx.pendingTools.has(toolCallId)),
-				);
-				this.#readToolCallArgs.clear();
-				this.#readToolCallAssistantComponents.clear();
-				this.#lastAssistantComponent = undefined;
-				this.ctx.ui.requestRender();
-				this.#scheduleIdleCompaction();
-				this.sendCompletionNotification();
-				break;
-
-			case "auto_compaction_start": {
-				this.#cancelIdleCompaction();
-				this.ctx.autoCompactionEscapeHandler = this.ctx.editor.onEscape;
-				this.ctx.editor.onEscape = () => {
-					this.ctx.session.abortCompaction();
-				};
-				this.ctx.statusContainer.clear();
-				const reasonText =
-					event.reason === "overflow" ? "Context overflow detected, " : event.reason === "idle" ? "Idle " : "";
-				const actionLabel = event.action === "handoff" ? "Auto-handoff" : "Auto context-full maintenance";
-				this.ctx.autoCompactionLoader = new Loader(
-					this.ctx.ui,
-					spinner => theme.fg("accent", spinner),
-					text => theme.fg("muted", text),
-					`${reasonText}${actionLabel}… (esc to cancel)`,
-					getSymbolTheme().spinnerFrames,
-				);
-				this.ctx.statusContainer.addChild(this.ctx.autoCompactionLoader);
-				this.ctx.ui.requestRender();
-				break;
 			}
+			this.#lastAssistantComponent = this.ctx.streamingComponent;
+			this.#lastAssistantComponent.setUsageInfo(event.message.usage);
+			this.ctx.streamingComponent = undefined;
+			this.ctx.streamingMessage = undefined;
+			this.ctx.statusLine.invalidate();
+			this.ctx.updateEditorTopBorder();
+		}
+		this.ctx.ui.requestRender();
+	}
 
-			case "auto_compaction_end": {
-				this.#cancelIdleCompaction();
-				if (this.ctx.autoCompactionEscapeHandler) {
-					this.ctx.editor.onEscape = this.ctx.autoCompactionEscapeHandler;
-					this.ctx.autoCompactionEscapeHandler = undefined;
-				}
-				if (this.ctx.autoCompactionLoader) {
-					this.ctx.autoCompactionLoader.stop();
-					this.ctx.autoCompactionLoader = undefined;
-					this.ctx.statusContainer.clear();
-				}
-				const isHandoffAction = event.action === "handoff";
-				if (event.aborted) {
-					this.ctx.showStatus(
-						isHandoffAction ? "Auto-handoff cancelled" : "Auto context-full maintenance cancelled",
-					);
-				} else if (event.result) {
-					this.ctx.rebuildChatFromMessages();
-					this.ctx.statusLine.invalidate();
-					this.ctx.updateEditorTopBorder();
-				} else if (event.errorMessage) {
-					this.ctx.showWarning(event.errorMessage);
-				} else if (isHandoffAction) {
-					this.ctx.chatContainer.clear();
-					this.ctx.rebuildChatFromMessages();
-					this.ctx.statusLine.invalidate();
-					this.ctx.updateEditorTopBorder();
-					await this.ctx.reloadTodos();
-					this.ctx.showStatus("Auto-handoff completed");
-				} else if (event.skipped) {
-					// Benign skip: no model selected, no candidate models available, or nothing
-					// to compact yet. Not a failure — suppress the warning.
+	async #handleToolExecutionStart(event: Extract<AgentSessionEvent, { type: "tool_execution_start" }>): Promise<void> {
+		this.#updateWorkingMessageFromIntent(event.intent);
+		if (!this.ctx.pendingTools.has(event.toolCallId)) {
+			if (event.toolName === "read") {
+				this.#trackReadToolCall(event.toolCallId, event.args);
+				const component = this.ctx.pendingTools.get(event.toolCallId);
+				if (component) {
+					component.updateArgs(event.args, event.toolCallId);
 				} else {
-					this.ctx.showWarning("Auto context-full maintenance failed; continuing without maintenance");
+					const group = this.#getReadGroup();
+					group.updateArgs(event.args, event.toolCallId);
+					this.ctx.pendingTools.set(event.toolCallId, group);
 				}
-				await this.ctx.flushCompactionQueue({ willRetry: event.willRetry });
 				this.ctx.ui.requestRender();
-				break;
+				return;
 			}
 
-			case "auto_retry_start": {
-				this.ctx.retryEscapeHandler = this.ctx.editor.onEscape;
-				this.ctx.editor.onEscape = () => {
-					this.ctx.session.abortRetry();
-				};
-				this.ctx.statusContainer.clear();
-				const delaySeconds = Math.round(event.delayMs / 1000);
-				this.ctx.retryLoader = new Loader(
-					this.ctx.ui,
-					spinner => theme.fg("warning", spinner),
-					text => theme.fg("muted", text),
-					`Retrying (${event.attempt}/${event.maxAttempts}) in ${delaySeconds}s… (esc to cancel)`,
-					getSymbolTheme().spinnerFrames,
-				);
-				this.ctx.statusContainer.addChild(this.ctx.retryLoader);
-				this.ctx.ui.requestRender();
-				break;
+			this.#resetReadGroup();
+			const tool = this.ctx.session.getToolByName(event.toolName);
+			const component = new ToolExecutionComponent(
+				event.toolName,
+				event.args,
+				{
+					showImages: settings.get("terminal.showImages"),
+					editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),
+					editAllowFuzzy: settings.get("edit.fuzzyMatch"),
+				},
+				tool,
+				this.ctx.ui,
+				this.ctx.sessionManager.getCwd(),
+			);
+			component.setExpanded(this.ctx.toolOutputExpanded);
+			this.ctx.chatContainer.addChild(component);
+			this.ctx.pendingTools.set(event.toolCallId, component);
+			this.ctx.ui.requestRender();
+		}
+	}
+
+	async #handleToolExecutionUpdate(
+		event: Extract<AgentSessionEvent, { type: "tool_execution_update" }>,
+	): Promise<void> {
+		const component = this.ctx.pendingTools.get(event.toolCallId);
+		if (component) {
+			const asyncState = (event.partialResult.details as { async?: { state?: string } } | undefined)?.async?.state;
+			const isFinalAsyncState = asyncState === "completed" || asyncState === "failed";
+			component.updateResult(
+				{ ...event.partialResult, isError: asyncState === "failed" },
+				!isFinalAsyncState,
+				event.toolCallId,
+			);
+			if (isFinalAsyncState) {
+				this.ctx.pendingTools.delete(event.toolCallId);
+				this.#backgroundToolCallIds.delete(event.toolCallId);
 			}
+			this.ctx.ui.requestRender();
+		}
+	}
 
-			case "auto_retry_end": {
-				if (this.ctx.retryEscapeHandler) {
-					this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
-					this.ctx.retryEscapeHandler = undefined;
+	async #handleToolExecutionEnd(event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>): Promise<void> {
+		if (event.toolName === "read") {
+			if (this.#inlineReadToolImages(event.toolCallId, event.result)) {
+				const component = this.ctx.pendingTools.get(event.toolCallId);
+				if (component) {
+					component.updateResult({ ...event.result, isError: event.isError }, false, event.toolCallId);
+					this.ctx.pendingTools.delete(event.toolCallId);
 				}
-				if (this.ctx.retryLoader) {
-					this.ctx.retryLoader.stop();
-					this.ctx.retryLoader = undefined;
-					this.ctx.statusContainer.clear();
+				const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
+				if (asyncState === "running") {
+					this.#backgroundToolCallIds.add(event.toolCallId);
+				} else {
+					this.#backgroundToolCallIds.delete(event.toolCallId);
+					this.#clearReadToolCall(event.toolCallId);
 				}
-				if (!event.success) {
-					this.ctx.showError(
-						`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`,
-					);
+				this.ctx.ui.requestRender();
+			} else {
+				let component = this.ctx.pendingTools.get(event.toolCallId);
+				if (!component) {
+					const group = this.#getReadGroup();
+					const args = this.#readToolCallArgs.get(event.toolCallId);
+					if (args) {
+						group.updateArgs(args, event.toolCallId);
+					}
+					component = group;
+					this.ctx.pendingTools.set(event.toolCallId, group);
+				}
+				const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
+				const isBackgroundRunning = asyncState === "running";
+				component.updateResult({ ...event.result, isError: event.isError }, isBackgroundRunning, event.toolCallId);
+				if (isBackgroundRunning) {
+					this.#backgroundToolCallIds.add(event.toolCallId);
+				} else {
+					this.ctx.pendingTools.delete(event.toolCallId);
+					this.#backgroundToolCallIds.delete(event.toolCallId);
+					this.#clearReadToolCall(event.toolCallId);
 				}
 				this.ctx.ui.requestRender();
-				break;
 			}
-
-			case "retry_fallback_applied": {
-				this.ctx.showWarning(`Fallback: ${event.from} -> ${event.to}`);
-				break;
+		} else {
+			const component = this.ctx.pendingTools.get(event.toolCallId);
+			if (component) {
+				const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
+				const isBackgroundRunning = asyncState === "running";
+				component.updateResult({ ...event.result, isError: event.isError }, isBackgroundRunning, event.toolCallId);
+				if (isBackgroundRunning) {
+					this.#backgroundToolCallIds.add(event.toolCallId);
+				} else {
+					this.ctx.pendingTools.delete(event.toolCallId);
+					this.#backgroundToolCallIds.delete(event.toolCallId);
+				}
+				this.ctx.ui.requestRender();
 			}
-
-			case "retry_fallback_succeeded": {
-				this.ctx.showStatus(`Fallback succeeded on ${event.model}`);
-				break;
+		}
+		// Update todo display when todo_write tool completes
+		if (event.toolName === "todo_write" && !event.isError) {
+			const details = event.result.details as { phases?: TodoPhase[] } | undefined;
+			if (details?.phases) {
+				this.ctx.setTodos(details.phases);
 			}
-
-			case "ttsr_triggered": {
-				const component = new TtsrNotificationComponent(event.rules);
-				component.setExpanded(this.ctx.toolOutputExpanded);
-				this.ctx.chatContainer.addChild(component);
-				this.ctx.ui.requestRender();
-				break;
+		} else if (event.toolName === "todo_write" && event.isError) {
+			const textContent = event.result.content.find(
+				(content: { type: string; text?: string }) => content.type === "text",
+			)?.text;
+			this.ctx.showWarning(
+				`Todo update failed${textContent ? `: ${textContent}` : ". Progress may be stale until todo_write succeeds."}`,
+			);
+		}
+		if (event.toolName === "exit_plan_mode" && !event.isError) {
+			const details = event.result.details as ExitPlanModeDetails | undefined;
+			if (details) {
+				await this.ctx.handleExitPlanModeTool(details);
 			}
+		}
+	}
 
-			case "todo_reminder": {
-				const component = new TodoReminderComponent(event.todos, event.attempt, event.maxAttempts);
-				this.ctx.chatContainer.addChild(component);
-				this.ctx.ui.requestRender();
-				break;
+	async #handleAgentEnd(_event: Extract<AgentSessionEvent, { type: "agent_end" }>): Promise<void> {
+		if (this.ctx.loadingAnimation) {
+			this.ctx.loadingAnimation.stop();
+			this.ctx.loadingAnimation = undefined;
+			this.ctx.statusContainer.clear();
+		}
+		if (this.ctx.streamingComponent) {
+			this.ctx.chatContainer.removeChild(this.ctx.streamingComponent);
+			this.ctx.streamingComponent = undefined;
+			this.ctx.streamingMessage = undefined;
+		}
+		await this.ctx.flushPendingModelSwitch();
+		for (const toolCallId of Array.from(this.ctx.pendingTools.keys())) {
+			if (!this.#backgroundToolCallIds.has(toolCallId)) {
+				this.ctx.pendingTools.delete(toolCallId);
 			}
+		}
+		this.#backgroundToolCallIds = new Set(
+			Array.from(this.#backgroundToolCallIds).filter(toolCallId => this.ctx.pendingTools.has(toolCallId)),
+		);
+		this.#readToolCallArgs.clear();
+		this.#readToolCallAssistantComponents.clear();
+		this.#lastAssistantComponent = undefined;
+		this.ctx.ui.requestRender();
+		this.#scheduleIdleCompaction();
+		this.sendCompletionNotification();
+	}
 
-			case "todo_auto_clear":
-				await this.ctx.reloadTodos();
-				break;
+	async #handleAutoCompactionStart(
+		event: Extract<AgentSessionEvent, { type: "auto_compaction_start" }>,
+	): Promise<void> {
+		this.#cancelIdleCompaction();
+		this.ctx.autoCompactionEscapeHandler = this.ctx.editor.onEscape;
+		this.ctx.editor.onEscape = () => {
+			this.ctx.session.abortCompaction();
+		};
+		this.ctx.statusContainer.clear();
+		const reasonText =
+			event.reason === "overflow" ? "Context overflow detected, " : event.reason === "idle" ? "Idle " : "";
+		const actionLabel = event.action === "handoff" ? "Auto-handoff" : "Auto context-full maintenance";
+		this.ctx.autoCompactionLoader = new Loader(
+			this.ctx.ui,
+			spinner => theme.fg("accent", spinner),
+			text => theme.fg("muted", text),
+			`${reasonText}${actionLabel}… (esc to cancel)`,
+			getSymbolTheme().spinnerFrames,
+		);
+		this.ctx.statusContainer.addChild(this.ctx.autoCompactionLoader);
+		this.ctx.ui.requestRender();
+	}
+
+	async #handleAutoCompactionEnd(event: Extract<AgentSessionEvent, { type: "auto_compaction_end" }>): Promise<void> {
+		this.#cancelIdleCompaction();
+		if (this.ctx.autoCompactionEscapeHandler) {
+			this.ctx.editor.onEscape = this.ctx.autoCompactionEscapeHandler;
+			this.ctx.autoCompactionEscapeHandler = undefined;
 		}
+		if (this.ctx.autoCompactionLoader) {
+			this.ctx.autoCompactionLoader.stop();
+			this.ctx.autoCompactionLoader = undefined;
+			this.ctx.statusContainer.clear();
+		}
+		const isHandoffAction = event.action === "handoff";
+		if (event.aborted) {
+			this.ctx.showStatus(isHandoffAction ? "Auto-handoff cancelled" : "Auto context-full maintenance cancelled");
+		} else if (event.result) {
+			this.ctx.rebuildChatFromMessages();
+			this.ctx.statusLine.invalidate();
+			this.ctx.updateEditorTopBorder();
+		} else if (event.errorMessage) {
+			this.ctx.showWarning(event.errorMessage);
+		} else if (isHandoffAction) {
+			this.ctx.chatContainer.clear();
+			this.ctx.rebuildChatFromMessages();
+			this.ctx.statusLine.invalidate();
+			this.ctx.updateEditorTopBorder();
+			await this.ctx.reloadTodos();
+			this.ctx.showStatus("Auto-handoff completed");
+		} else if (event.skipped) {
+			// Benign skip: no model selected, no candidate models available, or nothing
+			// to compact yet. Not a failure — suppress the warning.
+		} else {
+			this.ctx.showWarning("Auto context-full maintenance failed; continuing without maintenance");
+		}
+		await this.ctx.flushCompactionQueue({ willRetry: event.willRetry });
+		this.ctx.ui.requestRender();
+	}
+
+	async #handleAutoRetryStart(event: Extract<AgentSessionEvent, { type: "auto_retry_start" }>): Promise<void> {
+		this.ctx.retryEscapeHandler = this.ctx.editor.onEscape;
+		this.ctx.editor.onEscape = () => {
+			this.ctx.session.abortRetry();
+		};
+		this.ctx.statusContainer.clear();
+		const delaySeconds = Math.round(event.delayMs / 1000);
+		this.ctx.retryLoader = new Loader(
+			this.ctx.ui,
+			spinner => theme.fg("warning", spinner),
+			text => theme.fg("muted", text),
+			`Retrying (${event.attempt}/${event.maxAttempts}) in ${delaySeconds}s… (esc to cancel)`,
+			getSymbolTheme().spinnerFrames,
+		);
+		this.ctx.statusContainer.addChild(this.ctx.retryLoader);
+		this.ctx.ui.requestRender();
+	}
+
+	async #handleAutoRetryEnd(event: Extract<AgentSessionEvent, { type: "auto_retry_end" }>): Promise<void> {
+		if (this.ctx.retryEscapeHandler) {
+			this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
+			this.ctx.retryEscapeHandler = undefined;
+		}
+		if (this.ctx.retryLoader) {
+			this.ctx.retryLoader.stop();
+			this.ctx.retryLoader = undefined;
+			this.ctx.statusContainer.clear();
+		}
+		if (!event.success) {
+			this.ctx.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
+		}
+		this.ctx.ui.requestRender();
+	}
+
+	async #handleRetryFallbackApplied(
+		event: Extract<AgentSessionEvent, { type: "retry_fallback_applied" }>,
+	): Promise<void> {
+		this.ctx.showWarning(`Fallback: ${event.from} -> ${event.to}`);
+	}
+
+	async #handleRetryFallbackSucceeded(
+		event: Extract<AgentSessionEvent, { type: "retry_fallback_succeeded" }>,
+	): Promise<void> {
+		this.ctx.showStatus(`Fallback succeeded on ${event.model}`);
+	}
+
+	async #handleTtsrTriggered(event: Extract<AgentSessionEvent, { type: "ttsr_triggered" }>): Promise<void> {
+		const component = new TtsrNotificationComponent(event.rules);
+		component.setExpanded(this.ctx.toolOutputExpanded);
+		this.ctx.chatContainer.addChild(component);
+		this.ctx.ui.requestRender();
+	}
+
+	async #handleTodoReminder(event: Extract<AgentSessionEvent, { type: "todo_reminder" }>): Promise<void> {
+		const component = new TodoReminderComponent(event.todos, event.attempt, event.maxAttempts);
+		this.ctx.chatContainer.addChild(component);
+		this.ctx.ui.requestRender();
+	}
+
+	async #handleTodoAutoClear(_event: Extract<AgentSessionEvent, { type: "todo_auto_clear" }>): Promise<void> {
+		await this.ctx.reloadTodos();
 	}
 
 	#cancelIdleCompaction(): void {