@oh-my-pi/pi-coding-agent 14.9.9 → 15.0.1

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

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { TERMINAL } from "@oh-my-pi/pi-tui";
 import { formatDuration, formatNumber, getProjectDir, relativePathWithinRoot } from "@oh-my-pi/pi-utils";
-import { theme } from "../../../modes/theme/theme";
+import { type ThemeColor, theme } from "../../../modes/theme/theme";
 import { shortenPath } from "../../../tools/render-utils";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../../../utils/session-color";
 import { sanitizeStatusText } from "../../shared";
@@ -76,17 +76,65 @@ const modelSegment: StatusLineSegment = {
 	},
 };
 
+function formatGoalBudget(current: number, budget?: number): string {
+	const used = formatNumber(current);
+	if (budget === undefined) return used;
+	return `${used}/${formatNumber(budget)}`;
+}
+
+function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: boolean }): RenderedSegment {
+	const goal = ctx.session.getGoalModeState()?.goal;
+	const status = goal?.status ?? (mode.paused ? "paused" : "active");
+
+	let icon: string = theme.icon.goal;
+	let color: ThemeColor = "accent";
+	switch (status) {
+		case "paused":
+			icon = theme.icon.pause || theme.symbol("status.pending");
+			color = "warning";
+			break;
+		case "complete":
+			icon = theme.symbol("status.success");
+			color = "success";
+			break;
+		case "budget-limited":
+			icon = theme.symbol("status.warning");
+			color = "warning";
+			break;
+		case "dropped":
+			icon = theme.symbol("status.aborted");
+			color = "dim";
+			break;
+		default:
+			break;
+	}
+
+	const parts: string[] = [withIcon(icon, "Goal")];
+	const showBudget = ctx.session.settings.get("goal.statusInFooter") === true;
+	if (showBudget && goal) {
+		parts.push(formatGoalBudget(goal.tokensUsed, goal.tokenBudget));
+	}
+	return { content: theme.fg(color, parts.join(" ")), visible: true };
+}
+
 const modeSegment: StatusLineSegment = {
 	id: "mode",
 	render(ctx) {
+		const pauseSuffix = theme.icon.pause ? ` ${theme.icon.pause}` : " (paused)";
+
 		const plan = ctx.planMode;
 		if (plan && (plan.enabled || plan.paused)) {
-			const label = plan.paused ? "Plan ⏸" : "Plan";
+			const label = plan.paused ? `Plan${pauseSuffix}` : "Plan";
 			const content = withIcon(theme.icon.plan, label);
 			const color = plan.paused ? "warning" : "accent";
 			return { content: theme.fg(color, content), visible: true };
 		}
 
+		const goal = ctx.goalMode;
+		if (goal && (goal.enabled || goal.paused)) {
+			return renderGoalMode(ctx, goal);
+		}
+
 		const loop = ctx.loopMode;
 		if (loop?.enabled) {
 			const content = withIcon(theme.icon.loop, "Loop");
@@ -216,8 +264,11 @@ const tokenOutSegment: StatusLineSegment = {
 const tokenTotalSegment: StatusLineSegment = {
 	id: "token_total",
 	render(ctx) {
-		const { input, output, cacheRead, cacheWrite } = ctx.usageStats;
-		const total = input + output + cacheRead + cacheWrite;
+		// Excludes cacheRead: that field re-reads the full cached context every
+		// turn, making the cumulative sum N×context_size. The dedicated cache_read
+		// segment handles cache monitoring; the cost segment handles billing.
+		const { input, output, cacheWrite } = ctx.usageStats;
+		const total = input + output + cacheWrite;
 		if (!total) return { content: "", visible: false };
 
 		const content = withIcon(theme.icon.tokens, formatNumber(total));

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

@@ -27,6 +27,10 @@ export interface SegmentContext {
 	loopMode: {
 		enabled: boolean;
 	} | null;
+	goalMode: {
+		enabled: boolean;
+		paused: boolean;
+	} | null;
 	// Cached values for performance (computed once per render)
 	usageStats: {
 		input: number;

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

@@ -1,5 +1,4 @@
 import * as fs from "node:fs";
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type Component, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { formatCount, getProjectDir } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
@@ -7,10 +6,10 @@ import { settings } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import { theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
-import { calculatePromptTokens } from "../../session/compaction/compaction";
 import * as git from "../../utils/git";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../../utils/session-color";
 import { sanitizeStatusText } from "../shared";
+import { computeContextBreakdown } from "../utils/context-usage";
 import {
 	canReuseCachedPr,
 	createPrCacheContext,
@@ -59,6 +58,7 @@ export class StatusLineComponent implements Component {
 	#sessionStartTime: number = Date.now();
 	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#loopModeStatus: { enabled: boolean } | null = null;
+	#goalModeStatus: { enabled: boolean; paused: boolean } | null = null;
 
 	// Git status caching (1s TTL)
 	#cachedGitStatus: { staged: number; unstaged: number; untracked: number } | null = null;
@@ -73,6 +73,10 @@ export class StatusLineComponent implements Component {
 	#lastTokensPerSecond: number | null = null;
 	#lastTokensPerSecondTimestamp: number | null = null;
 
+	// Context breakdown caching (2s TTL — aligns with /context command output)
+	#cachedBreakdown: { usedTokens: number; contextWindow: number } | null = null;
+	#breakdownFetchedAt = 0;
+
 	constructor(private readonly session: AgentSession) {
 		this.#settings = {
 			preset: settings.get("statusLine.preset"),
@@ -109,6 +113,10 @@ export class StatusLineComponent implements Component {
 		this.#loopModeStatus = status ?? null;
 	}
 
+	setGoalModeStatus(status: { enabled: boolean; paused: boolean } | undefined): void {
+		this.#goalModeStatus = status ?? null;
+	}
+
 	setHookStatus(key: string, text: string | undefined): void {
 		if (text === undefined) {
 			this.#hookStatuses.delete(key);
@@ -301,6 +309,19 @@ export class StatusLineComponent implements Component {
 		return null;
 	}
 
+	#getCachedContextBreakdown(): { usedTokens: number; contextWindow: number } {
+		const now = Date.now();
+		if (!this.#cachedBreakdown || now - this.#breakdownFetchedAt > 2_000) {
+			const breakdown = computeContextBreakdown(this.session);
+			this.#cachedBreakdown = {
+				usedTokens: breakdown.usedTokens,
+				contextWindow: breakdown.contextWindow,
+			};
+			this.#breakdownFetchedAt = now;
+		}
+		return this.#cachedBreakdown;
+	}
+
 	#buildSegmentContext(width: number): SegmentContext {
 		const state = this.session.state;
 
@@ -318,14 +339,10 @@ export class StatusLineComponent implements Component {
 			tokensPerSecond: this.#getTokensPerSecond(),
 		};
 
-		// Get context percentage
-		const lastAssistantMessage = state.messages
-			.slice()
-			.reverse()
-			.find(m => m.role === "assistant" && m.stopReason !== "aborted") as AssistantMessage | undefined;
-
-		const contextTokens = lastAssistantMessage ? calculatePromptTokens(lastAssistantMessage.usage) : 0;
-		const contextWindow = state.model?.contextWindow || 0;
+		// Context usage — aligned with /context command so both surfaces report the same value
+		const breakdown = this.#getCachedContextBreakdown();
+		const contextTokens = breakdown.usedTokens;
+		const contextWindow = breakdown.contextWindow || state.model?.contextWindow || 0;
 		const contextPercent = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
 
 		return {
@@ -334,6 +351,7 @@ export class StatusLineComponent implements Component {
 			options: this.#resolveSettings().segmentOptions ?? {},
 			planMode: this.#planModeStatus,
 			loopMode: this.#loopModeStatus,
+			goalMode: this.#goalModeStatus,
 			usageStats,
 			contextPercent,
 			contextWindow,

package/src/modes/components/tool-execution.ts

@@ -32,7 +32,6 @@ import {
 import { formatExpandHint, replaceTabs, resolveImageOptions, truncateToWidth } from "../../tools/render-utils";
 import { toolRenderers } from "../../tools/renderers";
 import { renderStatusLine } from "../../tui";
-import { convertToPng } from "../../utils/image-convert";
 import { sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
 import { renderDiff } from "./diff";
 
@@ -295,13 +294,13 @@ export class ToolExecutionComponent extends Container {
 
 			// Convert async - catch errors from processing
 			const index = i;
-			convertToPng(img.data, img.mimeType)
-				.then(converted => {
-					if (converted) {
-						this.#convertedImages.set(index, converted);
-						this.#updateDisplay();
-						this.#ui.requestRender();
-					}
+			new Bun.Image(Buffer.from(img.data, "base64"))
+				.png()
+				.toBase64()
+				.then(data => {
+					this.#convertedImages.set(index, { data, mimeType: "image/png" });
+					this.#updateDisplay();
+					this.#ui.requestRender();
 				})
 				.catch(() => {
 					// Ignore conversion failures - display will use original image format

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

@@ -0,0 +1,108 @@
+/**
+ * Shared helpers for /mcp and /ssh command controllers.
+ *
+ * Captures argument parsing, source grouping, and chat-message rendering that
+ * was duplicated between mcp-command-controller and ssh-command-controller.
+ * Intentionally kept narrow: subcommand routing, help text, success/error
+ * wording, and add-flow logic stay in the per-controller files because they
+ * diverge in workflow.
+ */
+import { Spacer, Text } from "@oh-my-pi/pi-tui";
+import type { SourceMeta } from "../../capability/types";
+import { shortenPath } from "../../tools/render-utils";
+import { DynamicBorder } from "../components/dynamic-border";
+import { parseCommandArgs } from "../shared";
+import type { InteractiveModeContext } from "../types";
+
+export type ScopeValue = "project" | "user";
+
+export type ScopeFlagResult = { ok: true; scope: ScopeValue } | { ok: false; error: string };
+
+/**
+ * Validate the value following a `--scope` flag.
+ */
+export function readScopeFlag(value: string | undefined): ScopeFlagResult {
+	if (!value || (value !== "project" && value !== "user")) {
+		return { ok: false, error: "Invalid --scope value. Use project or user." };
+	}
+	return { ok: true, scope: value };
+}
+
+export type RemoveArgs = { name: string | undefined; scope: ScopeValue };
+
+export type ParseRemoveResult = { ok: true; value: RemoveArgs } | { ok: false; error: string };
+
+/**
+ * Parse the argument tail of `/<cmd> remove <name> [--scope project|user]`.
+ *
+ * `rest` is the text after the subcommand keyword. The caller is responsible
+ * for emitting the command-specific "<entity> name required" usage hint when
+ * `value.name` is undefined.
+ */
+export function parseRemoveArgs(rest: string): ParseRemoveResult {
+	const tokens = parseCommandArgs(rest);
+
+	let name: string | undefined;
+	let scope: ScopeValue = "project";
+	let i = 0;
+
+	if (tokens.length > 0 && !tokens[0].startsWith("-")) {
+		name = tokens[0];
+		i = 1;
+	}
+
+	while (i < tokens.length) {
+		const token = tokens[i];
+		if (token === "--scope") {
+			const r = readScopeFlag(tokens[i + 1]);
+			if (!r.ok) return { ok: false, error: r.error };
+			scope = r.scope;
+			i += 2;
+			continue;
+		}
+		return { ok: false, error: `Unknown option: ${token}` };
+	}
+
+	return { ok: true, value: { name, scope } };
+}
+
+/**
+ * Group capability-loaded items by their source provider+path, yielding each
+ * group with a display-ready `shortPath`.
+ */
+export function* groupBySource<T>(
+	items: Iterable<T>,
+	getSource: (item: T) => SourceMeta,
+): Iterable<{ providerName: string; shortPath: string; items: T[] }> {
+	const groups = new Map<string, T[]>();
+	for (const item of items) {
+		const src = getSource(item);
+		const key = `${src.providerName}|${src.path}`;
+		let group = groups.get(key);
+		if (!group) {
+			group = [];
+			groups.set(key, group);
+		}
+		group.push(item);
+	}
+	for (const [key, grouped] of groups) {
+		const sepIdx = key.indexOf("|");
+		yield {
+			providerName: key.slice(0, sepIdx),
+			shortPath: shortenPath(key.slice(sepIdx + 1)),
+			items: grouped,
+		};
+	}
+}
+
+/**
+ * Render a message block (DynamicBorder / Text / DynamicBorder) into the chat
+ * container and request a render.
+ */
+export function showCommandMessage(ctx: InteractiveModeContext, text: string): void {
+	ctx.chatContainer.addChild(new Spacer(1));
+	ctx.chatContainer.addChild(new DynamicBorder());
+	ctx.chatContainer.addChild(new Text(text, 1, 1));
+	ctx.chatContainer.addChild(new DynamicBorder());
+	ctx.ui.requestRender();
+}

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

@@ -37,6 +37,7 @@ import { buildHotkeysMarkdown } from "../../modes/utils/hotkeys-markdown";
 import { buildToolsMarkdown } from "../../modes/utils/tools-markdown";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
+import { CompactionCancelledError, type CompactionOutcome } from "../../session/compaction";
 import type { NewSessionOptions } from "../../session/session-manager";
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
@@ -255,12 +256,21 @@ export class CommandController {
 	}
 
 	#copyLastMessage() {
-		const text = this.ctx.session.getLastAssistantText();
-		if (!text) {
-			this.ctx.showError("No agent messages to copy yet.");
+		const assistantText = this.ctx.session.getLastAssistantText();
+		if (assistantText) {
+			this.#doCopy(assistantText, "Copied last agent message to clipboard");
 			return;
 		}
-		this.#doCopy(text, "Copied last agent message to clipboard");
+
+		if (!this.ctx.session.hasCopyCandidateAssistantMessage()) {
+			const handoffText = this.ctx.session.getLastVisibleHandoffText();
+			if (handoffText) {
+				this.#doCopy(handoffText, "Copied handoff context to clipboard");
+				return;
+			}
+		}
+
+		this.ctx.showError("No agent messages to copy yet.");
 	}
 
 	#copyCode() {
@@ -1071,16 +1081,16 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 	}
 
-	async handleCompactCommand(customInstructions?: string): Promise<void> {
+	async handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome> {
 		const entries = this.ctx.sessionManager.getEntries();
 		const messageCount = entries.filter(e => e.type === "message").length;
 
 		if (messageCount < 2) {
 			this.ctx.showWarning("Nothing to compact (no messages yet)");
-			return;
+			return "ok";
 		}
 
-		await this.executeCompaction(customInstructions, false);
+		return this.executeCompaction(customInstructions, false);
 	}
 
 	async handleSkillCommand(skillPath: string, args: string): Promise<void> {
@@ -1098,7 +1108,10 @@ export class CommandController {
 		}
 	}
 
-	async executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto = false): Promise<void> {
+	async executeCompaction(
+		customInstructionsOrOptions?: string | CompactOptions,
+		isAuto = false,
+	): Promise<CompactionOutcome> {
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
 			this.ctx.loadingAnimation = undefined;
@@ -1122,6 +1135,7 @@ export class CommandController {
 		this.ctx.statusContainer.addChild(compactingLoader);
 		this.ctx.ui.requestRender();
 
+		let outcome: CompactionOutcome = "ok";
 		try {
 			const instructions = typeof customInstructionsOrOptions === "string" ? customInstructionsOrOptions : undefined;
 			const options =
@@ -1135,10 +1149,12 @@ export class CommandController {
 			this.ctx.statusLine.invalidate();
 			this.ctx.updateEditorTopBorder();
 		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			if (message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError")) {
+			if (error instanceof CompactionCancelledError) {
+				outcome = "cancelled";
 				this.ctx.showError("Compaction cancelled");
 			} else {
+				outcome = "failed";
+				const message = error instanceof Error ? error.message : String(error);
 				this.ctx.showError(`Compaction failed: ${message}`);
 			}
 		} finally {
@@ -1147,6 +1163,7 @@ export class CommandController {
 			this.ctx.editor.onEscape = originalOnEscape;
 		}
 		await this.ctx.flushCompactionQueue({ willRetry: false });
+		return outcome;
 	}
 
 	async handleHandoffCommand(customInstructions?: string): Promise<void> {

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

@@ -3,15 +3,21 @@ import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
 import { type Component, Loader, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { settings } from "../../config/settings";
 import { AssistantMessageComponent } from "../../modes/components/assistant-message";
-import { ReadToolGroupComponent } from "../../modes/components/read-tool-group";
+import {
+	ReadToolGroupComponent,
+	readArgsHaveTarget,
+	readArgsTargetInternalUrl,
+} from "../../modes/components/read-tool-group";
 import { TodoReminderComponent } from "../../modes/components/todo-reminder";
 import { ToolExecutionComponent } from "../../modes/components/tool-execution";
 import { TtsrNotificationComponent } from "../../modes/components/ttsr-notification";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext, TodoPhase } from "../../modes/types";
+import type { PlanApprovalDetails } from "../../plan-mode/approved-plan";
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { calculatePromptTokens } from "../../session/compaction/compaction";
-import type { ExitPlanModeDetails } from "../../tools";
+import { isSilentAbort, readPendingDisplayTag } from "../../session/messages";
+import type { ResolveToolDetails } from "../../tools/resolve";
 
 type AgentSessionEventKind = AgentSessionEvent["type"];
 
@@ -57,6 +63,8 @@ export class EventController {
 			todo_auto_clear: e => this.#handleTodoAutoClear(e),
 			irc_message: e => this.#handleIrcMessage(e),
 			notice: e => this.#handleNotice(e),
+			thinking_level_changed: async () => {},
+			goal_updated: async () => {},
 		} satisfies AgentSessionEventHandlers;
 	}
 
@@ -174,6 +182,17 @@ export class EventController {
 			this.#renderedCustomMessages.add(signature);
 			this.#resetReadGroup();
 			this.ctx.addMessageToChat(event.message);
+			// Tag-keyed pending-bar refresh: when AgentSession.#handleAgentEvent
+			// spliced this dequeued custom message out of #steeringMessages /
+			// #followUpMessages (it ran before this emit), the array state is
+			// already correct — pendingMessagesContainer just needs to be
+			// re-rendered to match. Gated on tag presence so non-queued customs
+			// (ttsr-injection, irc:*, async-result, hookMessage) skip the
+			// rebuild; their dispatch path never registered a pending chip.
+			// Mirrors the user-role refresh at the bottom of this function.
+			if (event.message.role === "custom" && readPendingDisplayTag(event.message.details)) {
+				this.ctx.updatePendingMessagesDisplay();
+			}
 			this.ctx.ui.requestRender();
 		} else if (event.message.role === "user") {
 			const textContent = this.ctx.getUserMessageText(event.message);
@@ -274,16 +293,25 @@ export class EventController {
 			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);
+					if (!readArgsHaveTarget(content.arguments)) {
+						// Args still streaming — defer until path is parseable so we can route to the
+						// read group (regular files) vs ToolExecutionComponent (internal URLs).
+						// Creating either component now would lock the read into the wrong shape.
+						continue;
 					}
-					continue;
+					if (!readArgsTargetInternalUrl(content.arguments)) {
+						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;
+					}
+					// Internal URL read falls through to ToolExecutionComponent below.
 				}
 
 				// Preserve the raw partial JSON for renderers that need to surface fields before the JSON object closes.
@@ -351,7 +379,15 @@ export class EventController {
 		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 aborted = this.ctx.streamingMessage.stopReason === "aborted";
+			const silentlyAborted = aborted && isSilentAbort(this.ctx.streamingMessage.errorMessage);
+			const ttsrSilenced = aborted && this.ctx.session.isTtsrAbortPending;
+			if (aborted && !silentlyAborted && !ttsrSilenced) {
+				// Real user-cancel / network / provider abort: surface the standard
+				// operator-facing label. AgentSession.#handleAgentEvent already stamped
+				// SILENT_ABORT_MARKER for the plan-compact transition before this
+				// controller ran, so reaching this branch implies the abort was NOT a
+				// silent internal transition.
 				const retryAttempt = this.ctx.session.retryAttempt;
 				errorMessage =
 					retryAttempt > 0
@@ -359,7 +395,10 @@ export class EventController {
 						: "Operation aborted";
 				this.ctx.streamingMessage.errorMessage = errorMessage;
 			}
-			if (this.ctx.session.isTtsrAbortPending && this.ctx.streamingMessage.stopReason === "aborted") {
+			if (silentlyAborted || ttsrSilenced) {
+				// Silence the streaming render by downgrading stopReason to "stop" for
+				// display only — does NOT mutate the persisted message's stopReason
+				// (the marker on errorMessage drives replay-side suppression).
 				const msgWithoutAbort = { ...this.ctx.streamingMessage, stopReason: "stop" as const };
 				this.ctx.streamingComponent.updateContent(msgWithoutAbort);
 			} else {
@@ -384,7 +423,7 @@ export class EventController {
 	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") {
+			if (event.toolName === "read" && readArgsHaveTarget(event.args) && !readArgsTargetInternalUrl(event.args)) {
 				this.#trackReadToolCall(event.toolCallId, event.args);
 				const component = this.ctx.pendingTools.get(event.toolCallId);
 				if (component) {
@@ -509,10 +548,13 @@ export class EventController {
 				`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);
+		if (event.toolName === "resolve" && !event.isError) {
+			const details = event.result.details as ResolveToolDetails | undefined;
+			if (details?.sourceToolName === "plan_approval" && details.action === "apply") {
+				const planDetails = details.sourceResultDetails as PlanApprovalDetails | undefined;
+				if (planDetails) {
+					await this.ctx.handlePlanApproval(planDetails);
+				}
 			}
 		}
 	}

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

@@ -119,7 +119,10 @@ export class ExtensionUiController {
 			abort: () => this.ctx.session.abort(),
 			hasPendingMessages: () => this.ctx.session.queuedMessageCount > 0,
 			shutdown: () => {
-				// Signal shutdown request (will be handled by main loop)
+				// Defer the actual teardown to the main loop, which calls
+				// `checkShutdownRequested()` at idle boundaries so any queued
+				// steering / follow-up messages drain first (see issue #1020).
+				this.ctx.shutdownRequested = true;
 			},
 			getContextUsage: () => this.ctx.session.getContextUsage(),
 			compact: instructionsOrOptions => this.#compactSession(instructionsOrOptions),
@@ -356,7 +359,10 @@ export class ExtensionUiController {
 			abort: () => this.ctx.session.abort(),
 			hasPendingMessages: () => this.ctx.session.queuedMessageCount > 0,
 			shutdown: () => {
-				// Signal shutdown request (will be handled by main loop)
+				// Defer the actual teardown to the main loop, which calls
+				// `checkShutdownRequested()` at idle boundaries so any queued
+				// steering / follow-up messages drain first (see issue #1020).
+				this.ctx.shutdownRequested = true;
 			},
 			getContextUsage: () => this.ctx.session.getContextUsage(),
 			compact: instructionsOrOptions => this.#compactSession(instructionsOrOptions),