@oh-my-pi/pi-coding-agent 15.9.0 → 15.9.3

package/src/internal-urls/omp-protocol.ts

@@ -64,9 +64,15 @@ export class OmpProtocolHandler implements ProtocolHandler {
 			throw new Error("Path traversal (..) is not allowed in omp:// URLs");
 		}
 
-		const content = EMBEDDED_DOCS[normalized];
+		const docPath =
+			normalized === "docs" ? "" : normalized.startsWith("docs/") ? normalized.slice("docs/".length) : normalized;
+		if (!docPath) {
+			return this.#listDocs(url);
+		}
+
+		const content = EMBEDDED_DOCS[docPath];
 		if (content === undefined) {
-			const lookup = normalized.replace(/\.md$/, "");
+			const lookup = docPath.replace(/\.md$/, "");
 			const suggestions = EMBEDDED_DOC_FILENAMES.filter(
 				f => f.includes(lookup) || lookup.includes(f.replace(/\.md$/, "")),
 			).slice(0, 5);

package/src/main.ts

@@ -822,10 +822,12 @@ export async function runRootCommand(
 	if (parsedArgs.noTitle || parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui" || parsedArgs.mode === "acp") {
 		Bun.env.PI_NO_TITLE = "1";
 	}
-	const pipedInput = await logger.time("readPipedInput", readPipedInput);
+	const mode = parsedArgs.mode || "text";
+	const isProtocolMode = mode === "rpc" || mode === "rpc-ui" || mode === "acp";
+	// Protocol modes own stdin; treating it as prompt text would consume JSON-RPC frames before their transports start.
+	const pipedInput = isProtocolMode ? undefined : await logger.time("readPipedInput", readPipedInput);
 	const autoPrint = pipedInput !== undefined && !parsedArgs.print && parsedArgs.mode === undefined;
 	const isInteractive = !parsedArgs.print && !autoPrint && parsedArgs.mode === undefined;
-	const mode = parsedArgs.mode || "text";
 
 	// Initialize discovery system with settings for provider persistence
 	logger.time("initializeWithSettings", initializeWithSettings, settingsInstance);

package/src/mcp/json-rpc.ts

@@ -37,18 +37,25 @@ export interface JsonRpcResponse<T = unknown> {
 	};
 }
 
+/** Options controlling a single MCP JSON-RPC HTTP request. */
+export interface CallMcpOptions {
+	signal?: AbortSignal;
+}
+
 /**
  * Call an MCP server with JSON-RPC 2.0 over HTTPS.
  *
  * @param url - Full MCP server URL (including any query parameters)
  * @param method - JSON-RPC method name (e.g., "tools/list", "tools/call")
  * @param params - Method parameters
+ * @param options - Optional transport controls such as cancellation.
  * @returns Parsed JSON-RPC response
  */
 export async function callMCP<T = unknown>(
 	url: string,
 	method: string,
 	params?: Record<string, unknown>,
+	options?: CallMcpOptions,
 ): Promise<JsonRpcResponse<T>> {
 	const body = {
 		jsonrpc: "2.0",
@@ -64,6 +71,7 @@ export async function callMCP<T = unknown>(
 			Accept: "application/json, text/event-stream",
 		},
 		body: JSON.stringify(body),
+		signal: options?.signal,
 	});
 
 	if (!response.ok) {

package/src/mcp/manager.ts

@@ -6,7 +6,7 @@
  */
 import * as path from "node:path";
 import * as url from "node:url";
-import type { TSchema } from "@oh-my-pi/pi-ai";
+import { isDefinitiveOAuthFailure, type TSchema } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { SourceMeta } from "../capability/types";
 import { resolveConfigValue } from "../config/resolve-config-value";
@@ -1184,29 +1184,48 @@ export class MCPManager {
 							await this.#authStorage.set(credentialId, refreshedCredential);
 							credential = refreshedCredential;
 						} catch (refreshError) {
-							logger.warn("MCP OAuth refresh failed, using existing token", {
-								credentialId,
-								error: refreshError,
-							});
+							const errorMsg = refreshError instanceof Error ? refreshError.message : String(refreshError);
+							if (isDefinitiveOAuthFailure(errorMsg)) {
+								// `invalid_grant` / `invalid_token` / 401 from the token endpoint means
+								// the server has retired this credential — keeping the stale access
+								// token would just re-fail with 401 on every MCP request and leave a
+								// poisoned row in agent.db that survives restarts. Drop it now so the
+								// next connect attempt surfaces a clean "needs reauth" failure and
+								// the user can recover with `/mcp reauth <server>` (or `/mcp unauth`
+								// to forget the server entirely).
+								logger.warn("MCP OAuth refresh failed definitively; cleared credential", {
+									credentialId,
+									error: errorMsg,
+								});
+								await this.#authStorage.remove(credentialId);
+								credential = undefined;
+							} else {
+								logger.warn("MCP OAuth refresh failed, using existing token", {
+									credentialId,
+									error: refreshError,
+								});
+							}
 						}
 					}
 
-					if (resolved.type === "http" || resolved.type === "sse") {
-						resolved = {
-							...resolved,
-							headers: {
-								...resolved.headers,
-								Authorization: `Bearer ${credential.access}`,
-							},
-						};
-					} else {
-						resolved = {
-							...resolved,
-							env: {
-								...resolved.env,
-								OAUTH_ACCESS_TOKEN: credential.access,
-							},
-						};
+					if (credential?.type === "oauth") {
+						if (resolved.type === "http" || resolved.type === "sse") {
+							resolved = {
+								...resolved,
+								headers: {
+									...resolved.headers,
+									Authorization: `Bearer ${credential.access}`,
+								},
+							};
+						} else {
+							resolved = {
+								...resolved,
+								env: {
+									...resolved.env,
+									OAUTH_ACCESS_TOKEN: credential.access,
+								},
+							};
+						}
 					}
 				}
 			} catch (error) {

package/src/mcp/render.ts

@@ -51,6 +51,9 @@ export function renderMCPResult(
 ): Component {
 	const { expanded } = options;
 	const lines: string[] = [];
+	const isError = result.isError ?? result.details?.isError ?? false;
+	const title = result.details ? `${result.details.serverName}/${result.details.mcpToolName}` : "MCP";
+	lines.push(renderStatusLine({ icon: isError ? "error" : "success", title }, theme));
 
 	// Args section (when expanded)
 	if (expanded && args && typeof args === "object" && Object.keys(args).length > 0) {

package/src/mcp/tool-bridge.ts

@@ -116,10 +116,12 @@ function buildResult(
 		provider,
 		providerName,
 	};
+	const contentText = result.isError ? `Error: ${text}` : text;
+	const toolResult: CustomToolResult<MCPToolDetails> = { content: [{ type: "text", text: contentText }], details };
 	if (result.isError) {
-		return { content: [{ type: "text", text: `Error: ${text}` }], details };
+		toolResult.isError = true;
 	}
-	return { content: [{ type: "text", text }], details };
+	return toolResult;
 }
 
 /** Build an error CustomToolResult from a caught exception. */
@@ -134,6 +136,7 @@ function buildErrorResult(
 	return {
 		content: [{ type: "text", text: `MCP error: ${message}` }],
 		details: { serverName, mcpToolName, isError: true, provider, providerName },
+		isError: true,
 	};
 }
 
@@ -217,6 +220,8 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	readonly mcpToolName: string;
 	/** Server name */
 	readonly mcpServerName: string;
+	/** Render completed MCP calls with the result header replacing the pending call header. */
+	readonly mergeCallAndResult = true;
 
 	/** Create MCPTool instances for all tools from an MCP server connection */
 	static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[], reconnect?: MCPReconnect): MCPTool[] {
@@ -300,6 +305,9 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	readonly mcpToolName: string;
 	/** Server name */
 	readonly mcpServerName: string;
+	/** Render completed MCP calls with the result header replacing the pending call header. */
+	readonly mergeCallAndResult = true;
+
 	readonly #fallbackProvider: string | undefined;
 	readonly #fallbackProviderName: string | undefined;
 

package/src/mcp/transports/http.ts

@@ -87,45 +87,62 @@ export class HttpTransport implements MCPTransport {
 			headers["Mcp-Session-Id"] = this.#sessionId;
 		}
 
-		let response: Response;
+		let response: Response | null;
 		let timedOut = false;
+		let startupFinished = false;
+		const connection = this.#sseConnection;
 		const startupTimeoutMs = resolveSSEConnectTimeoutMs(this.config.timeout);
-		const timeoutId =
+		const fetchPromise = fetch(this.config.url, {
+			method: "GET",
+			headers,
+			signal: connection.signal,
+		});
+		const timeoutPromise =
 			startupTimeoutMs > 0
-				? setTimeout(() => {
-						timedOut = true;
-						this.#sseConnection?.abort();
-					}, startupTimeoutMs)
+				? new Promise<null>(resolve => {
+						setTimeout(() => {
+							if (!startupFinished) {
+								timedOut = true;
+								connection.abort();
+							}
+							resolve(null);
+						}, startupTimeoutMs);
+					})
 				: null;
 		try {
-			response = await fetch(this.config.url, {
-				method: "GET",
-				headers,
-				signal: this.#sseConnection.signal,
-			});
+			response = timeoutPromise === null ? await fetchPromise : await Promise.race([fetchPromise, timeoutPromise]);
 		} catch (error) {
-			this.#sseConnection = null;
+			if (this.#sseConnection === connection) this.#sseConnection = null;
 			if (error instanceof Error && error.name !== "AbortError" && !timedOut) {
 				this.onError?.(error);
 			}
 			return;
 		} finally {
-			if (timeoutId !== null) clearTimeout(timeoutId);
+			startupFinished = true;
+		}
+		if (response === null) {
+			if (this.#sseConnection === connection) this.#sseConnection = null;
+			void fetchPromise.then(lateResponse => lateResponse.body?.cancel()).catch(() => {});
+			return;
 		}
 
+		if (this.#sseConnection !== connection) {
+			await response.body?.cancel();
+			return;
+		}
 		if (response.status === 405 || !response.ok || !response.body) {
 			await response.body?.cancel();
-			this.#sseConnection = null;
+			if (this.#sseConnection === connection) this.#sseConnection = null;
 			return;
 		}
 
 		// Connection established — read messages in background.
 		// If the stream ends unexpectedly (server restart, network drop),
 		// fire onClose so the manager can trigger reconnection.
-		const signal = this.#sseConnection.signal;
+		const signal = connection.signal;
 		void this.#readSSEStream(response.body!, signal).finally(() => {
 			const wasConnected = this.#connected;
-			this.#sseConnection = null;
+			if (this.#sseConnection === connection) this.#sseConnection = null;
 			if (wasConnected) this.onClose?.();
 		});
 	}

package/src/mnemopi/state.ts

@@ -173,7 +173,7 @@ export class MnemopiSessionState {
 		return lines.join("\n\n");
 	}
 
-	collectScopedRecallResults(query: string): RecallResult[] {
+	async collectScopedRecallResults(query: string): Promise<RecallResult[]> {
 		const merged: RecallResult[] = [];
 		const byId = new Map<string, number>();
 		const byContent = new Map<string, number>();
@@ -187,7 +187,7 @@ export class MnemopiSessionState {
 				target.bank === this.scoped.global?.bank && sharedFallbackQuery ? [query, sharedFallbackQuery] : [query];
 			try {
 				for (const recallQuery of queries) {
-					const results = target.memory.recallEnhanced(recallQuery, this.config.recallLimit, {
+					const results = await target.memory.recallEnhanced(recallQuery, this.config.recallLimit, {
 						includeFacts: true,
 						channelId: target.bank,
 					});
@@ -209,7 +209,7 @@ export class MnemopiSessionState {
 		return merged;
 	}
 
-	recallResultsScoped(query: string): RecallResult[] {
+	recallResultsScoped(query: string): Promise<RecallResult[]> {
 		return this.collectScopedRecallResults(query);
 	}
 
@@ -242,7 +242,7 @@ export class MnemopiSessionState {
 	}
 
 	async recallForContext(query: string): Promise<string | undefined> {
-		const results = this.collectScopedRecallResults(query);
+		const results = await this.collectScopedRecallResults(query);
 		if (results.length === 0) return undefined;
 		return formatRecallBlock(results);
 	}

package/src/modes/acp/acp-agent.ts

@@ -42,8 +42,9 @@ import {
 	type SetSessionModeResponse,
 	type Usage,
 } from "@agentclientprotocol/sdk";
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, Model } from "@oh-my-pi/pi-ai";
-import { logger, VERSION } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger, VERSION } from "@oh-my-pi/pi-utils";
 import { disableProvider, enableProvider, reset as resetCapabilities } from "../../capability";
 import { Settings } from "../../config/settings";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
@@ -56,10 +57,12 @@ import { runExtensionCompact } from "../../extensibility/extensions/compact-hand
 import { getSessionSlashCommands } from "../../extensibility/extensions/get-commands-handler";
 import { buildSkillPromptMessage, getSkillSlashCommandName } from "../../extensibility/skills";
 import { loadSlashCommands } from "../../extensibility/slash-commands";
+import { resolveLocalUrlToPath } from "../../internal-urls";
 import { MCPManager } from "../../mcp/manager";
 import type { MCPServerConfig } from "../../mcp/types";
 import { loadAllExtensions } from "../../modes/components/extensions/state-manager";
 import { theme } from "../../modes/theme/theme";
+import { type PlanApprovalDetails, renameApprovedPlanFile, resolvePlanTitle } from "../../plan-mode/approved-plan";
 import type { AgentSession, AgentSessionEvent } from "../../session/agent-session";
 import { isSilentAbort, SKILL_PROMPT_MESSAGE_TYPE } from "../../session/messages";
 import {
@@ -69,6 +72,9 @@ import {
 } from "../../session/session-manager";
 import { ACP_BUILTIN_SLASH_COMMANDS, executeAcpBuiltinSlashCommand } from "../../slash-commands/acp-builtins";
 import { AUTO_THINKING, parseConfiguredThinkingLevel } from "../../thinking";
+import { normalizeLocalScheme } from "../../tools/path-utils";
+import { runResolveInvocation } from "../../tools/resolve";
+import { ToolError } from "../../tools/tool-errors";
 import { createAcpClientBridge } from "./acp-client-bridge";
 import {
 	buildToolCallStartUpdate,
@@ -80,6 +86,8 @@ import { ACP_TERMINAL_AUTH_FLAG } from "./terminal-auth";
 const ACP_DEFAULT_MODE_ID = "default";
 const ACP_PLAN_MODE_ID = "plan";
 const DEFAULT_PLAN_FILE_URL = "local://PLAN.md";
+const APPROVE_OPTION = "Approve and execute";
+const REFINE_OPTION = "Refine plan";
 const MODE_CONFIG_ID = "mode";
 const MODEL_CONFIG_ID = "model";
 const THINKING_CONFIG_ID = "thinking";
@@ -1229,11 +1237,15 @@ export class AcpAgent implements Agent {
 	}
 
 	async #pushConfigOptionUpdate(record: ManagedSessionRecord): Promise<void> {
+		await this.#pushConfigOptionUpdateForSession(record.session);
+	}
+
+	async #pushConfigOptionUpdateForSession(session: AgentSession): Promise<void> {
 		await this.#connection.sessionUpdate({
-			sessionId: record.session.sessionId,
+			sessionId: session.sessionId,
 			update: {
 				sessionUpdate: "config_option_update",
-				configOptions: this.#buildConfigOptions(record.session),
+				configOptions: this.#buildConfigOptions(session),
 			},
 		});
 	}
@@ -1380,11 +1392,164 @@ export class AcpAgent implements Agent {
 				workflow: previous?.workflow ?? "parallel",
 				reentry: previous !== undefined,
 			});
+			// Mirror `InteractiveMode.#enterPlanMode`: register the standing resolve
+			// handler that consumes `resolve { action: "apply" }` from plan-mode.
+			// Without this, the agent's resolve call falls through to the "No
+			// pending action to resolve" error (issue #1869).
+			session.setStandingResolveHandler?.(input => this.#runAcpPlanApprovalResolve(session, input));
 		} else {
+			session.setStandingResolveHandler?.(null);
 			session.setPlanModeState(undefined);
 		}
 	}
 
+	/**
+	 * Standing resolve handler installed while ACP plan mode is active. The agent
+	 * submits the finalized plan via `resolve { action: "apply", extra: { title } }`;
+	 * this handler validates the plan file, normalizes the title, asks the ACP
+	 * client to confirm (via `unstable_createElicitation` when supported), and on
+	 * approval renames the plan to `local://<title>.md`, exits plan mode, and
+	 * notifies the client of both mode surfaces so the agent regains full tools.
+	 *
+	 * Mirrors `InteractiveMode.#runPlanApprovalResolve` for the parts the agent
+	 * sees (same `PlanApprovalDetails` shape, same source tool name `plan_approval`).
+	 * Clients without form-mode elicitation get an auto-approve so plan mode is
+	 * never stranded — the agent always has a way out.
+	 */
+	#runAcpPlanApprovalResolve(session: AgentSession, input: unknown): Promise<AgentToolResult<unknown>> {
+		return runResolveInvocation(input as Parameters<typeof runResolveInvocation>[0], {
+			sourceToolName: "plan_approval",
+			label: "Plan ready for approval",
+			apply: async (_reason, extra) => {
+				const state = session.getPlanModeState();
+				if (!state?.enabled) {
+					throw new ToolError("Plan mode is not active.");
+				}
+				const planFilePath = state.planFilePath;
+				const planContent = await this.#readAcpPlanFile(session, planFilePath);
+				if (planContent === null) {
+					throw new ToolError(
+						`Plan file not found at ${planFilePath}. Write the finalized plan to ${planFilePath} before requesting approval.`,
+					);
+				}
+				const normalized = resolvePlanTitle({
+					suppliedTitle: extra?.title,
+					planContent,
+					planFilePath,
+				});
+				const finalPlanFilePath = `local://${normalized.fileName}`;
+				const approved = await this.#requestAcpPlanApprovalChoice(session.sessionId, normalized.title, planContent);
+				const details: PlanApprovalDetails = {
+					planFilePath,
+					finalPlanFilePath,
+					title: normalized.title,
+					planExists: true,
+				};
+				if (!approved) {
+					// User chose to refine: leave plan mode active so the agent
+					// keeps the read-only toolset and can iterate on the plan file.
+					return {
+						content: [
+							{
+								type: "text" as const,
+								text: 'Plan refinement requested. Update the plan file, then call `resolve { action: "apply" }` again when ready.',
+							},
+						],
+						details,
+					};
+				}
+				// Approved. Rename plan to its titled filename, set the plan
+				// reference so the next turn injects the plan content as
+				// context, then exit plan mode so the agent regains full tools.
+				await renameApprovedPlanFile({
+					planFilePath,
+					finalPlanFilePath,
+					getArtifactsDir: () => session.sessionManager.getArtifactsDir(),
+					getSessionId: () => session.sessionManager.getSessionId(),
+				});
+				session.setPlanReferencePath(finalPlanFilePath);
+				session.setStandingResolveHandler?.(null);
+				session.setPlanModeState(undefined);
+				try {
+					await this.#connection.sessionUpdate({
+						sessionId: session.sessionId,
+						update: this.#buildCurrentModeUpdate(session),
+					});
+					await this.#pushConfigOptionUpdateForSession(session);
+				} catch (error) {
+					logger.warn("Failed to emit mode updates after plan approval", {
+						sessionId: session.sessionId,
+						error,
+					});
+				}
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `Plan approved at ${finalPlanFilePath}. Plan mode exited; proceed with the implementation.`,
+						},
+					],
+					details,
+				};
+			},
+		});
+	}
+
+	#resolveAcpPlanFilePath(session: AgentSession, planFilePath: string): string {
+		if (planFilePath.startsWith("local:")) {
+			const normalized = normalizeLocalScheme(planFilePath);
+			return resolveLocalUrlToPath(normalized, {
+				getArtifactsDir: () => session.sessionManager.getArtifactsDir(),
+				getSessionId: () => session.sessionManager.getSessionId(),
+			});
+		}
+		return path.resolve(session.sessionManager.getCwd(), planFilePath);
+	}
+
+	async #readAcpPlanFile(session: AgentSession, planFilePath: string): Promise<string | null> {
+		const resolvedPath = this.#resolveAcpPlanFilePath(session, planFilePath);
+		try {
+			return await Bun.file(resolvedPath).text();
+		} catch (error) {
+			if (isEnoent(error)) {
+				return null;
+			}
+			throw error;
+		}
+	}
+
+	/**
+	 * Ask the ACP client to confirm plan approval. Returns `true` only on an
+	 * explicit `APPROVE_OPTION` selection. Refine, dismissal (`undefined`), or
+	 * any unrecognized value falls through to refine semantics — the caller
+	 * keeps plan mode active and surfaces guidance text to the agent. Clients
+	 * without `elicitation.form` support auto-approve because there is no
+	 * confirmation surface available; without that, plan mode would strand
+	 * the agent (the bug this method exists to fix).
+	 */
+	async #requestAcpPlanApprovalChoice(sessionId: string, title: string, planContent: string): Promise<boolean> {
+		const supportsForm = this.#clientCapabilities?.elicitation?.form != null;
+		if (!supportsForm) return true;
+		// Include a short preview of the plan so the user has context in the
+		// dialog. Keep the body bounded — Zed renders elicitation messages
+		// inline and a multi-thousand-line plan blows out the dialog.
+		const previewLines = planContent.split("\n").slice(0, 12).join("\n");
+		const ellipsis = planContent.split("\n").length > 12 ? "\n…" : "";
+		const message = `Approve plan "${title}" and start implementation?\n\n${previewLines}${ellipsis}`;
+		const value = await elicitFromAcpClient(
+			this.#connection,
+			sessionId,
+			"select",
+			message,
+			{ type: "string", enum: [APPROVE_OPTION, REFINE_OPTION] },
+			undefined,
+		);
+		// Approve ONLY on the explicit approve selection. Dismissal, cancel,
+		// timeout, or any other non-approve response falls through to refine
+		// semantics so closing the dialog can never grant write access.
+		return value === APPROVE_OPTION;
+	}
+
 	#buildModeState(session: AgentSession): SessionModeState {
 		return {
 			availableModes: this.#getAvailableModes(session),