@oh-my-pi/pi-coding-agent 8.4.0 → 8.4.2

package/src/sdk.ts

@@ -50,6 +50,7 @@ import {
 	loadCustomCommands as loadCustomCommandsInternal,
 } from "./extensibility/custom-commands";
 import type { CustomTool, CustomToolContext, CustomToolSessionEvent } from "./extensibility/custom-tools/types";
+import { CustomToolAdapter } from "./extensibility/custom-tools/wrapper";
 import {
 	discoverAndLoadExtensions,
 	type ExtensionContext,
@@ -69,6 +70,7 @@ import {
 	AgentProtocolHandler,
 	ArtifactProtocolHandler,
 	InternalUrlRouter,
+	PlanProtocolHandler,
 	RuleProtocolHandler,
 	SkillProtocolHandler,
 } from "./internal-urls";
@@ -743,12 +745,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		outputSchema: options.outputSchema,
 		requireCompleteTool: options.requireCompleteTool,
 		getSessionFile: () => sessionManager.getSessionFile() ?? null,
+		getSessionId: () => sessionManager.getSessionId?.() ?? null,
 		getSessionSpawns: () => options.spawns ?? "*",
 		getModelString: () => (hasExplicitModel && model ? formatModelString(model) : undefined),
 		getActiveModelString: () => {
 			const activeModel = agent?.state.model;
 			return activeModel ? formatModelString(activeModel) : undefined;
 		},
+		getPlanModeState: () => session.getPlanModeState(),
 		settings: settingsManager,
 		settingsManager,
 		authStorage,
@@ -763,6 +767,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	};
 	internalRouter.register(new AgentProtocolHandler({ getArtifactsDir }));
 	internalRouter.register(new ArtifactProtocolHandler({ getArtifactsDir }));
+	internalRouter.register(
+		new PlanProtocolHandler({
+			getPlansDirectory: settingsManager.getPlansDirectory.bind(settingsManager),
+			cwd,
+		}),
+	);
 	internalRouter.register(
 		new SkillProtocolHandler({
 			getSkills: () => skills,
@@ -924,14 +934,33 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const toolContextStore = new ToolContextStore(getSessionContext);
 
 	const registeredTools = extensionRunner?.getAllRegisteredTools() ?? [];
-	const allCustomTools = [
-		...registeredTools,
-		...(options.customTools?.map(tool => {
-			const definition = isCustomTool(tool) ? customToolToDefinition(tool) : tool;
-			return { definition, extensionPath: "<sdk>" };
-		}) ?? []),
-	];
-	const wrappedExtensionTools = extensionRunner ? wrapRegisteredTools(allCustomTools, extensionRunner) : [];
+	let wrappedExtensionTools: AgentTool[];
+
+	if (extensionRunner) {
+		// With extension runner: convert CustomTools to ToolDefinitions and wrap all together
+		const allCustomTools = [
+			...registeredTools,
+			...(options.customTools?.map(tool => {
+				const definition = isCustomTool(tool) ? customToolToDefinition(tool) : tool;
+				return { definition, extensionPath: "<sdk>" };
+			}) ?? []),
+		];
+		wrappedExtensionTools = wrapRegisteredTools(allCustomTools, extensionRunner);
+	} else {
+		// Without extension runner: wrap CustomTools directly with CustomToolAdapter
+		// ToolDefinition items require ExtensionContext and cannot be used without a runner
+		const customToolContext = (): CustomToolContext => ({
+			sessionManager,
+			modelRegistry,
+			model: agent?.state.model,
+			isIdle: () => !session?.isStreaming,
+			hasQueuedMessages: () => (session?.queuedMessageCount ?? 0) > 0,
+			abort: () => session?.abort(),
+		});
+		wrappedExtensionTools = (options.customTools ?? [])
+			.filter(isCustomTool)
+			.map(tool => CustomToolAdapter.wrap(tool, customToolContext) as AgentTool);
+	}
 
 	// All built-in tools are active (conditional tools like git/ask return null from factory if disabled)
 	const toolRegistry = new Map<string, AgentTool>();
@@ -989,7 +1018,25 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		return options.systemPrompt(defaultPrompt);
 	};
 
-	const systemPrompt = await rebuildSystemPrompt(Array.from(toolRegistry.keys()), toolRegistry);
+	const toolNamesFromRegistry = Array.from(toolRegistry.keys());
+	const requestedToolNames = options.toolNames ?? toolNamesFromRegistry;
+	const normalizedRequested = requestedToolNames.filter(name => toolRegistry.has(name));
+	const includeExitPlanMode = options.toolNames?.includes("exit_plan_mode") ?? false;
+	const initialToolNames = includeExitPlanMode
+		? normalizedRequested
+		: normalizedRequested.filter(name => name !== "exit_plan_mode");
+
+	// Custom tools are always included regardless of toolNames filter
+	if (options.customTools) {
+		const customToolNames = options.customTools.map(t => (isCustomTool(t) ? t.name : t.name));
+		for (const name of customToolNames) {
+			if (toolRegistry.has(name) && !initialToolNames.includes(name)) {
+				initialToolNames.push(name);
+			}
+		}
+	}
+
+	const systemPrompt = await rebuildSystemPrompt(initialToolNames, toolRegistry);
 	time("buildSystemPrompt");
 
 	const promptTemplates = options.promptTemplates ?? (await discoverPromptTemplates(cwd, agentDir));
@@ -1038,12 +1085,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		toolContextStore.setUIContext(uiContext, hasUI);
 	};
 
+	const initialTools = initialToolNames
+		.map(name => toolRegistry.get(name))
+		.filter((tool): tool is AgentTool => tool !== undefined);
+
 	agent = new Agent({
 		initialState: {
 			systemPrompt,
 			model,
 			thinkingLevel,
-			tools: Array.from(toolRegistry.values()),
+			tools: initialTools,
 		},
 		convertToLlm: convertToLlmWithBlockImages,
 		sessionId: sessionManager.getSessionId(),

package/src/session/agent-session.ts

@@ -14,6 +14,7 @@
  */
 
 import * as fs from "node:fs";
+
 import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type {
 	AssistantMessage,
@@ -26,6 +27,7 @@ import type {
 	UsageReport,
 } from "@oh-my-pi/pi-ai";
 import { isContextOverflow, modelsAreEqual, supportsXhigh } from "@oh-my-pi/pi-ai";
+import { resolvePlanUrlToPath } from "@oh-my-pi/pi-coding-agent/internal-urls";
 import { abortableSleep, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import type { Rule } from "../capability/rule";
@@ -62,6 +64,9 @@ import { expandSlashCommand, type FileSlashCommand } from "../extensibility/slas
 import { executePython as executePythonCommand, type PythonResult } from "../ipy/executor";
 import { theme } from "../modes/theme/theme";
 import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../patch";
+import type { PlanModeState } from "../plan-mode/state";
+import planModeActivePrompt from "../prompts/system/plan-mode-active.md" with { type: "text" };
+import planModeReferencePrompt from "../prompts/system/plan-mode-reference.md" with { type: "text" };
 import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
 import { closeAllConnections } from "../ssh/connection-manager";
 import { unmountAll } from "../ssh/sshfs-mount";
@@ -188,6 +193,11 @@ export interface SessionStats {
 	cost: number;
 }
 
+/** Result from handoff() */
+export interface HandoffResult {
+	document: string;
+}
+
 /** Internal marker for hook messages queued through the agent loop */
 // ============================================================================
 // Constants
@@ -255,6 +265,8 @@ export class AgentSession {
 	private _followUpMessages: string[] = [];
 	/** Messages queued to be included with the next user prompt as context ("asides"). */
 	private _pendingNextTurnMessages: CustomMessage[] = [];
+	private _planModeState: PlanModeState | undefined;
+	private _planReferenceSent = false;
 
 	// Compaction state
 	private _compactionAbortController: AbortController | undefined = undefined;
@@ -263,6 +275,9 @@ export class AgentSession {
 	// Branch summarization state
 	private _branchSummaryAbortController: AbortController | undefined = undefined;
 
+	// Handoff state
+	private _handoffAbortController: AbortController | undefined = undefined;
+
 	// Retry state
 	private _retryAbortController: AbortController | undefined = undefined;
 	private _retryAttempt = 0;
@@ -970,6 +985,25 @@ export class AgentSession {
 	}
 
 	/** Prompt templates */
+	getPlanModeState(): PlanModeState | undefined {
+		return this._planModeState;
+	}
+
+	setPlanModeState(state: PlanModeState | undefined): void {
+		this._planModeState = state;
+		if (state?.enabled) {
+			this._planReferenceSent = false;
+		}
+	}
+
+	markPlanReferenceSent(): void {
+		this._planReferenceSent = true;
+	}
+
+	resolveRoleModel(role: string): Model<any> | undefined {
+		return this._resolveRoleModel(role, this._modelRegistry.getAvailable(), this.model);
+	}
+
 	get promptTemplates(): ReadonlyArray<PromptTemplate> {
 		return this._promptTemplates;
 	}
@@ -983,6 +1017,95 @@ export class AgentSession {
 	// Prompting
 	// =========================================================================
 
+	/**
+	 * Build a plan mode message.
+	 * Returns null if plan mode is not enabled.
+	 * @returns The plan mode message, or null if plan mode is not enabled.
+	 */
+	private async _buildPlanReferenceMessage(): Promise<CustomMessage | null> {
+		if (this._planModeState?.enabled) return null;
+		if (this._planReferenceSent) return null;
+
+		const planFilePath = `plan://${this.sessionManager.getSessionId()}/plan.md`;
+		const resolvedPlanPath = resolvePlanUrlToPath(planFilePath, {
+			getPlansDirectory: this.settingsManager.getPlansDirectory.bind(this.settingsManager),
+			cwd: this.sessionManager.getCwd(),
+		});
+		let planContent: string;
+		try {
+			planContent = await fs.promises.readFile(resolvedPlanPath, "utf-8");
+		} catch (error) {
+			if (isEnoent(error)) {
+				return null;
+			}
+			throw error;
+		}
+
+		const content = renderPromptTemplate(planModeReferencePrompt, {
+			planFilePath,
+			planContent,
+		});
+
+		this._planReferenceSent = true;
+
+		return {
+			role: "custom",
+			customType: "plan-mode-reference",
+			content,
+			display: false,
+			timestamp: Date.now(),
+		};
+	}
+
+	private async _buildPlanModeMessage(): Promise<CustomMessage | null> {
+		const state = this._planModeState;
+		if (!state?.enabled) return null;
+		const sessionPlanUrl = `plan://${this.sessionManager.getSessionId()}/plan.md`;
+		const resolvedPlanPath = state.planFilePath.startsWith("plan://")
+			? resolvePlanUrlToPath(state.planFilePath, {
+					getPlansDirectory: this.settingsManager.getPlansDirectory.bind(this.settingsManager),
+					cwd: this.sessionManager.getCwd(),
+				})
+			: resolveToCwd(state.planFilePath, this.sessionManager.getCwd());
+		const resolvedSessionPlan = resolvePlanUrlToPath(sessionPlanUrl, {
+			getPlansDirectory: this.settingsManager.getPlansDirectory.bind(this.settingsManager),
+			cwd: this.sessionManager.getCwd(),
+		});
+		const displayPlanPath =
+			state.planFilePath.startsWith("plan://") || resolvedPlanPath !== resolvedSessionPlan
+				? state.planFilePath
+				: sessionPlanUrl;
+
+		let planExists = false;
+		try {
+			const stat = await fs.promises.stat(resolvedPlanPath);
+			planExists = stat.isFile();
+		} catch (error) {
+			if (!isEnoent(error)) {
+				throw error;
+			}
+		}
+
+		const content = renderPromptTemplate(planModeActivePrompt, {
+			planFilePath: displayPlanPath,
+			planExists,
+			askToolName: "ask",
+			writeToolName: "write",
+			editToolName: "edit",
+			exitToolName: "exit_plan_mode",
+			reentry: state.reentry ?? false,
+			iterative: state.workflow === "iterative",
+		});
+
+		return {
+			role: "custom",
+			customType: "plan-mode-context",
+			content,
+			display: false,
+			timestamp: Date.now(),
+		};
+	}
+
 	/**
 	 * Send a prompt to the agent.
 	 * - Handles extension commands (registered via pi.registerCommand) immediately, even during streaming
@@ -1069,6 +1192,14 @@ export class AgentSession {
 
 		// Build messages array (custom messages if any, then user message)
 		const messages: AgentMessage[] = [];
+		const planReferenceMessage = await this._buildPlanReferenceMessage?.();
+		if (planReferenceMessage) {
+			messages.push(planReferenceMessage);
+		}
+		const planModeMessage = await this._buildPlanModeMessage();
+		if (planModeMessage) {
+			messages.push(planModeMessage);
+		}
 
 		// Add user message
 		const userContent: (TextContent | ImageContent)[] = [{ type: "text", text: expandedText }];
@@ -1512,6 +1643,7 @@ export class AgentSession {
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
 		this._todoReminderCount = 0;
+		this._planReferenceSent = false;
 		this._reconnectToAgent();
 
 		// Emit session_switch event with reason "new" to hooks
@@ -1945,6 +2077,141 @@ export class AgentSession {
 		this._branchSummaryAbortController?.abort();
 	}
 
+	/**
+	 * Cancel in-progress handoff generation.
+	 */
+	abortHandoff(): void {
+		this._handoffAbortController?.abort();
+	}
+
+	/**
+	 * Check if handoff generation is in progress.
+	 */
+	get isGeneratingHandoff(): boolean {
+		return this._handoffAbortController !== undefined;
+	}
+
+	/**
+	 * Generate a handoff document by asking the agent, then start a new session with it.
+	 *
+	 * This prompts the current agent to write a comprehensive handoff document,
+	 * waits for completion, then starts a fresh session with the handoff as context.
+	 *
+	 * @param customInstructions Optional focus for the handoff document
+	 * @returns The handoff document text, or undefined if cancelled/failed
+	 */
+	async handoff(customInstructions?: string): Promise<HandoffResult | undefined> {
+		const entries = this.sessionManager.getBranch();
+		const messageCount = entries.filter(e => e.type === "message").length;
+
+		if (messageCount < 2) {
+			throw new Error("Nothing to hand off (no messages yet)");
+		}
+
+		this._handoffAbortController = new AbortController();
+
+		// Build the handoff prompt
+		let handoffPrompt = `Write a comprehensive handoff document that will allow another instance of yourself to seamlessly continue this work. The document should capture everything needed to resume without access to this conversation.
+
+Use this format:
+
+## Goal
+[What the user is trying to accomplish]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks with specifics]
+
+### In Progress
+- [ ] [Current work if any]
+
+### Pending
+- [ ] [Tasks mentioned but not started]
+
+## Key Decisions
+- **[Decision]**: [Rationale]
+
+## Critical Context
+- [Code snippets, file paths, error messages, or data essential to continue]
+- [Repository state if relevant]
+
+## Next Steps
+1. [What should happen next]
+
+Be thorough - include exact file paths, function names, error messages, and technical details. Output ONLY the handoff document, no other text.`;
+
+		if (customInstructions) {
+			handoffPrompt += `\n\nAdditional focus: ${customInstructions}`;
+		}
+
+		// Create a promise that resolves when the agent completes
+		let handoffText: string | undefined;
+		const completionPromise = new Promise<void>((resolve, reject) => {
+			const unsubscribe = this.subscribe(event => {
+				if (this._handoffAbortController?.signal.aborted) {
+					unsubscribe();
+					reject(new Error("Handoff cancelled"));
+					return;
+				}
+
+				if (event.type === "agent_end") {
+					unsubscribe();
+					// Extract text from the last assistant message
+					const messages = this.agent.state.messages;
+					for (let i = messages.length - 1; i >= 0; i--) {
+						const msg = messages[i];
+						if (msg.role === "assistant") {
+							const content = (msg as AssistantMessage).content;
+							const textParts = content
+								.filter((c): c is { type: "text"; text: string } => c.type === "text")
+								.map(c => c.text);
+							if (textParts.length > 0) {
+								handoffText = textParts.join("\n");
+								break;
+							}
+						}
+					}
+					resolve();
+				}
+			});
+		});
+
+		try {
+			// Send the prompt and wait for completion
+			await this.prompt(handoffPrompt, { expandPromptTemplates: false });
+			await completionPromise;
+
+			if (!handoffText || this._handoffAbortController.signal.aborted) {
+				return undefined;
+			}
+
+			// Start a new session
+			await this.sessionManager.flush();
+			this.sessionManager.newSession();
+			this.agent.reset();
+			this.agent.sessionId = this.sessionManager.getSessionId();
+			this._steeringMessages = [];
+			this._followUpMessages = [];
+			this._pendingNextTurnMessages = [];
+			this._todoReminderCount = 0;
+
+			// Inject the handoff document as a custom message
+			const handoffContent = `<handoff-context>\n${handoffText}\n</handoff-context>\n\nThe above is a handoff document from a previous session. Use this context to continue the work seamlessly.`;
+			this.sessionManager.appendCustomMessageEntry("handoff", handoffContent, true);
+
+			// Rebuild agent messages from session
+			const sessionContext = this.sessionManager.buildSessionContext();
+			this.agent.replaceMessages(sessionContext.messages);
+
+			return { document: handoffText };
+		} finally {
+			this._handoffAbortController = undefined;
+		}
+	}
+
 	/**
 	 * Check if compaction is needed and run it.
 	 * Called after agent_end and before prompt submission.

package/src/task/executor.ts

@@ -81,6 +81,7 @@ export interface ExecutorOptions {
 	modelRegistry?: ModelRegistry;
 	settingsManager?: {
 		serialize: () => import("@oh-my-pi/pi-coding-agent/config/settings-manager").Settings;
+		getPlansDirectory: (cwd?: string) => string;
 		getPythonToolMode?: () => "ipy-only" | "bash-only" | "both";
 		getPythonKernelMode?: () => "session" | "per-call";
 		getPythonSharedGateway?: () => boolean;

package/src/task/index.ts

@@ -17,6 +17,9 @@ import * as os from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
+import planModeSubagentPrompt from "@oh-my-pi/pi-coding-agent/prompts/system/plan-mode-subagent.md" with {
+	type: "text",
+};
 import { $ } from "bun";
 import { nanoid } from "nanoid";
 import type { ToolSession } from "..";
@@ -192,14 +195,25 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			};
 		}
 
-		const effectiveAgentModel = isDefaultModelAlias(agent.model) ? undefined : agent.model;
+		const planModeState = this.session.getPlanModeState?.();
+		const planModeTools = ["read", "grep", "find", "ls", "lsp", "fetch", "web_search"];
+		const effectiveAgent: typeof agent = planModeState?.enabled
+			? {
+					...agent,
+					systemPrompt: `${planModeSubagentPrompt}\n\n${agent.systemPrompt}`,
+					tools: planModeTools,
+					spawns: undefined,
+				}
+			: agent;
+
+		const effectiveAgentModel = isDefaultModelAlias(effectiveAgent.model) ? undefined : effectiveAgent.model;
 		const modelOverride =
 			effectiveAgentModel ?? this.session.getActiveModelString?.() ?? this.session.getModelString?.();
-		const thinkingLevelOverride = agent.thinkingLevel;
+		const thinkingLevelOverride = effectiveAgent.thinkingLevel;
 
 		// Output schema priority: agent frontmatter > params > inherited from parent session
-		const schemaOverridden = outputSchema !== undefined && agent.output !== undefined;
-		const effectiveOutputSchema = agent.output ?? outputSchema ?? this.session.outputSchema;
+		const schemaOverridden = outputSchema !== undefined && effectiveAgent.output !== undefined;
+		const effectiveOutputSchema = effectiveAgent.output ?? outputSchema ?? this.session.outputSchema;
 
 		// Handle empty or missing tasks
 		if (!params.tasks || params.tasks.length === 0) {

package/src/tools/enter-plan-mode.ts

@@ -0,0 +1,76 @@
+import * as fs from "node:fs/promises";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
+import { resolvePlanUrlToPath } from "@oh-my-pi/pi-coding-agent/internal-urls";
+import enterPlanModeDescription from "@oh-my-pi/pi-coding-agent/prompts/tools/enter-plan-mode.md" with { type: "text" };
+import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
+import { ToolError } from "@oh-my-pi/pi-coding-agent/tools/tool-errors";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import { Type } from "@sinclair/typebox";
+
+const enterPlanModeSchema = Type.Object({
+	workflow: Type.Optional(Type.Union([Type.Literal("parallel"), Type.Literal("iterative")])),
+});
+
+export interface EnterPlanModeDetails {
+	planFilePath: string;
+	planExists: boolean;
+	workflow?: "parallel" | "iterative";
+}
+
+export class EnterPlanModeTool implements AgentTool<typeof enterPlanModeSchema, EnterPlanModeDetails> {
+	public readonly name = "enter_plan_mode";
+	public readonly label = "EnterPlanMode";
+	public readonly description: string;
+	public readonly parameters = enterPlanModeSchema;
+
+	private readonly session: ToolSession;
+
+	constructor(session: ToolSession) {
+		this.session = session;
+		this.description = renderPromptTemplate(enterPlanModeDescription);
+	}
+
+	public async execute(
+		_toolCallId: string,
+		params: { workflow?: "parallel" | "iterative" },
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<EnterPlanModeDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<EnterPlanModeDetails>> {
+		const state = this.session.getPlanModeState?.();
+		if (state?.enabled) {
+			throw new ToolError("Plan mode is already active.");
+		}
+
+		const sessionId = this.session.getSessionId?.();
+		if (!sessionId) {
+			throw new ToolError("Plan mode requires an active session.");
+		}
+
+		const settingsManager = this.session.settingsManager;
+		if (!settingsManager) {
+			throw new ToolError("Settings manager unavailable for plan mode.");
+		}
+
+		const planFilePath = `plan://${sessionId}/plan.md`;
+		const resolvedPlanPath = resolvePlanUrlToPath(planFilePath, {
+			getPlansDirectory: settingsManager.getPlansDirectory.bind(settingsManager),
+			cwd: this.session.cwd,
+		});
+		let planExists = false;
+		try {
+			const stat = await fs.stat(resolvedPlanPath);
+			planExists = stat.isFile();
+		} catch (error) {
+			if (!isEnoent(error)) {
+				throw error;
+			}
+		}
+
+		return {
+			content: [{ type: "text", text: "Plan mode requested." }],
+			details: { planFilePath, planExists, workflow: params.workflow },
+		};
+	}
+}

package/src/tools/exit-plan-mode.ts

@@ -0,0 +1,62 @@
+import * as fs from "node:fs/promises";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import { Type } from "@sinclair/typebox";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import exitPlanModeDescription from "../prompts/tools/exit-plan-mode.md" with { type: "text" };
+import type { ToolSession } from ".";
+import { resolvePlanPath } from "./plan-mode-guard";
+import { ToolError } from "./tool-errors";
+
+const exitPlanModeSchema = Type.Object({});
+
+export interface ExitPlanModeDetails {
+	planFilePath: string;
+	planExists: boolean;
+}
+
+export class ExitPlanModeTool implements AgentTool<typeof exitPlanModeSchema, ExitPlanModeDetails> {
+	public readonly name = "exit_plan_mode";
+	public readonly label = "ExitPlanMode";
+	public readonly description: string;
+	public readonly parameters = exitPlanModeSchema;
+
+	private readonly session: ToolSession;
+
+	constructor(session: ToolSession) {
+		this.session = session;
+		this.description = renderPromptTemplate(exitPlanModeDescription);
+	}
+
+	public async execute(
+		_toolCallId: string,
+		_params: Record<string, never>,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<ExitPlanModeDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<ExitPlanModeDetails>> {
+		const state = this.session.getPlanModeState?.();
+		if (!state?.enabled) {
+			throw new ToolError("Plan mode is not active.");
+		}
+
+		const resolvedPlanPath = resolvePlanPath(this.session, state.planFilePath);
+		let planExists = false;
+		try {
+			const stat = await fs.stat(resolvedPlanPath);
+			planExists = stat.isFile();
+		} catch (error) {
+			if (!isEnoent(error)) {
+				throw error;
+			}
+		}
+
+		return {
+			content: [{ type: "text", text: "Plan ready for approval." }],
+			details: {
+				planFilePath: state.planFilePath,
+				planExists,
+			},
+		};
+	}
+}

package/src/tools/find.ts

@@ -127,7 +127,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		params: Static<typeof findSchema>,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
-		_context?: AgentToolContext,
+		context?: AgentToolContext,
 	): Promise<AgentToolResult<FindToolDetails>> {
 		const { pattern, path: searchDir, limit, hidden, type } = params;
 
@@ -196,7 +196,10 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			}
 
 			// Default: use fd
-			const fdPath = await ensureTool("fd", true);
+			const fdPath = await ensureTool("fd", {
+				silent: true,
+				notify: message => context?.ui?.notify(message, "info"),
+			});
 			if (!fdPath) {
 				throw new ToolError("fd is not available and could not be downloaded");
 			}