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

package/src/main.ts

@@ -5,13 +5,20 @@
  * createAgentSession() options. The SDK does the heavy lifting.
  */
 
-import { realpathSync } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import { $env, getProjectDir, logger, postmortem, setProjectDir, VERSION } from "@oh-my-pi/pi-utils";
+import {
+	$env,
+	getProjectDir,
+	logger,
+	normalizePathForComparison,
+	postmortem,
+	setProjectDir,
+	VERSION,
+} from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { Args } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
@@ -216,15 +223,6 @@ async function runInteractiveMode(
 	}
 }
 
-function normalizePathForComparison(value: string): string {
-	const resolved = path.resolve(value);
-	let realPath = resolved;
-	try {
-		realPath = realpathSync(resolved);
-	} catch {}
-	return process.platform === "win32" ? realPath.toLowerCase() : realPath;
-}
-
 async function promptForkSession(session: SessionInfo): Promise<boolean> {
 	if (!process.stdin.isTTY) {
 		return false;
@@ -353,10 +351,7 @@ async function maybeAutoChdir(parsed: Args): Promise<void> {
 		return;
 	}
 
-	const normalizePath = (value: string) => {
-		const resolved = realpathSync(path.resolve(value));
-		return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-	};
+	const normalizePath = normalizePathForComparison;
 
 	const cwd = normalizePath(getProjectDir());
 	const normalizedHome = normalizePath(home);

package/src/mcp/discoverable-tool-metadata.ts

@@ -1,202 +1,24 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-
-export interface DiscoverableMCPTool {
-	name: string;
-	label: string;
-	description: string;
-	serverName?: string;
-	mcpToolName?: string;
-	schemaKeys: string[];
-}
-
-export interface DiscoverableMCPToolServerSummary {
-	name: string;
-	toolCount: number;
-}
-
-export interface DiscoverableMCPToolSummary {
-	servers: DiscoverableMCPToolServerSummary[];
-	toolCount: number;
-}
-
-export function formatDiscoverableMCPToolServerSummary(server: DiscoverableMCPToolServerSummary): string {
-	const toolLabel = server.toolCount === 1 ? "tool" : "tools";
-	return `${server.name} (${server.toolCount} ${toolLabel})`;
-}
-
-export interface DiscoverableMCPSearchDocument {
-	tool: DiscoverableMCPTool;
-	termFrequencies: Map<string, number>;
-	length: number;
-}
-
-export interface DiscoverableMCPSearchIndex {
-	documents: DiscoverableMCPSearchDocument[];
-	averageLength: number;
-	documentFrequencies: Map<string, number>;
-}
-
-export interface DiscoverableMCPSearchResult {
-	tool: DiscoverableMCPTool;
-	score: number;
-}
-
-const BM25_K1 = 1.2;
-const BM25_B = 0.75;
-const FIELD_WEIGHTS = {
-	name: 6,
-	label: 4,
-	serverName: 2,
-	mcpToolName: 4,
-	description: 2,
-	schemaKey: 1,
-} as const;
-
-export function isMCPToolName(name: string): boolean {
-	return name.startsWith("mcp__");
-}
-
-function getSchemaPropertyKeys(parameters: unknown): string[] {
-	if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) return [];
-	const properties = (parameters as { properties?: unknown }).properties;
-	if (!properties || typeof properties !== "object" || Array.isArray(properties)) return [];
-	return Object.keys(properties as Record<string, unknown>).sort();
-}
-
-function tokenize(value: string): string[] {
-	return value
-		.replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-		.replace(/[^a-zA-Z0-9]+/g, " ")
-		.toLowerCase()
-		.trim()
-		.split(/\s+/)
-		.filter(token => token.length > 0);
-}
-
-function addWeightedTokens(termFrequencies: Map<string, number>, value: string | undefined, weight: number): void {
-	if (!value) return;
-	for (const token of tokenize(value)) {
-		termFrequencies.set(token, (termFrequencies.get(token) ?? 0) + weight);
-	}
-}
-
-function buildSearchDocument(tool: DiscoverableMCPTool): DiscoverableMCPSearchDocument {
-	const termFrequencies = new Map<string, number>();
-	addWeightedTokens(termFrequencies, tool.name, FIELD_WEIGHTS.name);
-	addWeightedTokens(termFrequencies, tool.label, FIELD_WEIGHTS.label);
-	addWeightedTokens(termFrequencies, tool.serverName, FIELD_WEIGHTS.serverName);
-	addWeightedTokens(termFrequencies, tool.mcpToolName, FIELD_WEIGHTS.mcpToolName);
-	addWeightedTokens(termFrequencies, tool.description, FIELD_WEIGHTS.description);
-	for (const schemaKey of tool.schemaKeys) {
-		addWeightedTokens(termFrequencies, schemaKey, FIELD_WEIGHTS.schemaKey);
-	}
-	const length = Array.from(termFrequencies.values()).reduce((sum, value) => sum + value, 0);
-	return { tool, termFrequencies, length };
-}
-
-export function getDiscoverableMCPTool(tool: AgentTool): DiscoverableMCPTool | null {
-	if (!isMCPToolName(tool.name)) return null;
-	const toolRecord = tool as AgentTool & {
-		label?: string;
-		description?: string;
-		mcpServerName?: string;
-		mcpToolName?: string;
-		parameters?: unknown;
-	};
-	return {
-		name: tool.name,
-		label: typeof toolRecord.label === "string" ? toolRecord.label : tool.name,
-		description: typeof toolRecord.description === "string" ? toolRecord.description : "",
-		serverName: typeof toolRecord.mcpServerName === "string" ? toolRecord.mcpServerName : undefined,
-		mcpToolName: typeof toolRecord.mcpToolName === "string" ? toolRecord.mcpToolName : undefined,
-		schemaKeys: getSchemaPropertyKeys(toolRecord.parameters),
-	};
-}
-
-export function collectDiscoverableMCPTools(tools: Iterable<AgentTool>): DiscoverableMCPTool[] {
-	const discoverable: DiscoverableMCPTool[] = [];
-	for (const tool of tools) {
-		const metadata = getDiscoverableMCPTool(tool);
-		if (metadata) {
-			discoverable.push(metadata);
-		}
-	}
-	return discoverable;
-}
-
-export function selectDiscoverableMCPToolNamesByServer(
-	tools: Iterable<DiscoverableMCPTool>,
-	serverNames: ReadonlySet<string>,
-): string[] {
-	if (serverNames.size === 0) return [];
-	return Array.from(tools)
-		.filter(tool => tool.serverName !== undefined && serverNames.has(tool.serverName))
-		.map(tool => tool.name);
-}
-
-export function summarizeDiscoverableMCPTools(tools: DiscoverableMCPTool[]): DiscoverableMCPToolSummary {
-	const serverToolCounts = new Map<string, number>();
-	for (const tool of tools) {
-		if (!tool.serverName) continue;
-		serverToolCounts.set(tool.serverName, (serverToolCounts.get(tool.serverName) ?? 0) + 1);
-	}
-	const servers = Array.from(serverToolCounts.entries())
-		.sort(([left], [right]) => left.localeCompare(right))
-		.map(([name, toolCount]) => ({ name, toolCount }));
-	return {
-		servers,
-		toolCount: tools.length,
-	};
-}
-
-export function buildDiscoverableMCPSearchIndex(tools: Iterable<DiscoverableMCPTool>): DiscoverableMCPSearchIndex {
-	const documents = Array.from(tools, buildSearchDocument);
-	const averageLength = documents.reduce((sum, document) => sum + document.length, 0) / documents.length || 1;
-	const documentFrequencies = new Map<string, number>();
-	for (const document of documents) {
-		for (const token of new Set(document.termFrequencies.keys())) {
-			documentFrequencies.set(token, (documentFrequencies.get(token) ?? 0) + 1);
-		}
-	}
-	return {
-		documents,
-		averageLength,
-		documentFrequencies,
-	};
-}
-
-export function searchDiscoverableMCPTools(
-	index: DiscoverableMCPSearchIndex,
-	query: string,
-	limit: number,
-): DiscoverableMCPSearchResult[] {
-	const queryTokens = tokenize(query);
-	if (queryTokens.length === 0) {
-		throw new Error("Query must contain at least one letter or number.");
-	}
-	if (index.documents.length === 0) {
-		return [];
-	}
-
-	const queryTermCounts = new Map<string, number>();
-	for (const token of queryTokens) {
-		queryTermCounts.set(token, (queryTermCounts.get(token) ?? 0) + 1);
-	}
-
-	return index.documents
-		.map(document => {
-			let score = 0;
-			for (const [token, queryTermCount] of queryTermCounts) {
-				const termFrequency = document.termFrequencies.get(token) ?? 0;
-				if (termFrequency === 0) continue;
-				const documentFrequency = index.documentFrequencies.get(token) ?? 0;
-				const idf = Math.log(1 + (index.documents.length - documentFrequency + 0.5) / (documentFrequency + 0.5));
-				const normalization = BM25_K1 * (1 - BM25_B + BM25_B * (document.length / index.averageLength));
-				score += queryTermCount * idf * ((termFrequency * (BM25_K1 + 1)) / (termFrequency + normalization));
-			}
-			return { tool: document.tool, score };
-		})
-		.filter(result => result.score > 0)
-		.sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name))
-		.slice(0, limit);
-}
+/**
+ * Back-compat re-export layer.
+ * All types and functions have moved to src/tool-discovery/tool-index.ts.
+ * This file exists solely so existing imports continue to compile without changes.
+ */
+export type {
+	DiscoverableMCPSearchDocument,
+	DiscoverableMCPSearchIndex,
+	DiscoverableMCPSearchResult,
+	DiscoverableMCPTool,
+	DiscoverableMCPToolServerSummary,
+	DiscoverableMCPToolSummary,
+} from "../tool-discovery/tool-index";
+
+export {
+	buildDiscoverableMCPSearchIndex,
+	collectDiscoverableMCPTools,
+	formatDiscoverableMCPToolServerSummary,
+	getDiscoverableMCPTool,
+	isMCPToolName,
+	searchDiscoverableMCPTools,
+	selectDiscoverableMCPToolNamesByServer,
+	summarizeDiscoverableMCPTools,
+} from "../tool-discovery/tool-index";

package/src/modes/components/extensions/extension-dashboard.ts

@@ -27,15 +27,24 @@ import { theme } from "../../../modes/theme/theme";
 import { matchesAppInterrupt } from "../../../modes/utils/keybinding-matchers";
 import { ExtensionList } from "./extension-list";
 import { InspectorPanel } from "./inspector-panel";
-import { applyFilter, createInitialState, filterByProvider, refreshState, toggleProvider } from "./state-manager";
+import {
+	applyDisabledExtensionsToState,
+	applyFilter,
+	createInitialState,
+	filterByProvider,
+	refreshState,
+	toggleProvider,
+} from "./state-manager";
 import type { DashboardState } from "./types";
 
 export class ExtensionDashboard extends Container {
 	#state!: DashboardState;
 	#mainList!: ExtensionList;
 	#inspector!: InspectorPanel;
+	#refreshToken = 0;
 
 	onClose?: () => void;
+	onRequestRender?: () => void;
 
 	private constructor(
 		private readonly cwd: string,
@@ -181,16 +190,20 @@ export class ExtensionDashboard extends Container {
 			}
 		}
 
+		this.#applyDisabledExtensions(disabled);
 		void this.#refreshFromState();
 	}
 
 	async #refreshFromState(): Promise<void> {
+		const refreshToken = ++this.#refreshToken;
 		// Remember current tab ID before refresh
 		const currentTabId = this.#state.tabs[this.#state.activeTabIndex]?.id;
 
 		const sm = this.settings ?? Settings.instance;
 		const disabledIds = sm ? ((sm.get("disabledExtensions") as string[]) ?? []) : [];
-		this.#state = await refreshState(this.#state, this.cwd, disabledIds);
+		const nextState = await refreshState(this.#state, this.cwd, disabledIds);
+		if (refreshToken !== this.#refreshToken) return;
+		this.#state = nextState;
 
 		// Find the same tab in the new (re-sorted) list
 		if (currentTabId) {
@@ -208,6 +221,17 @@ export class ExtensionDashboard extends Container {
 		}
 
 		this.#buildLayout();
+		this.onRequestRender?.();
+	}
+
+	#applyDisabledExtensions(disabledIds: string[]): void {
+		this.#state = applyDisabledExtensionsToState(this.#state, disabledIds);
+		this.#mainList.setExtensions(this.#state.searchFiltered);
+		if (this.#state.selected) {
+			this.#inspector.setExtension(this.#state.selected);
+		}
+		this.#buildLayout();
+		this.onRequestRender?.();
 	}
 
 	#switchTab(direction: 1 | -1): void {

package/src/modes/components/extensions/state-manager.ts

@@ -509,6 +509,47 @@ export function filterByProvider(extensions: Extension[], providerId: string): E
 	return extensions.filter(ext => ext.source.provider === providerId);
 }
 
+function isShadowedExtension(ext: Extension): boolean {
+	if (ext.shadowedBy) return true;
+	return Boolean((ext.raw as { _shadowed?: boolean } | null | undefined)?._shadowed);
+}
+
+/**
+ * Apply setting-backed item disable overrides to an existing dashboard state.
+ * This gives the UI immediate feedback while the full capability refresh runs.
+ */
+export function applyDisabledExtensionsToState(state: DashboardState, disabledIds: string[]): DashboardState {
+	const disabled = new Set(disabledIds);
+	const updateExtension = (ext: Extension): Extension => {
+		if (disabled.has(ext.id)) {
+			if (ext.state === "disabled" && ext.disabledReason === "item-disabled") return ext;
+			return { ...ext, state: "disabled", disabledReason: "item-disabled" };
+		}
+
+		if (ext.state !== "disabled" || ext.disabledReason !== "item-disabled") return ext;
+		if (!isProviderEnabled(ext.source.provider)) {
+			return { ...ext, state: "disabled", disabledReason: "provider-disabled" };
+		}
+
+		if (isShadowedExtension(ext)) {
+			const shadowed: Extension = { ...ext, state: "shadowed", disabledReason: "shadowed" };
+			return shadowed;
+		}
+
+		const enabled: Extension = { ...ext, state: "active" };
+		delete enabled.disabledReason;
+		return enabled;
+	};
+
+	return {
+		...state,
+		extensions: state.extensions.map(updateExtension),
+		tabFiltered: state.tabFiltered.map(updateExtension),
+		searchFiltered: state.searchFiltered.map(updateExtension),
+		selected: state.selected ? updateExtension(state.selected) : null,
+	};
+}
+
 /**
  * Create initial dashboard state.
  */

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

@@ -182,6 +182,9 @@ export class SelectorController {
 				done();
 				this.ctx.ui.requestRender();
 			};
+			dashboard.onRequestRender = () => {
+				this.ctx.ui.requestRender();
+			};
 			return { component: dashboard, focus: dashboard };
 		});
 	}

package/src/modes/interactive-mode.ts

@@ -663,10 +663,23 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	finishPendingSubmission(input: SubmittedUserInput): void {
-		if (this.#pendingSubmittedInput === input) {
+		const wasPendingSubmission = this.#pendingSubmittedInput === input;
+		const pendingSubmissionDispose = this.#pendingSubmissionDispose;
+		if (wasPendingSubmission) {
 			this.#pendingSubmittedInput = undefined;
 			this.#pendingSubmissionDispose = undefined;
 		}
+
+		if (wasPendingSubmission && !this.session.isStreaming && !this.streamingComponent) {
+			this.optimisticUserMessageSignature = undefined;
+			pendingSubmissionDispose?.();
+			this.#pendingWorkingMessage = undefined;
+			if (this.loadingAnimation) {
+				this.loadingAnimation.stop();
+				this.loadingAnimation = undefined;
+				this.statusContainer.clear();
+			}
+		}
 	}
 
 	#computeEditorMaxHeight(): number {
@@ -857,6 +870,14 @@ export class InteractiveMode implements InteractiveModeContext {
 	/** Restore mode state from session entries on resume (e.g. plan mode). */
 	async #restoreModeFromSession(): Promise<void> {
 		const sessionContext = this.sessionManager.buildSessionContext();
+		if (!this.session.settings.get("plan.enabled")) {
+			// Clear stale plan/plan_paused mode so re-enabling the setting
+			// later doesn't unexpectedly restore an old plan session.
+			if (sessionContext.mode === "plan" || sessionContext.mode === "plan_paused") {
+				this.sessionManager.appendModeChange("none");
+			}
+			return;
+		}
 		if (sessionContext.mode === "plan") {
 			const planFilePath = sessionContext.modeData?.planFilePath as string | undefined;
 			await this.#enterPlanMode({ planFilePath });
@@ -1060,7 +1081,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	async #approvePlan(
 		planContent: string,
-		options: { planFilePath: string; finalPlanFilePath: string },
+		options: { planFilePath: string; finalPlanFilePath: string; preserveContext?: boolean },
 	): Promise<void> {
 		await renameApprovedPlanFile({
 			planFilePath: options.planFilePath,
@@ -1070,14 +1091,16 @@ export class InteractiveMode implements InteractiveModeContext {
 		});
 		const previousTools = this.#planModePreviousTools ?? this.session.getActiveToolNames();
 		await this.#exitPlanMode({ silent: true, paused: false });
-		await this.handleClearCommand();
-		// The new session has a fresh local:// root — persist the approved plan there
-		// so `local://<title>.md` resolves correctly in the execution session.
-		const newLocalPath = resolveLocalUrlToPath(options.finalPlanFilePath, {
-			getArtifactsDir: () => this.sessionManager.getArtifactsDir(),
-			getSessionId: () => this.sessionManager.getSessionId(),
-		});
-		await Bun.write(newLocalPath, planContent);
+		if (!options.preserveContext) {
+			await this.handleClearCommand();
+			// The new session has a fresh local:// root — persist the approved plan there
+			// so `local://<title>.md` resolves correctly in the execution session.
+			const newLocalPath = resolveLocalUrlToPath(options.finalPlanFilePath, {
+				getArtifactsDir: () => this.sessionManager.getArtifactsDir(),
+				getSessionId: () => this.sessionManager.getSessionId(),
+			});
+			await Bun.write(newLocalPath, planContent);
+		}
 		if (previousTools.length > 0) {
 			await this.session.setActiveToolsByName(previousTools);
 		}
@@ -1086,6 +1109,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		const planModePrompt = prompt.render(planModeApprovedPrompt, {
 			planContent,
 			finalPlanFilePath: options.finalPlanFilePath,
+			contextPreserved: options.preserveContext === true,
 		});
 		await this.session.prompt(planModePrompt, { synthetic: true });
 	}
@@ -1100,6 +1124,10 @@ export class InteractiveMode implements InteractiveModeContext {
 			await this.#exitPlanMode({ paused: true });
 			return;
 		}
+		if (!this.session.settings.get("plan.enabled")) {
+			this.showWarning("Plan mode is disabled. Enable it in settings (plan.enabled).");
+			return;
+		}
 		await this.#enterPlanMode();
 		if (initialPrompt && this.onInputCallback) {
 			this.onInputCallback(this.startPendingSubmission({ text: initialPrompt }));
@@ -1129,14 +1157,14 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#renderPlanPreview(planContent);
 		const choice = await this.showHookSelector(
 			"Plan mode - next step",
-			["Approve and execute", "Refine plan", "Stay in plan mode"],
+			["Approve and execute", "Approve and keep context", "Refine plan", "Stay in plan mode"],
 			{
 				helpText: this.#getPlanReviewHelpText(),
 				onExternalEditor: () => void this.#openPlanInExternalEditor(planFilePath),
 			},
 		);
 
-		if (choice === "Approve and execute") {
+		if (choice === "Approve and execute" || choice === "Approve and keep context") {
 			const finalPlanFilePath = details.finalPlanFilePath || planFilePath;
 			try {
 				const latestPlanContent = await this.#readPlanFile(planFilePath);
@@ -1144,7 +1172,11 @@ export class InteractiveMode implements InteractiveModeContext {
 					this.showError(`Plan file not found at ${planFilePath}`);
 					return;
 				}
-				await this.#approvePlan(latestPlanContent, { planFilePath, finalPlanFilePath });
+				await this.#approvePlan(latestPlanContent, {
+					planFilePath,
+					finalPlanFilePath,
+					preserveContext: choice === "Approve and keep context",
+				});
 			} catch (error) {
 				this.showError(
 					`Failed to finalize approved plan: ${error instanceof Error ? error.message : String(error)}`,

package/src/prompts/system/plan-mode-active.md

@@ -6,7 +6,7 @@ You **MUST NOT**:
 - Run state-changing commands (git commit, npm install, etc.)
 - Make any system changes
 
-To implement: call `{{exitToolName}}` → user approves → new session starts with full write access to execute the plan.
+To implement: call `{{exitToolName}}` → user approves an execution option → full write access is restored to execute the plan.
 You **MUST NOT** ask the user to exit plan mode for you; you **MUST** call `{{exitToolName}}` yourself.
 </critical>
 
@@ -21,7 +21,11 @@ You **MUST** create a plan at `{{planFilePath}}`.
 You **MUST** use `{{editToolName}}` for incremental updates; use `{{writeToolName}}` only for create/full replace.
 
 <caution>
-Plan execution runs in fresh context (session cleared). You **MUST** make the plan file self-contained: include requirements, decisions, key findings, remaining todos needed to continue without prior session history.
+The approval selector includes:
+- **Approve and execute**: starts execution in fresh context (session cleared).
+- **Approve and keep context**: starts execution in this session, preserving exploration history.
+
+You **MUST** still make the plan file self-contained: include requirements, decisions, key findings, and remaining todos needed to continue without prior session history.
 </caution>
 
 {{#if reentry}}
@@ -100,7 +104,7 @@ You **MUST** ask questions throughout. You **MUST NOT** make large assumptions a
 <critical>
 Your turn ends ONLY by:
 1. Using `{{askToolName}}` to gather information, OR
-2. Calling `{{exitToolName}}` when ready — this triggers user approval, then a new implementation session with full tool access
+2. Calling `{{exitToolName}}` when ready — this triggers user approval, then implementation with full tool access
 
 You **MUST NOT** ask plan approval via text or `{{askToolName}}`; you **MUST** use `{{exitToolName}}`.
 You **MUST** keep going until complete.

package/src/prompts/system/plan-mode-approved.md

@@ -3,6 +3,11 @@ Plan approved. You **MUST** execute it now.
 </critical>
 
 Finalized plan artifact: `{{finalPlanFilePath}}`
+{{#if contextPreserved}}
+Context was preserved for execution. Use the existing conversation history when it is useful, and treat the finalized plan as the source of truth if it conflicts with earlier exploration.
+{{else}}
+Execution may be running in fresh context. Treat the finalized plan as the source of truth.
+{{/if}}
 
 ## Plan
 

package/src/prompts/tools/search-tool-bm25.md

@@ -1,34 +1,34 @@
-Search hidden MCP tool metadata when MCP tool discovery is enabled.
+Search hidden tool metadata to discover and activate tools.
 
-Use this tool to discover MCP tools that are loaded into the session but not exposed to the model by default.
+Use this tool when you need a capability that is not currently available in your active tool set. It searches all discoverable tools — including MCP tools and built-in tools that are hidden to save tokens.
 
 {{#if hasDiscoverableMCPServers}}Discoverable MCP servers in this session: {{#list discoverableMCPServerSummaries join=", "}}{{this}}{{/list}}.{{/if}}
-{{#if discoverableMCPToolCount}}Total discoverable MCP tools loaded: {{discoverableMCPToolCount}}.{{/if}}
+{{#if discoverableMCPToolCount}}Total discoverable tools available: {{discoverableMCPToolCount}}.{{/if}}
 Input:
 - `query` — required natural-language or keyword query
 - `limit` — optional maximum number of tools to return and activate (default `8`)
 
 Behavior:
-- Searches hidden MCP tool metadata using BM25-style relevance ranking
-- Matches against MCP tool name, server name, description, and input schema keys
-- Activates the top matching MCP tools for the rest of the current session
-- Repeated searches add to the active MCP tool set; they do not remove earlier selections
-- Newly activated MCP tools become available before the next model call in the same overall turn
+- Searches hidden tool metadata using BM25-style relevance ranking
+- Matches against tool name, label, server name, description/summary, and input schema keys
+- Activates the top matching tools for the rest of the current session
+- Repeated searches add to the active tool set; they do not remove earlier selections
+- Newly activated tools become available before the next model call in the same overall turn
 
 Notes:
 - If you are unsure, start with `limit` between 5 and 10 to see a broader set of tools.
-- `query` is matched against MCP tool metadata fields:
+- `query` is matched against tool metadata fields:
   - `name`
   - `label`
-  - `server_name`
-  - `mcp_tool_name`
-  - `description`
+  - `server_name` (MCP tools)
+  - `mcp_tool_name` (MCP tools)
+  - `description` / `summary`
   - input schema property keys (`schema_keys`)
 
-This is not repository search, file search, or code search. Use it only for MCP tool discovery.
+This is not repository search, file search, or code search. Use it only for tool discovery.
 
 Returns JSON with:
 - `query`
-- `activated_tools` — MCP tools activated by this search call
+- `activated_tools` — tools activated by this search call
 - `match_count` — number of ranked matches returned by the search
 - `total_tools`

package/src/prompts/tools/todo-write.md

@@ -1,5 +1,6 @@
 Manages a phased task list. Pass `ops`: a flat array of operations.
 The next pending task is auto-promoted to `in_progress` after each completion.
+Allowed `op` values are only `init`, `start`, `done`, `drop`, `rm`, `append`, and `note`. `pending` is a task status, not an `op`; leave not-yet-started tasks implicit in `init`/`append` lists.
 
 ## Operations