@oh-my-pi/pi-coding-agent 14.7.0 → 14.7.2

package/src/sdk.ts

@@ -81,7 +81,6 @@ import {
 	collectDiscoverableMCPTools,
 	formatDiscoverableMCPToolServerSummary,
 	selectDiscoverableMCPToolNamesByServer,
-	summarizeDiscoverableMCPTools,
 } from "./mcp/discoverable-tool-metadata";
 import { getMemoryRoot } from "./memories";
 import { resolveMemoryBackend } from "./memory-backend";
@@ -110,9 +109,15 @@ import {
 } from "./system-prompt";
 import { AgentOutputManager } from "./task/output-manager";
 import { parseThinkingLevel, resolveThinkingLevelForModel, toReasoningEffort } from "./thinking";
+import {
+	collectDiscoverableTools,
+	type DiscoverableTool,
+	summarizeDiscoverableTools,
+} from "./tool-discovery/tool-index";
 import {
 	BashTool,
 	BUILTIN_TOOLS,
+	computeEssentialBuiltinNames,
 	createTools,
 	discoverStartupLspServers,
 	EditTool,
@@ -995,6 +1000,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			getDiscoverableMCPSearchIndex: () => session.getDiscoverableMCPSearchIndex(),
 			getSelectedMCPToolNames: () => session.getSelectedMCPToolNames(),
 			activateDiscoveredMCPTools: toolNames => session.activateDiscoveredMCPTools(toolNames),
+			// Generic tool discovery (unified — covers built-in + MCP + extension)
+			isToolDiscoveryEnabled: () => session.isToolDiscoveryEnabled(),
+			getDiscoverableTools: filter => session.getDiscoverableTools(filter),
+			getDiscoverableToolSearchIndex: () => session.getDiscoverableToolSearchIndex(),
+			getSelectedDiscoveredToolNames: () => session.getSelectedDiscoveredToolNames(),
+			activateDiscoveredTools: toolNames => session.activateDiscoveredTools(toolNames),
 			getCheckpointState: () => session.getCheckpointState(),
 			setCheckpointState: state => session.setCheckpointState(state ?? undefined),
 			getToolChoiceQueue: () => session.toolChoiceQueue,
@@ -1344,11 +1355,33 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		): Promise<BuildSystemPromptResult> => {
 			toolContextStore.setToolNames(toolNames);
 			const discoverableMCPTools = mcpDiscoveryEnabled ? collectDiscoverableMCPTools(tools.values()) : [];
-			const discoverableMCPSummary = summarizeDiscoverableMCPTools(discoverableMCPTools);
-			const hasDiscoverableMCPTools =
-				mcpDiscoveryEnabled && toolNames.includes("search_tool_bm25") && discoverableMCPTools.length > 0;
+			const activeToolNames = new Set(toolNames);
+			const discoverableBuiltinTools: DiscoverableTool[] =
+				effectiveDiscoveryMode === "all"
+					? collectDiscoverableTools(
+							Array.from(tools.values()).filter(
+								tool => tool.loadMode === "discoverable" && !activeToolNames.has(tool.name),
+							),
+							{ source: "builtin" },
+						)
+					: [];
+			const discoverableToolsForDesc: DiscoverableTool[] = [
+				...discoverableBuiltinTools,
+				...discoverableMCPTools.map(t => ({
+					name: t.name,
+					label: t.label,
+					summary: t.description,
+					source: "mcp" as const,
+					serverName: t.serverName,
+					mcpToolName: t.mcpToolName,
+					schemaKeys: t.schemaKeys,
+				})),
+			];
+			const discoverableToolSummary = summarizeDiscoverableTools(discoverableToolsForDesc);
+			const hasDiscoverableTools =
+				mcpDiscoveryEnabled && toolNames.includes("search_tool_bm25") && discoverableToolsForDesc.length > 0;
 			const promptTools = buildSystemPromptToolMetadata(tools, {
-				search_tool_bm25: { description: renderSearchToolBm25Description(discoverableMCPTools) },
+				search_tool_bm25: { description: renderSearchToolBm25Description(discoverableToolsForDesc) },
 			});
 			const memoryInstructions = await resolveMemoryBackend(settings).buildDeveloperInstructions(
 				agentDir,
@@ -1386,8 +1419,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				appendSystemPrompt: appendPrompt,
 				repeatToolDescriptions,
 				intentField,
-				mcpDiscoveryMode: hasDiscoverableMCPTools,
-				mcpDiscoveryServerSummaries: discoverableMCPSummary.servers.map(formatDiscoverableMCPToolServerSummary),
+				mcpDiscoveryMode: hasDiscoverableTools,
+				mcpDiscoveryServerSummaries: discoverableToolSummary.servers.map(formatDiscoverableMCPToolServerSummary),
 				eagerTasks,
 				secretsEnabled,
 				agentsMdSearch: agentsMdSearchPromise,
@@ -1411,7 +1444,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			toolNamesFromRegistry;
 		const normalizedRequested = requestedToolNames.filter(name => toolRegistry.has(name));
 		const includeExitPlanMode = requestedToolNames.includes("exit_plan_mode");
-		const mcpDiscoveryEnabled = settings.get("mcp.discoveryMode") ?? false;
+		// Effective discovery mode: tools.discoveryMode takes precedence; mcp.discoveryMode is back-compat alias.
+		const toolsDiscoveryModeSetting = settings.get("tools.discoveryMode");
+		const effectiveDiscoveryMode: "off" | "mcp-only" | "all" =
+			toolsDiscoveryModeSetting !== "off"
+				? (toolsDiscoveryModeSetting as "off" | "mcp-only" | "all")
+				: settings.get("mcp.discoveryMode")
+					? "mcp-only"
+					: "off";
+		const mcpDiscoveryEnabled = effectiveDiscoveryMode !== "off"; // back-compat: true when any discovery active
 		const defaultInactiveToolNames = new Set(
 			registeredTools.filter(tool => tool.definition.defaultInactive).map(tool => tool.definition.name),
 		);
@@ -1468,6 +1509,26 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 		}
 
+		// When tools.discoveryMode === "all", hide non-essential built-in discoverable tools
+		// from the initial set unless they were explicitly requested or restored from persistence.
+		// The model finds them via search_tool_bm25 and activates them on demand.
+		if (effectiveDiscoveryMode === "all") {
+			const essentialBuiltinNames = new Set(computeEssentialBuiltinNames(settings));
+			const explicitlyRequestedToolNames = new Set(options.toolNames?.map(name => name.toLowerCase()) ?? []);
+			// Back-compat: persisted activations live under selectedMCPToolNames today (built-in
+			// activation persistence is a follow-up). MCP names won't collide with built-in names.
+			const restoredDiscoveredNames = new Set(existingSession.selectedMCPToolNames);
+			initialToolNames = initialToolNames.filter(name => {
+				const tool = toolRegistry.get(name);
+				if (!tool?.loadMode) return true; // not a built-in — leave MCP/custom/extension to existing logic
+				if (tool.loadMode === "essential") return true;
+				if (essentialBuiltinNames.has(name)) return true;
+				if (explicitlyRequestedToolNames.has(name)) return true;
+				if (restoredDiscoveredNames.has(name)) return true;
+				return false;
+			});
+		}
+
 		const { systemPrompt } = await logger.time(
 			"buildSystemPrompt",
 			rebuildSystemPrompt,

package/src/session/agent-session.ts

@@ -129,6 +129,12 @@ import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { t
 import { type AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
 import { deobfuscateSessionContext, type SecretObfuscator } from "../secrets/obfuscator";
 import { resolveThinkingLevelForModel, toReasoningEffort } from "../thinking";
+import {
+	buildDiscoverableToolSearchIndex,
+	collectDiscoverableTools,
+	type DiscoverableTool,
+	type DiscoverableToolSearchIndex,
+} from "../tool-discovery/tool-index";
 import { assertEditableFile } from "../tools/auto-generated-guard";
 import type { CheckpointState } from "../tools/checkpoint";
 import { outputMeta } from "../tools/output-meta";
@@ -536,6 +542,9 @@ export class AgentSession {
 	#discoverableMCPTools = new Map<string, DiscoverableMCPTool>();
 	#discoverableMCPSearchIndex: DiscoverableMCPSearchIndex | null = null;
 	#selectedMCPToolNames = new Set<string>();
+	// Generic tool discovery (covers built-in + MCP + extension when tools.discoveryMode === "all")
+	#discoverableToolSearchIndex: DiscoverableToolSearchIndex | null = null;
+	#selectedDiscoveredToolNames = new Set<string>();
 	#rpcHostToolNames = new Set<string>();
 	#defaultSelectedMCPServerNames = new Set<string>();
 	#defaultSelectedMCPToolNames = new Set<string>();
@@ -2101,7 +2110,15 @@ export class AgentSession {
 
 	#setDiscoverableMCPTools(discoverableMCPTools: Map<string, DiscoverableMCPTool>): void {
 		this.#discoverableMCPTools = discoverableMCPTools;
+		this.#invalidateDiscoveryCaches();
+	}
+
+	/** Single point for invalidating cached discovery indices. Call after any change that can
+	 *  affect which tools should be discoverable: registry mutations (refreshMCPTools,
+	 *  refreshRpcHostTools) or active-tool mutations (#applyActiveToolsByName). */
+	#invalidateDiscoveryCaches(): void {
 		this.#discoverableMCPSearchIndex = null;
+		this.#discoverableToolSearchIndex = null;
 	}
 
 	#filterSelectableMCPToolNames(toolNames: Iterable<string>): string[] {
@@ -2204,10 +2221,21 @@ export class AgentSession {
 		return this.#mcpDiscoveryEnabled;
 	}
 
+	/** @deprecated Use {@link getDiscoverableTools} with `{ source: "mcp" }` instead.
+	 *  Preserves the legacy `description`-bearing MCP shape for back-compat callers. */
 	getDiscoverableMCPTools(): DiscoverableMCPTool[] {
-		return Array.from(this.#discoverableMCPTools.values());
+		return Array.from(this.#discoverableMCPTools.values()).map(t => ({
+			name: t.name,
+			label: t.label,
+			description: t.description,
+			serverName: t.serverName,
+			mcpToolName: t.mcpToolName,
+			schemaKeys: t.schemaKeys,
+		}));
 	}
 
+	/** @deprecated Use {@link getDiscoverableToolSearchIndex} instead.
+	 *  Returns the legacy MCP search index whose documents expose `tool.description`. */
 	getDiscoverableMCPSearchIndex(): DiscoverableMCPSearchIndex {
 		if (!this.#discoverableMCPSearchIndex) {
 			this.#discoverableMCPSearchIndex = buildDiscoverableMCPSearchIndex(this.#discoverableMCPTools.values());
@@ -2243,6 +2271,113 @@ export class AgentSession {
 		return [...new Set(activated)];
 	}
 
+	// ── Generic tool discovery (covers built-in + MCP + extension) ────────────
+
+	/** Resolve effective discovery mode: tools.discoveryMode wins; mcp.discoveryMode is back-compat alias. */
+	#resolveEffectiveDiscoveryMode(): "off" | "mcp-only" | "all" {
+		const toolsMode = this.settings.get("tools.discoveryMode");
+		if (toolsMode !== "off") return toolsMode as "off" | "mcp-only" | "all";
+		if (this.settings.get("mcp.discoveryMode")) return "mcp-only";
+		return "off";
+	}
+
+	isToolDiscoveryEnabled(): boolean {
+		return this.#resolveEffectiveDiscoveryMode() !== "off";
+	}
+
+	getDiscoverableTools(filter?: { source?: DiscoverableTool["source"] }): DiscoverableTool[] {
+		// For "all" mode we combine built-in registry entries + MCP tools.
+		// For "mcp-only" mode we only return MCP tools.
+		const mode = this.#resolveEffectiveDiscoveryMode();
+		const activeNames = new Set(this.getActiveToolNames());
+		const mcpTools: DiscoverableTool[] = Array.from(this.#discoverableMCPTools.values())
+			.filter(t => !activeNames.has(t.name))
+			.map(t => ({
+				name: t.name,
+				label: t.label,
+				summary: t.description,
+				source: "mcp" as const,
+				serverName: t.serverName,
+				mcpToolName: t.mcpToolName,
+				schemaKeys: t.schemaKeys,
+			}));
+		const builtinTools: DiscoverableTool[] = mode === "all" ? this.#collectDiscoverableBuiltinTools() : [];
+		const allTools = [...builtinTools, ...mcpTools];
+		return filter?.source ? allTools.filter(t => t.source === filter.source) : allTools;
+	}
+
+	/** Collect built-in tools the model can discover via search_tool_bm25. Restricted to tool
+	 *  definitions whose `loadMode === "discoverable"`. This keeps hidden/internal tools
+	 *  (resolve, yield, exit_plan_mode, report_finding, report_tool_issue) out of the index
+	 *  and avoids mislabeling extension/custom default-inactive tools as built-ins. */
+	#collectDiscoverableBuiltinTools(): DiscoverableTool[] {
+		const activeNames = new Set(this.getActiveToolNames());
+		const result: DiscoverableTool[] = [];
+		for (const tool of this.#toolRegistry.values()) {
+			if (tool.loadMode !== "discoverable") continue;
+			if (activeNames.has(tool.name)) continue;
+			const collected = collectDiscoverableTools([tool], { source: "builtin" });
+			result.push(...collected);
+		}
+		return result;
+	}
+
+	getDiscoverableToolSearchIndex(): DiscoverableToolSearchIndex {
+		if (!this.#discoverableToolSearchIndex) {
+			this.#discoverableToolSearchIndex = buildDiscoverableToolSearchIndex(this.getDiscoverableTools());
+		}
+		return this.#discoverableToolSearchIndex;
+	}
+
+	/** Invalidate the generic search index cache (call after tool set changes).
+	 *  Delegates to {@link #invalidateDiscoveryCaches} so all discovery-related caches stay in sync. */
+	#invalidateDiscoverableToolSearchIndex(): void {
+		this.#invalidateDiscoveryCaches();
+	}
+
+	getSelectedDiscoveredToolNames(): string[] {
+		// Union of MCP-selected and generic non-MCP selected. Non-MCP selections are only
+		// selected while they are still active; otherwise BM25 must be able to rediscover them.
+		const activeNames = new Set(this.getActiveToolNames());
+		const mcpSelected = this.getSelectedMCPToolNames();
+		const nonMcpSelected = Array.from(this.#selectedDiscoveredToolNames).filter(
+			name => activeNames.has(name) && this.#toolRegistry.has(name) && !isMCPToolName(name),
+		);
+		return [...new Set([...mcpSelected, ...nonMcpSelected])];
+	}
+
+	async activateDiscoveredTools(toolNames: string[]): Promise<string[]> {
+		const mcpNames = toolNames.filter(isMCPToolName);
+		const nonMcpNames = toolNames.filter(name => !isMCPToolName(name));
+		const activated: string[] = [];
+
+		// Activate MCP tools via existing path
+		if (mcpNames.length > 0) {
+			const activatedMcp = await this.activateDiscoveredMCPTools(mcpNames);
+			activated.push(...activatedMcp);
+		}
+
+		// Activate non-MCP tools (built-ins that are in the registry but not currently active)
+		if (nonMcpNames.length > 0) {
+			const currentActiveNames = new Set(this.getActiveToolNames());
+			const newlyAdded: string[] = [];
+			for (const name of nonMcpNames) {
+				if (this.#toolRegistry.has(name) && !currentActiveNames.has(name)) {
+					newlyAdded.push(name);
+					this.#selectedDiscoveredToolNames.add(name);
+					activated.push(name);
+				}
+			}
+			if (newlyAdded.length > 0) {
+				const nextActive = [...this.getActiveToolNames(), ...newlyAdded];
+				await this.setActiveToolsByName(nextActive);
+				this.#invalidateDiscoverableToolSearchIndex();
+			}
+		}
+
+		return [...new Set(activated)];
+	}
+
 	async #applyActiveToolsByName(
 		toolNames: string[],
 		options?: { persistMCPSelection?: boolean; previousSelectedMCPToolNames?: string[] },
@@ -2273,8 +2408,18 @@ export class AgentSession {
 				),
 			);
 		}
+		const activeNameSet = new Set(validToolNames);
+		for (const name of Array.from(this.#selectedDiscoveredToolNames)) {
+			if (!activeNameSet.has(name) || isMCPToolName(name) || !this.#toolRegistry.has(name)) {
+				this.#selectedDiscoveredToolNames.delete(name);
+			}
+		}
 		this.agent.setTools(tools);
 
+		// Active tool set changed → discoverable tool list (which excludes already-active tools)
+		// is now stale. Invalidate before any prompt-template hook reads the discovery list.
+		this.#invalidateDiscoveryCaches();
+
 		// Rebuild base system prompt with new tool set, but only when the tool set
 		// actually changed. MCP servers can reconnect at arbitrary times and call
 		// `refreshMCPTools` -> `#applyActiveToolsByName` even though the resulting
@@ -2509,6 +2654,11 @@ export class AgentSession {
 			this.#rpcHostToolNames.add(finalTool.name);
 		}
 
+		// Registry contents changed — invalidate discovery caches so the next BM25 lookup sees
+		// the new RPC-host tool set. (#applyActiveToolsByName below also invalidates, but doing
+		// it here too keeps the contract local to "registry mutated".)
+		this.#invalidateDiscoveryCaches();
+
 		const activeNonRpcToolNames = previousActiveToolNames.filter(name => !previousRpcHostToolNames.has(name));
 		const preservedRpcToolNames = previousActiveToolNames.filter(
 			name => previousRpcHostToolNames.has(name) && this.#rpcHostToolNames.has(name),
@@ -5983,6 +6133,32 @@ export class AgentSession {
 	setAutoRetryEnabled(enabled: boolean): void {
 		this.settings.set("retry.enabled", enabled);
 	}
+	/**
+	 * Manually retry the last failed assistant turn.
+	 * Removes the error message from agent state and re-attempts with a fresh retry budget.
+	 * @returns true if retry was initiated, false if no failed turn to retry or agent is busy
+	 */
+	async retry(): Promise<boolean> {
+		if (this.isStreaming || this.isCompacting || this.isRetrying) return false;
+
+		const messages = this.agent.state.messages;
+		const lastMsg = messages[messages.length - 1];
+		if (lastMsg?.role !== "assistant") return false;
+
+		const assistantMsg = lastMsg as AssistantMessage;
+		if (assistantMsg.stopReason !== "error" && assistantMsg.stopReason !== "aborted") return false;
+
+		// Remove the failed/aborted assistant message (same as auto-retry does before re-attempting)
+		this.agent.replaceMessages(messages.slice(0, -1));
+
+		// Reset retry budget for a fresh attempt
+		this.#retryAttempt = 0;
+
+		// Re-attempt the turn
+		this.#scheduleAgentContinue({ delayMs: 1 });
+
+		return true;
+	}
 
 	// =========================================================================
 	// Bash Execution

package/src/slash-commands/builtin-registry.ts

@@ -57,8 +57,8 @@ interface BuiltinSlashCommandSpec extends BuiltinSlashCommand {
 	handle: (
 		command: ParsedBuiltinSlashCommand,
 		runtime: BuiltinSlashCommandRuntime,
-		// biome-ignore lint/suspicious/noConfusingVoidType: void needed so handlers returning nothing are assignable
-	) => Promise<string | undefined> | string | void;
+		// biome-ignore lint/suspicious/noConfusingVoidType: void needed so async handlers returning nothing are assignable
+	) => Promise<string | void> | string | void;
 }
 
 export interface BuiltinSlashCommandRuntime {
@@ -572,6 +572,17 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			await runtime.ctx.handleBtwCommand(question);
 		},
 	},
+	{
+		name: "retry",
+		description: "Retry the last failed agent turn",
+		handle: async (_command, runtime) => {
+			const didRetry = await runtime.ctx.session.retry();
+			if (!didRetry) {
+				runtime.ctx.showStatus("Nothing to retry");
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "background",
 		aliases: ["bg"],

package/src/task/index.ts

@@ -195,7 +195,9 @@ function validateTaskModeParams(simpleMode: TaskSimpleMode, params: TaskParams):
 export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 	readonly name = "task";
 	readonly label = "Task";
+	readonly summary = "Spawn a subagent to complete a parallel task";
 	readonly strict = true;
+	readonly loadMode = "discoverable";
 	readonly renderResult = renderResult;
 	readonly #discoveredAgents: AgentDefinition[];
 	readonly #blockedAgent: string | undefined;

package/src/task/isolation-backend.ts

@@ -9,11 +9,26 @@ export interface IsolationBackendResolution {
 	warning: string;
 }
 
+type ProcessorEnv = Partial<Pick<NodeJS.ProcessEnv, "PROCESSOR_ARCHITECTURE" | "PROCESSOR_ARCHITEW6432">>;
+
+function isWindowsArm64HostUnderX64Emulation(
+	platform: NodeJS.Platform,
+	arch: NodeJS.Architecture,
+	env: ProcessorEnv,
+): boolean {
+	if (platform !== "win32" || arch !== "x64") return false;
+	return (
+		env.PROCESSOR_ARCHITECTURE?.toUpperCase() === "ARM64" || env.PROCESSOR_ARCHITEW6432?.toUpperCase() === "ARM64"
+	);
+}
+
 export async function resolveIsolationBackendForTaskExecution(
 	requestedMode: TaskIsolationMode,
 	isIsolated: boolean,
 	repoRoot: string | null,
 	platform: NodeJS.Platform = process.platform,
+	arch: NodeJS.Architecture = process.arch,
+	env: ProcessorEnv = process.env as ProcessorEnv,
 ): Promise<IsolationBackendResolution> {
 	let effectiveIsolationMode = requestedMode;
 	let warning = "";
@@ -39,6 +54,13 @@ export async function resolveIsolationBackendForTaskExecution(
 		return { effectiveIsolationMode, warning };
 	}
 
+	if (isWindowsArm64HostUnderX64Emulation(platform, arch, env)) {
+		effectiveIsolationMode = "worktree";
+		warning =
+			"<system-notification>ProjFS isolation is disabled on Windows ARM64 x64 emulation. Falling back to worktree isolation.</system-notification>";
+		return { effectiveIsolationMode, warning };
+	}
+
 	const probe = projfsOverlayProbe();
 	if (!probe.available) {
 		effectiveIsolationMode = "worktree";