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

package/src/tools/index.ts

@@ -10,13 +10,13 @@ import type { Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { InternalUrlRouter } from "../internal-urls";
 import { LspTool } from "../lsp";
-import type { DiscoverableMCPSearchIndex, DiscoverableMCPTool } from "../mcp/discoverable-tool-metadata";
 import type { PlanModeState } from "../plan-mode/state";
 import type { AgentRegistry } from "../registry/agent-registry";
 import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import { TaskTool } from "../task";
 import type { AgentOutputManager } from "../task/output-manager";
+import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { EventBus } from "../utils/event-bus";
 import { WebSearchTool } from "../web/search";
 import { AskTool } from "./ask";
@@ -105,6 +105,12 @@ export type ContextFileEntry = {
 };
 
 export type { DiscoverableMCPTool } from "../mcp/discoverable-tool-metadata";
+export type {
+	DiscoverableTool,
+	DiscoverableToolSearchIndex,
+	DiscoverableToolSearchResult,
+	DiscoverableToolSource,
+} from "../tool-discovery/tool-index";
 
 /** Session context for tool factories */
 export interface ToolSession {
@@ -184,14 +190,29 @@ export interface ToolSession {
 	setTodoPhases?: (phases: TodoPhase[]) => void;
 	/** Whether MCP tool discovery is active for this session. */
 	isMCPDiscoveryEnabled?: () => boolean;
-	/** Get hidden-but-discoverable MCP tools for search_tool_bm25 prompts and fallbacks. */
-	getDiscoverableMCPTools?: () => DiscoverableMCPTool[];
-	/** Get the cached discoverable MCP search index for search_tool_bm25 execution. */
-	getDiscoverableMCPSearchIndex?: () => DiscoverableMCPSearchIndex;
+	/** Get hidden-but-discoverable MCP tools for search_tool_bm25 prompts and fallbacks.
+	 * @deprecated Use getDiscoverableTools with source filter instead. */
+	getDiscoverableMCPTools?: () => import("../mcp/discoverable-tool-metadata").DiscoverableMCPTool[];
+	/** Get the cached discoverable MCP search index for search_tool_bm25 execution.
+	 * @deprecated Use getDiscoverableToolSearchIndex instead. */
+	getDiscoverableMCPSearchIndex?: () => import("../tool-discovery/tool-index").DiscoverableMCPSearchIndex;
 	/** Get MCP tools activated by prior search_tool_bm25 calls. */
 	getSelectedMCPToolNames?: () => string[];
 	/** Merge MCP tool selections into the active session tool set. */
 	activateDiscoveredMCPTools?: (toolNames: string[]) => Promise<string[]>;
+	// ── Generic tool discovery (unified — covers built-in + MCP + extension) ──
+	/** Whether any form of tool discovery is active (tools.discoveryMode !== "off" or mcp.discoveryMode). */
+	isToolDiscoveryEnabled?: () => boolean;
+	/** Get all hidden-but-discoverable tools for search_tool_bm25 prompts. */
+	getDiscoverableTools?: (filter?: {
+		source?: import("../tool-discovery/tool-index").DiscoverableToolSource;
+	}) => DiscoverableTool[];
+	/** Get the cached generic discoverable search index. */
+	getDiscoverableToolSearchIndex?: () => DiscoverableToolSearchIndex;
+	/** Get tool names activated by prior search_tool_bm25 calls (all sources). */
+	getSelectedDiscoveredToolNames?: () => string[];
+	/** Merge tool selections into the active session tool set. */
+	activateDiscoveredTools?: (toolNames: string[]) => Promise<string[]>;
 	/** The tool-choice queue used to force forthcoming tool invocations and carry invocation handlers. */
 	getToolChoiceQueue?(): ToolChoiceQueue;
 	/** Build a model-provider-specific ToolChoice that targets the named tool, or undefined if unsupported. */
@@ -209,25 +230,48 @@ export interface ToolSession {
 	queueDeferredMessage?(message: CustomMessage): void;
 }
 
-type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
+export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 
+export type BuiltinToolLoadMode = "essential" | "discoverable";
+
+/** Default essential tool names when tools.essentialOverride is empty. */
+export const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[] = ["read", "bash", "edit"] as const;
+
+/**
+ * Resolve the active essential built-in tool names from settings.
+ * Returns `tools.essentialOverride` if non-empty (filtered to known built-ins),
+ * otherwise `DEFAULT_ESSENTIAL_TOOL_NAMES`.
+ */
+export function computeEssentialBuiltinNames(settings: Settings): string[] {
+	const override = settings.get("tools.essentialOverride") ?? [];
+	const cleaned = override.map(name => name.trim()).filter(Boolean);
+	if (cleaned.length > 0) {
+		return cleaned.filter(name => name in BUILTIN_TOOLS);
+	}
+	return [...DEFAULT_ESSENTIAL_TOOL_NAMES];
+}
+
+/**
+ * Public callable factory map. External callers may invoke `BUILTIN_TOOLS.read(session)` or
+ * `BUILTIN_TOOLS[name](session)` to construct a tool directly.
+ */
 export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
+	read: s => new ReadTool(s),
+	bash: s => new BashTool(s),
+	edit: s => new EditTool(s),
 	ast_grep: s => new AstGrepTool(s),
 	ast_edit: s => new AstEditTool(s),
 	render_mermaid: s => new RenderMermaidTool(s),
 	ask: AskTool.createIf,
-	bash: s => new BashTool(s),
 	debug: DebugTool.createIf,
 	eval: s => new EvalTool(s),
 	calc: s => new CalculatorTool(s),
 	ssh: loadSshTool,
-	edit: s => new EditTool(s),
 	github: GithubTool.createIf,
 	find: s => new FindTool(s),
 	search: s => new SearchTool(s),
 	lsp: LspTool.createIf,
 	notebook: s => new NotebookTool(s),
-	read: s => new ReadTool(s),
 	inspect_image: s => new InspectImageTool(s),
 	browser: s => new BrowserTool(s),
 	checkpoint: CheckpointTool.createIf,
@@ -299,7 +343,8 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	const enableLsp = session.enableLsp ?? true;
 	const requestedTools =
 		toolNames && toolNames.length > 0 ? [...new Set(toolNames.map(name => name.toLowerCase()))] : undefined;
-	if (requestedTools && !requestedTools.includes("exit_plan_mode")) {
+	const planEnabled = session.settings.get("plan.enabled");
+	if (planEnabled && requestedTools && !requestedTools.includes("exit_plan_mode")) {
 		requestedTools.push("exit_plan_mode");
 	}
 	const backends = resolveEvalBackends(session);
@@ -360,8 +405,20 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 			}
 		}
 	}
+	// Resolve effective tool discovery mode.
+	// tools.discoveryMode takes precedence; mcp.discoveryMode is a back-compat alias for "mcp-only".
+	const toolsDiscoveryMode = session.settings.get("tools.discoveryMode");
+	const effectiveDiscoveryMode: "off" | "mcp-only" | "all" =
+		toolsDiscoveryMode !== "off"
+			? (toolsDiscoveryMode as "off" | "mcp-only" | "all")
+			: session.settings.get("mcp.discoveryMode")
+				? "mcp-only"
+				: "off";
+	const discoveryActive = effectiveDiscoveryMode !== "off";
+
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
 	const isToolAllowed = (name: string) => {
+		if (name === "exit_plan_mode") return planEnabled;
 		if (name === "lsp") return enableLsp && session.settings.get("lsp.enabled");
 		if (name === "bash") return true;
 		if (name === "eval") return allowEval;
@@ -376,7 +433,8 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "notebook") return session.settings.get("notebook.enabled");
 		if (name === "inspect_image") return session.settings.get("inspect_image.enabled");
 		if (name === "web_search") return session.settings.get("web_search.enabled");
-		if (name === "search_tool_bm25") return session.settings.get("mcp.discoveryMode");
+		// search_tool_bm25 is allowed when either legacy mcp.discoveryMode or new tools.discoveryMode is active.
+		if (name === "search_tool_bm25") return discoveryActive;
 		if (name === "calc") return session.settings.get("calc.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
@@ -401,14 +459,16 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		filteredRequestedTools !== undefined
 			? filteredRequestedTools.filter(name => name !== "resolve").map(name => [name, allTools[name]] as const)
 			: [
-					...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name)),
+					...Object.entries(BUILTIN_TOOLS)
+						.filter(([name]) => isToolAllowed(name))
+						.map(([name, factory]) => [name, factory] as const),
 					...(includeYield ? ([["yield", HIDDEN_TOOLS.yield]] as const) : []),
-					...([["exit_plan_mode", HIDDEN_TOOLS.exit_plan_mode]] as const),
+					...(planEnabled ? ([["exit_plan_mode", HIDDEN_TOOLS.exit_plan_mode]] as const) : []),
 				];
 
 	const baseResults = await Promise.all(
 		baseEntries.map(async ([name, factory]) => {
-			const tool = await logger.time(`createTools:${name}`, factory, session);
+			const tool = await logger.time(`createTools:${name}`, factory as ToolFactory, session);
 			return tool ? wrapToolWithMetaNotice(tool) : null;
 		}),
 	);

package/src/tools/inspect-image.ts

@@ -41,6 +41,8 @@ function extractResponseText(message: AssistantMessage): string {
 export class InspectImageTool implements AgentTool<typeof inspectImageSchema, InspectImageToolDetails> {
 	readonly name = "inspect_image";
 	readonly label = "InspectImage";
+	readonly loadMode = "discoverable";
+	readonly summary = "Describe or analyze an image file";
 	readonly description: string;
 	readonly parameters = inspectImageSchema;
 	readonly strict = false;

package/src/tools/irc.ts

@@ -74,10 +74,11 @@ export interface IrcDetails {
 export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 	readonly name = "irc";
 	readonly label = "IRC";
+	readonly summary = "Send and receive messages between agents over IRC-like channels";
 	readonly description: string;
 	readonly parameters = ircSchema;
 	readonly strict = true;
-
+	readonly loadMode = "discoverable";
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(ircDescription);
 	}

package/src/tools/job.ts

@@ -76,10 +76,11 @@ export interface JobToolDetails {
 export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	readonly name = "job";
 	readonly label = "Job";
+	readonly summary = "Manage long-running background jobs (async bash/python)";
 	readonly description: string;
 	readonly parameters = jobSchema;
 	readonly strict = true;
-
+	readonly loadMode = "discoverable";
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(jobDescription);
 	}

package/src/tools/notebook.ts

@@ -64,6 +64,8 @@ type NotebookParams = Static<typeof notebookSchema>;
 export class NotebookTool implements AgentTool<typeof notebookSchema, NotebookToolDetails> {
 	readonly name = "notebook";
 	readonly label = "Notebook";
+	readonly loadMode = "discoverable";
+	readonly summary = "Read and execute Jupyter notebooks";
 	readonly description = "Edit, insert, or delete cells in Jupyter notebooks (.ipynb). cell_index is 0-based.";
 	readonly parameters = notebookSchema;
 	readonly strict = true;

package/src/tools/read.ts

@@ -512,6 +512,7 @@ interface ResolvedSqliteReadPath {
 export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly name = "read";
 	readonly label = "Read";
+	readonly loadMode = "essential";
 	readonly description: string;
 	readonly parameters = readSchema;
 	readonly nonAbortable = true;

package/src/tools/recipe/index.ts

@@ -33,6 +33,8 @@ export class RecipeTool implements AgentTool<typeof recipeSchema, BashToolDetail
 	readonly parameters = recipeSchema;
 	readonly strict = true;
 	readonly concurrency = "exclusive";
+	readonly loadMode = "discoverable";
+	readonly summary = "Execute a saved bash recipe (multi-step shell command preset)";
 	readonly mergeCallAndResult = true;
 	readonly inline = true;
 	readonly renderCall: (args: RecipeRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;

package/src/tools/render-mermaid.ts

@@ -35,9 +35,11 @@ export interface RenderMermaidToolDetails {
 export class RenderMermaidTool implements AgentTool<typeof renderMermaidSchema, RenderMermaidToolDetails> {
 	readonly name = "render_mermaid";
 	readonly label = "RenderMermaid";
+	readonly summary = "Render a Mermaid diagram to an image";
 	readonly description: string;
 	readonly parameters = renderMermaidSchema;
 	readonly strict = true;
+	readonly loadMode = "discoverable";
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(renderMermaidDescription);

package/src/tools/search-tool-bm25.ts

@@ -3,21 +3,27 @@ import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import {
-	buildDiscoverableMCPSearchIndex,
-	type DiscoverableMCPSearchIndex,
-	type DiscoverableMCPTool,
-	formatDiscoverableMCPToolServerSummary,
-	searchDiscoverableMCPTools,
-	summarizeDiscoverableMCPTools,
-} from "../mcp/discoverable-tool-metadata";
 import type { Theme } from "../modes/theme/theme";
 import searchToolBm25Description from "../prompts/tools/search-tool-bm25.md" with { type: "text" };
+import {
+	buildDiscoverableToolSearchIndex,
+	type DiscoverableTool,
+	type DiscoverableToolSearchIndex,
+	formatDiscoverableToolServerSummary,
+	searchDiscoverableTools,
+	summarizeDiscoverableTools,
+} from "../tool-discovery/tool-index";
 import { renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
 import { formatCount, replaceTabs, TRUNCATE_LENGTHS } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
+// Re-export legacy MCP types for back-compat (tests and external callers may reference them)
+export type {
+	DiscoverableMCPSearchIndex,
+	DiscoverableMCPTool,
+} from "../mcp/discoverable-tool-metadata";
+
 const DEFAULT_LIMIT = 8;
 const TOOL_DISCOVERY_TITLE = "Tool Discovery";
 const COLLAPSED_MATCH_LIMIT = 5;
@@ -25,7 +31,10 @@ const MATCH_LABEL_LEN = 72;
 const MATCH_DESCRIPTION_LEN = 96;
 
 const searchToolBm25Schema = Type.Object({
-	query: Type.String({ description: "mcp search query", examples: ["kubernetes pod", "image processing"] }),
+	query: Type.String({
+		description: "tool search query",
+		examples: ["kubernetes pod", "image processing", "git commit"],
+	}),
 	limit: Type.Optional(Type.Integer({ description: "max matches", minimum: 1 })),
 });
 
@@ -50,11 +59,11 @@ export interface SearchToolBm25Details {
 	tools: SearchToolBm25Match[];
 }
 
-function formatMatch(tool: DiscoverableMCPTool, score: number): SearchToolBm25Match {
+function formatMatch(tool: DiscoverableTool, score: number): SearchToolBm25Match {
 	return {
 		name: tool.name,
 		label: tool.label,
-		description: tool.description,
+		description: tool.summary,
 		server_name: tool.serverName,
 		mcp_tool_name: tool.mcpToolName,
 		schema_keys: tool.schemaKeys,
@@ -71,41 +80,99 @@ function buildSearchToolBm25Content(details: SearchToolBm25Details): string {
 	});
 }
 
-function getDiscoverableMCPToolsForDescription(session: ToolSession): DiscoverableMCPTool[] {
+/** Get discoverable tools for description rendering. Falls back to empty array on error. */
+function getDiscoverableToolsForDescription(session: ToolSession): DiscoverableTool[] {
 	try {
-		return session.getDiscoverableMCPTools?.() ?? [];
+		// Prefer generic method; fall back to legacy MCP-only
+		if (session.getDiscoverableTools) {
+			return session.getDiscoverableTools();
+		}
+		// Legacy MCP path — adapt DiscoverableMCPTool (with `description`) → DiscoverableTool.
+		const legacy = session.getDiscoverableMCPTools?.() ?? [];
+		return legacy.map(t => ({
+			name: t.name,
+			label: t.label,
+			summary: t.description,
+			source: "mcp" as const,
+			serverName: t.serverName,
+			mcpToolName: t.mcpToolName,
+			schemaKeys: t.schemaKeys,
+		}));
 	} catch {
 		return [];
 	}
 }
 
-function getDiscoverableMCPSearchIndexForExecution(session: ToolSession): DiscoverableMCPSearchIndex {
+function getDiscoverableToolSearchIndexForExecution(session: ToolSession): DiscoverableToolSearchIndex {
 	try {
-		const cached = session.getDiscoverableMCPSearchIndex?.();
-		if (cached) return cached;
+		// Prefer generic cached index
+		if (session.getDiscoverableToolSearchIndex) {
+			const cached = session.getDiscoverableToolSearchIndex();
+			if (cached) return cached;
+		}
+		// Legacy MCP: use cached MCP index. Its documents expose `tool.description` as well as
+		// `tool.summary`, so it is structurally compatible with DiscoverableToolSearchIndex.
+		const mcpCached = session.getDiscoverableMCPSearchIndex?.();
+		if (mcpCached) return mcpCached as unknown as DiscoverableToolSearchIndex;
 	} catch {}
-	return buildDiscoverableMCPSearchIndex(session.getDiscoverableMCPTools?.() ?? []);
+	return buildDiscoverableToolSearchIndex(getDiscoverableToolsForDescription(session));
+}
+
+/** Resolve the effective selected tool names (generic or legacy MCP). */
+function getSelectedToolNames(session: ToolSession): string[] {
+	if (session.getSelectedDiscoveredToolNames) {
+		return session.getSelectedDiscoveredToolNames();
+	}
+	return session.getSelectedMCPToolNames?.() ?? [];
 }
 
-type MCPDiscoveryExecutionSession = ToolSession & {
-	isMCPDiscoveryEnabled: () => boolean;
-	getSelectedMCPToolNames: () => string[];
-	activateDiscoveredMCPTools: (toolNames: string[]) => Promise<string[]>;
+/** Activate tools (generic or legacy MCP fallback). */
+async function activateTools(session: ToolSession, toolNames: string[]): Promise<string[]> {
+	if (session.activateDiscoveredTools) {
+		return session.activateDiscoveredTools(toolNames);
+	}
+	if (session.activateDiscoveredMCPTools) {
+		return session.activateDiscoveredMCPTools(toolNames);
+	}
+	return [];
+}
+
+type DiscoveryExecutionSession = ToolSession & {
+	_supportsDiscoveryExecution: true;
 };
 
-function supportsMCPToolDiscoveryExecution(session: ToolSession): session is MCPDiscoveryExecutionSession {
-	return (
+function supportsToolDiscoveryExecution(session: ToolSession): session is DiscoveryExecutionSession {
+	// Supports generic discovery
+	if (
+		typeof session.isToolDiscoveryEnabled === "function" &&
+		typeof session.getSelectedDiscoveredToolNames === "function" &&
+		typeof session.activateDiscoveredTools === "function"
+	) {
+		return true;
+	}
+	// Supports legacy MCP discovery
+	if (
 		typeof session.isMCPDiscoveryEnabled === "function" &&
 		typeof session.getSelectedMCPToolNames === "function" &&
 		typeof session.activateDiscoveredMCPTools === "function"
-	);
+	) {
+		return true;
+	}
+	return false;
+}
+
+function isDiscoveryEnabled(session: ToolSession): boolean {
+	if (typeof session.isToolDiscoveryEnabled === "function") {
+		return session.isToolDiscoveryEnabled();
+	}
+	return session.isMCPDiscoveryEnabled?.() ?? false;
 }
 
-export function renderSearchToolBm25Description(discoverableTools: DiscoverableMCPTool[] = []): string {
-	const summary = summarizeDiscoverableMCPTools(discoverableTools);
+export function renderSearchToolBm25Description(discoverableTools: DiscoverableTool[] = []): string {
+	const summary = summarizeDiscoverableTools(discoverableTools);
 	return prompt.render(searchToolBm25Description, {
 		discoverableMCPToolCount: summary.toolCount,
-		discoverableMCPServerSummaries: summary.servers.map(formatDiscoverableMCPToolServerSummary),
+		discoverableMCPServerSummaries: summary.servers.map(formatDiscoverableToolServerSummary),
 		hasDiscoverableMCPServers: summary.servers.length > 0,
 	});
 }
@@ -134,11 +201,18 @@ function renderFallbackResult(text: string, theme: Theme): Component {
 	return new Text([header, ...bodyLines].join("\n"), 0, 0);
 }
 
+/**
+ * SearchToolsTool — wire name `search_tool_bm25` (preserved for persisted session back-compat).
+ *
+ * When tools.discoveryMode === "all", this covers both MCP tools and built-in discoverable tools.
+ * When tools.discoveryMode === "mcp-only" or mcp.discoveryMode === true, only MCP tools are searched.
+ */
 export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema, SearchToolBm25Details> {
 	readonly name = "search_tool_bm25";
-	readonly label = "SearchToolBm25";
+	readonly label = "SearchTools";
+	readonly loadMode = "essential";
 	get description(): string {
-		return renderSearchToolBm25Description(getDiscoverableMCPToolsForDescription(this.session));
+		return renderSearchToolBm25Description(getDiscoverableToolsForDescription(this.session));
 	}
 	readonly parameters = searchToolBm25Schema;
 	readonly strict = true;
@@ -146,8 +220,13 @@ export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema
 	constructor(private readonly session: ToolSession) {}
 
 	static createIf(session: ToolSession): SearchToolBm25Tool | null {
-		if (!session.settings.get("mcp.discoveryMode")) return null;
-		return supportsMCPToolDiscoveryExecution(session) ? new SearchToolBm25Tool(session) : null;
+		// Active when new tools.discoveryMode is non-"off" or legacy mcp.discoveryMode is true
+		const toolsDiscoveryMode = session.settings.get("tools.discoveryMode");
+		const active =
+			(toolsDiscoveryMode !== undefined && toolsDiscoveryMode !== "off") ||
+			session.settings.get("mcp.discoveryMode") === true;
+		if (!active) return null;
+		return supportsToolDiscoveryExecution(session) ? new SearchToolBm25Tool(session) : null;
 	}
 
 	async execute(
@@ -157,11 +236,13 @@ export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema
 		_onUpdate?: AgentToolUpdateCallback<SearchToolBm25Details>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<SearchToolBm25Details>> {
-		if (!supportsMCPToolDiscoveryExecution(this.session)) {
-			throw new ToolError("MCP tool discovery is unavailable in this session.");
+		if (!supportsToolDiscoveryExecution(this.session)) {
+			throw new ToolError("Tool discovery is unavailable in this session.");
 		}
-		if (!this.session.isMCPDiscoveryEnabled()) {
-			throw new ToolError("MCP tool discovery is disabled. Enable mcp.discoveryMode to use search_tool_bm25.");
+		if (!isDiscoveryEnabled(this.session)) {
+			throw new ToolError(
+				"Tool discovery is disabled. Enable tools.discoveryMode or mcp.discoveryMode to use search_tool_bm25.",
+			);
 		}
 
 		const query = params.query.trim();
@@ -173,11 +254,11 @@ export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema
 			throw new ToolError("Limit must be a positive integer.");
 		}
 
-		const searchIndex = getDiscoverableMCPSearchIndexForExecution(this.session);
-		const selectedToolNames = new Set(this.session.getSelectedMCPToolNames());
-		let ranked: Array<{ tool: DiscoverableMCPTool; score: number }> = [];
+		const searchIndex = getDiscoverableToolSearchIndexForExecution(this.session);
+		const selectedToolNames = new Set(getSelectedToolNames(this.session));
+		let ranked: Array<{ tool: DiscoverableTool; score: number }> = [];
 		try {
-			ranked = searchDiscoverableMCPTools(searchIndex, query, searchIndex.documents.length)
+			ranked = searchDiscoverableTools(searchIndex, query, searchIndex.documents.length)
 				.filter(result => !selectedToolNames.has(result.tool.name))
 				.slice(0, limit);
 		} catch (error) {
@@ -187,14 +268,19 @@ export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema
 			throw error;
 		}
 		const activated =
-			ranked.length > 0 ? await this.session.activateDiscoveredMCPTools(ranked.map(result => result.tool.name)) : [];
+			ranked.length > 0
+				? await activateTools(
+						this.session,
+						ranked.map(result => result.tool.name),
+					)
+				: [];
 
 		const details: SearchToolBm25Details = {
 			query,
 			limit,
 			total_tools: searchIndex.documents.length,
 			activated_tools: activated,
-			active_selected_tools: this.session.getSelectedMCPToolNames(),
+			active_selected_tools: getSelectedToolNames(this.session),
 			tools: ranked.map(result => formatMatch(result.tool, result.score)),
 		};
 
@@ -252,7 +338,7 @@ export const searchToolBm25Renderer = {
 		);
 		if (details.tools.length === 0) {
 			const emptyMessage =
-				details.total_tools === 0 ? "No discoverable MCP tools are currently loaded." : "No matching tools found.";
+				details.total_tools === 0 ? "No discoverable tools are currently loaded." : "No matching tools found.";
 			return new Text(`${header}\n${uiTheme.fg("muted", emptyMessage)}`, 0, 0);
 		}
 

package/src/tools/search.ts

@@ -80,6 +80,8 @@ type SearchParams = Static<typeof searchSchema>;
 export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
 	readonly name = "search";
 	readonly label = "Search";
+	readonly loadMode = "discoverable";
+	readonly summary = "Search file contents using ripgrep (fast text search)";
 	readonly description: string;
 	readonly parameters = searchSchema;
 	readonly strict = true;

package/src/tools/ssh.ts

@@ -120,6 +120,8 @@ type SshToolParams = Static<typeof sshSchema>;
 
 export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 	readonly name = "ssh";
+	readonly summary = "Execute a command on a remote host over SSH";
+	readonly loadMode = "discoverable";
 	readonly label = "SSH";
 	readonly parameters = sshSchema;
 	readonly concurrency = "exclusive";

package/src/tools/todo-write.ts

@@ -503,11 +503,12 @@ function formatSummary(phases: TodoPhase[], errors: string[]): string {
 export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWriteToolDetails> {
 	readonly name = "todo_write";
 	readonly label = "Todo Write";
+	readonly summary = "Write a structured todo list to track progress within a session";
 	readonly description: string;
 	readonly parameters = todoWriteSchema;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
-
+	readonly loadMode = "discoverable";
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(todoWriteDescription);
 	}

package/src/tools/write.ts

@@ -166,6 +166,8 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	readonly nonAbortable = true;
 	readonly strict = true;
 	readonly concurrency = "exclusive";
+	readonly loadMode = "discoverable";
+	readonly summary = "Write content to a file (creates or overwrites)";
 
 	readonly #writethrough: WritethroughCallback;
 

package/src/web/search/index.ts

@@ -211,6 +211,8 @@ export class WebSearchTool implements AgentTool<typeof webSearchSchema, SearchRe
 	readonly description: string;
 	readonly parameters = webSearchSchema;
 	readonly strict = true;
+	readonly loadMode = "discoverable";
+	readonly summary = "Search the web for up-to-date information";
 
 	constructor(_session: ToolSession) {
 		this.description = prompt.render(webSearchDescription);

package/src/web/search/providers/searxng.ts

@@ -119,6 +119,11 @@ function buildBasicAuthValue(username: string, password: string): string {
 	return Buffer.from(`${username}:${password}`, "utf-8").toString("base64");
 }
 
+/** RFC 7617 forbids C0 and C1 control characters in Basic auth credentials. */
+function hasControlCharacters(value: string): boolean {
+	return /[\u0000-\u001F\u007F-\u009F]/u.test(value);
+}
+
 /** Find SearXNG authentication from settings or environment. Basic auth takes precedence over bearer tokens. */
 function findAuth(): SearXNGAuth | null {
 	const basicUsername = findBasicUsername();
@@ -132,6 +137,9 @@ function findAuth(): SearXNGAuth | null {
 		if (basicUsername.includes(":")) {
 			throw new Error("SearXNG Basic auth username cannot contain ':' because RFC 7617 uses it as the separator.");
 		}
+		if (hasControlCharacters(basicUsername) || hasControlCharacters(basicPassword)) {
+			throw new Error("SearXNG Basic auth credentials must not contain RFC 7617 control characters.");
+		}
 		return { type: "basic", value: buildBasicAuthValue(basicUsername, basicPassword) };
 	}