@oh-my-pi/pi-coding-agent 13.12.6 → 13.12.8

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## [Unreleased]
 
+## [13.12.8] - 2026-03-16
+
+### Breaking Changes
+
+- Changed `SessionManager.create()` to require explicit `sessionDir` parameter instead of optional—callers must now pass `SessionManager.getDefaultSessionDir(cwd)` to use default behavior
+- Changed `SessionManager.continueRecent()` to require explicit `sessionDir` parameter instead of optional—callers must now pass `SessionManager.getDefaultSessionDir(cwd)` to use default behavior
+- Changed `SessionManager.forkFrom()` to require explicit `sessionDir` parameter instead of optional—callers must now pass `SessionManager.getDefaultSessionDir(cwd)` to use default behavior
+- Changed `SessionManager.list()` signature to accept only `sessionDir` parameter instead of `cwd` and optional `sessionDir`—callers must now compute and pass the session directory explicitly
+
+### Added
+
+- Added `SessionManager.getDefaultSessionDir()` static method to explicitly resolve the canonical default session directory for a working directory
+- Added support for quoted paths in grep, ast_grep, and find tools to handle directory names with spaces
+- Added `normalizePathLikeInput` utility function to consistently handle quoted and whitespace-trimmed path inputs
+
+### Changed
+
+- Made `sessionDir` parameter optional in `SessionManager.create()`, `SessionManager.continueRecent()`, and `SessionManager.forkFrom()`—callers can now omit it to use the default session directory
+- Changed `SessionManager.list()` signature to accept `cwd` as the first parameter instead of requiring an explicit `sessionDir`—callers can now omit `sessionDir` to use the default for the given working directory
+- Updated `SessionManager.getDefaultSessionDir()` to accept optional `agentDir` parameter for computing session directories within a custom agent root
+- Improved status line path display to strip display roots using canonical path resolution, correctly handling symlink aliases to home and Projects directories
+- Improved error messaging in ast_grep when no matches are found with parse errors, now suggests narrowing `path`/`glob` or setting `lang` to resolve mis-scoped queries
+
+### Fixed
+
+- Fixed SDK-created default sessions to honor the configured `agentDir` for session storage, preventing tests from writing stray session directories into the real `~/.omp/agent/sessions` root
+- Fixed session directory resolution to correctly handle symlink-equivalent paths, ensuring aliased home and temp directories resolve to the same session storage location as their real targets
+
+## [13.12.7] - 2026-03-16
+### Changed
+
+- Modified `getSelectedMCPToolNames()` to return only active MCP tools in non-discovery sessions, filtering by tool registry availability
+- Updated `search_tool_bm25` tool instantiation to conditionally create the tool only when MCP discovery mode is enabled and execution hooks are available
+- Changed search results to exclude already-selected MCP tools before applying the limit parameter, allowing discovery of additional tools in subsequent searches
+
+### Fixed
+
+- Fixed MCP tool selection tracking to properly distinguish between discovery-enabled and non-discovery sessions, preventing orphaned tool selections after manual deactivation
+
 ## [13.12.6] - 2026-03-15
 ### Changed
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.12.6",
+	"version": "13.12.8",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.12.6",
-		"@oh-my-pi/pi-agent-core": "13.12.6",
-		"@oh-my-pi/pi-ai": "13.12.6",
-		"@oh-my-pi/pi-natives": "13.12.6",
-		"@oh-my-pi/pi-tui": "13.12.6",
-		"@oh-my-pi/pi-utils": "13.12.6",
+		"@oh-my-pi/omp-stats": "13.12.8",
+		"@oh-my-pi/pi-agent-core": "13.12.8",
+		"@oh-my-pi/pi-ai": "13.12.8",
+		"@oh-my-pi/pi-natives": "13.12.8",
+		"@oh-my-pi/pi-tui": "13.12.8",
+		"@oh-my-pi/pi-utils": "13.12.8",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/config/keybindings.ts

@@ -264,10 +264,7 @@ export class KeybindingsManager {
 	 * Get display string for an action.
 	 */
 	getDisplayString(action: AppAction): string {
-		const keys = this.getKeys(action);
-		if (keys.length === 0) return "";
-		if (keys.length === 1) return keys[0]!;
-		return keys.join("/");
+		return formatKeyHints(this.getKeys(action));
 	}
 
 	/**

package/src/config/settings-schema.ts

@@ -1188,6 +1188,16 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "tools", label: "MCP Project Config", description: "Load .mcp.json/mcp.json from project root" },
 	},
 
+	"mcp.discoveryMode": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "MCP Tool Discovery",
+			description: "Hide MCP tools by default and expose them through a tool discovery tool",
+		},
+	},
+
 	"mcp.notifications": {
 		type: "boolean",
 		default: false,
@@ -1463,9 +1473,6 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "providers", label: "Exa Websets", description: "Webset management and enrichment tools" },
 	},
 
-	// ────────────────────────────────────────────────────────────────────────
-	// Advanced settings (no UI)
-	// ────────────────────────────────────────────────────────────────────────
 	"commit.mapReduceEnabled": { type: "boolean", default: true },
 
 	"commit.mapReduceMinFiles": { type: "number", default: 4 },

package/src/discovery/claude.ts

@@ -89,6 +89,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 			const serverConfig = config as Record<string, unknown>;
 			return {
 				name,
+				timeout: typeof serverConfig.timeout === "number" ? serverConfig.timeout : undefined,
 				command: serverConfig.command as string | undefined,
 				args: serverConfig.args as string[] | undefined,
 				env: serverConfig.env as Record<string, string> | undefined,

package/src/discovery/codex.ts

@@ -197,6 +197,10 @@ function extractMCPServersFromToml(toml: Record<string, unknown>): Record<string
 		}
 		// Note: validation of transport vs endpoint is handled by mcpCapability.validate()
 
+		// Map Codex tool_timeout_sec (seconds) to MCPServer timeout (milliseconds)
+		if (typeof config.tool_timeout_sec === "number" && config.tool_timeout_sec > 0) {
+			server.timeout = config.tool_timeout_sec * 1000;
+		}
 		result[name] = server;
 	}
 

package/src/discovery/cursor.ts

@@ -65,6 +65,7 @@ function parseMCPServers(
 			transport: ["stdio", "sse", "http"].includes(serverConfig.type as string)
 				? (serverConfig.type as "stdio" | "sse" | "http")
 				: undefined,
+			timeout: typeof serverConfig.timeout === "number" ? serverConfig.timeout : undefined,
 			_source: createSourceMeta(PROVIDER_ID, path, level),
 		});
 	}

package/src/discovery/gemini.ts

@@ -110,6 +110,7 @@ async function loadMCPFromSettings(
 			transport: ["stdio", "sse", "http"].includes(raw.type as string)
 				? (raw.type as "stdio" | "sse" | "http")
 				: undefined,
+			timeout: typeof raw.timeout === "number" ? raw.timeout : undefined,
 			_source: createSourceMeta(PROVIDER_ID, path, level),
 		} as MCPServer);
 	}

package/src/discovery/vscode.ts

@@ -94,6 +94,7 @@ async function loadMCPConfig(
 			transport: ["stdio", "sse", "http"].includes(expanded.transport as string)
 				? (expanded.transport as "stdio" | "sse" | "http")
 				: undefined,
+			timeout: typeof expanded.timeout === "number" ? expanded.timeout : undefined,
 			_source: createSourceMeta(PROVIDER_ID, path, level),
 		};
 

package/src/discovery/windsurf.ts

@@ -54,6 +54,7 @@ function parseServerConfig(
 			url: server.url as string | undefined,
 			headers: server.headers as Record<string, string> | undefined,
 			transport: server.type as "stdio" | "sse" | "http" | undefined,
+			timeout: typeof server.timeout === "number" ? server.timeout : undefined,
 			_source: createSourceMeta(PROVIDER_ID, path, scope),
 		},
 	};

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

@@ -0,0 +1,192 @@
+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 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);
+}

package/src/modes/components/status-line/segments.ts

@@ -1,7 +1,8 @@
 import * as os from "node:os";
+import * as path from "node:path";
 import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { TERMINAL } from "@oh-my-pi/pi-tui";
-import { formatDuration, formatNumber, getProjectDir } from "@oh-my-pi/pi-utils";
+import { formatDuration, formatNumber, getProjectDir, relativePathWithinRoot } from "@oh-my-pi/pi-utils";
 import { theme } from "../../../modes/theme/theme";
 import { shortenPath } from "../../../tools/render-utils";
 import { getContextUsageLevel, getContextUsageThemeColor } from "./context-thresholds";
@@ -17,6 +18,14 @@ function withIcon(icon: string, text: string): string {
 	return icon ? `${icon} ${text}` : text;
 }
 
+function stripDisplayRoot(pwd: string): string {
+	for (const root of ["/work", path.join(os.homedir(), "Projects")]) {
+		const relative = relativePathWithinRoot(root, pwd);
+		if (relative) return relative;
+	}
+	return pwd;
+}
+
 function normalizePremiumRequests(value: number): number {
 	return Math.round((value + Number.EPSILON) * 100) / 100;
 }
@@ -87,13 +96,12 @@ const pathSegment: StatusLineSegment = {
 
 		let pwd = getProjectDir();
 
+		if (opts.stripWorkPrefix !== false) {
+			pwd = stripDisplayRoot(pwd);
+		}
 		if (opts.abbreviate !== false) {
 			pwd = shortenPath(pwd);
 		}
-		if (opts.stripWorkPrefix !== false) {
-			if (pwd.startsWith("/work/")) pwd = pwd.slice(6);
-			else if (pwd.startsWith("~/Projects/")) pwd = pwd.slice(11);
-		}
 
 		const maxLen = opts.maxLength ?? 40;
 		if (pwd.length > maxLen) {

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

@@ -24,6 +24,7 @@ import { DynamicBorder } from "../../modes/components/dynamic-border";
 import { PythonExecutionComponent } from "../../modes/components/python-execution";
 import { getMarkdownTheme, getSymbolTheme, theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
+import { buildHotkeysMarkdown } from "../../modes/utils/hotkeys-markdown";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
 import { outputMeta } from "../../tools/output-meta";
@@ -509,52 +510,13 @@ export class CommandController {
 		const sttKey = this.ctx.keybindings.getDisplayString("toggleSTT") || "Alt+H";
 		const copyLineKey = this.ctx.keybindings.getDisplayString("copyLine") || "Alt+Shift+L";
 		const copyPromptKey = this.ctx.keybindings.getDisplayString("copyPrompt") || "Alt+Shift+C";
-		const hotkeys = `
-		**Navigation**
-		| Key | Action |
-		|-----|--------|
-		| \`Arrow keys\` | Move cursor / browse history (Up when empty) |
-		| \`Option+Left/Right\` | Move by word |
-		| \`Ctrl+A\` / \`Home\` / \`Cmd+Left\` | Start of line |
-		| \`Ctrl+E\` / \`End\` / \`Cmd+Right\` | End of line |
-		
-		**Editing**
-		| Key | Action |
-		|-----|--------|
-		| \`Enter\` | Send message |
-		| \`Shift+Enter\` / \`Alt+Enter\` | New line |
-		| \`Ctrl+W\` / \`Option+Backspace\` | Delete word backwards |
-		| \`Ctrl+U\` | Delete to start of line |
-		| \`Ctrl+K\` | Delete to end of line |
-		| \`${copyLineKey}\` | Copy current line |
-		| \`${copyPromptKey}\` | Copy whole prompt |
-		
-		**Other**
-		| Key | Action |
-		|-----|--------|
-		| \`Tab\` | Path completion / accept autocomplete |
-		| \`Escape\` | Cancel autocomplete / abort streaming |
-		| \`Ctrl+C\` | Clear editor (first) / exit (second) |
-		| \`Ctrl+D\` | Exit (when editor is empty) |
-		| \`Ctrl+Z\` | Suspend to background |
-		| \`Shift+Tab\` | Cycle thinking level |
-		| \`Ctrl+P\` | Cycle role models (slow/default/smol) |
-		| \`Shift+Ctrl+P\` | Cycle role models (temporary) |
-		| \`Alt+P\` | Select model (temporary) |
-		| \`Ctrl+L\` | Select model (set roles) |
-		| \`${planModeKey}\` | Toggle plan mode |
-		| \`Ctrl+R\` | Search prompt history |
-		| \`${expandToolsKey}\` | Toggle tool output expansion |
-		| \`Ctrl+T\` | Toggle todo list expansion |
-		| \`Ctrl+G\` | Edit message in external editor |
-		| \`${sttKey}\` | Toggle speech-to-text recording |
-		| \`#\` | Open prompt actions |
-		| \`/\` | Slash commands |
-		| \`!\` | Run bash command |
-		| \`!!\` | Run bash command (excluded from context) |
-		| \`$\` | Run Python in shared kernel |
-		| \`$$\` | Run Python (excluded from context) |
-		`;
+		const hotkeys = buildHotkeysMarkdown({
+			expandToolsKey,
+			planModeKey,
+			sttKey,
+			copyLineKey,
+			copyPromptKey,
+		});
 		this.ctx.chatContainer.addChild(new Spacer(1));
 		this.ctx.chatContainer.addChild(new DynamicBorder());
 		this.ctx.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Keyboard Shortcuts")), 1, 0));

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

@@ -535,6 +535,7 @@ export class InputController {
 			keybindings: this.ctx.keybindings,
 			copyCurrentLine: () => this.handleCopyCurrentLine(),
 			copyPrompt: () => this.handleCopyPrompt(),
+			undo: prefix => this.ctx.editor.undoPastTransientText(prefix),
 			moveCursorToMessageEnd: () => this.ctx.editor.moveToMessageEnd(),
 			moveCursorToMessageStart: () => this.ctx.editor.moveToMessageStart(),
 			moveCursorToLineStart: () => this.ctx.editor.moveToLineStart(),

package/src/modes/prompt-action-autocomplete.ts

@@ -12,12 +12,12 @@ interface PromptActionDefinition {
 	label: string;
 	description: string;
 	keywords: string[];
-	execute: () => void;
+	execute: (prefix: string) => void;
 }
 
 interface PromptActionAutocompleteItem extends AutocompleteItem {
 	actionId: string;
-	execute: () => void;
+	execute: (prefix: string) => void;
 }
 
 interface PromptActionAutocompleteOptions {
@@ -26,6 +26,7 @@ interface PromptActionAutocompleteOptions {
 	keybindings: KeybindingsManager;
 	copyCurrentLine: () => void;
 	copyPrompt: () => void;
+	undo: (prefix: string) => void;
 	moveCursorToMessageEnd: () => void;
 	moveCursorToMessageStart: () => void;
 	moveCursorToLineStart: () => void;
@@ -141,6 +142,14 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 		onApplied?: () => void;
 	} {
 		if (prefix.startsWith("#") && isPromptActionItem(item)) {
+			if (item.actionId === "undo") {
+				return {
+					lines,
+					cursorLine,
+					cursorCol,
+					onApplied: () => item.execute(prefix),
+				};
+			}
 			const currentLine = lines[cursorLine] || "";
 			const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
 			const afterCursor = currentLine.slice(cursorCol);
@@ -150,7 +159,7 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 				lines: newLines,
 				cursorLine,
 				cursorCol: beforePrefix.length,
-				onApplied: item.execute,
+				onApplied: () => item.execute(prefix),
 			};
 		}
 
@@ -181,6 +190,13 @@ export function createPromptActionAutocompleteProvider(
 			keywords: ["copy", "prompt", "clipboard", "message"],
 			execute: options.copyPrompt,
 		},
+		{
+			id: "undo",
+			label: "Undo",
+			description: formatKeyHints(editorKeybindings.getKeys("undo")),
+			keywords: ["undo", "revert", "edit", "history"],
+			execute: options.undo,
+		},
 		{
 			id: "cursor-message-end",
 			label: "Move cursor to end of message",

package/src/modes/utils/hotkeys-markdown.ts

@@ -0,0 +1,57 @@
+export interface HotkeysMarkdownBindings {
+	expandToolsKey: string;
+	planModeKey: string;
+	sttKey: string;
+	copyLineKey: string;
+	copyPromptKey: string;
+}
+
+export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string {
+	const { expandToolsKey, planModeKey, sttKey, copyLineKey, copyPromptKey } = bindings;
+	return [
+		"**Navigation**",
+		"| Key | Action |",
+		"|-----|--------|",
+		"| `Arrow keys` | Move cursor / browse history (Up when empty) |",
+		"| `Option+Left/Right` | Move by word |",
+		"| `Ctrl+A` / `Home` / `Cmd+Left` | Start of line |",
+		"| `Ctrl+E` / `End` / `Cmd+Right` | End of line |",
+		"",
+		"**Editing**",
+		"| Key | Action |",
+		"|-----|--------|",
+		"| `Enter` | Send message |",
+		"| `Shift+Enter` / `Alt+Enter` | New line |",
+		"| `Ctrl+W` / `Option+Backspace` | Delete word backwards |",
+		"| `Ctrl+U` | Delete to start of line |",
+		"| `Ctrl+K` | Delete to end of line |",
+		`| \`${copyLineKey}\` | Copy current line |`,
+		`| \`${copyPromptKey}\` | Copy whole prompt |`,
+		"",
+		"**Other**",
+		"| Key | Action |",
+		"|-----|--------|",
+		"| `Tab` | Path completion / accept autocomplete |",
+		"| `Escape` | Cancel autocomplete / abort streaming |",
+		"| `Ctrl+C` | Clear editor (first) / exit (second) |",
+		"| `Ctrl+D` | Exit (when editor is empty) |",
+		"| `Ctrl+Z` | Suspend to background |",
+		"| `Shift+Tab` | Cycle thinking level |",
+		"| `Ctrl+P` | Cycle role models (slow/default/smol) |",
+		"| `Shift+Ctrl+P` | Cycle role models (temporary) |",
+		"| `Alt+P` | Select model (temporary) |",
+		"| `Ctrl+L` | Select model (set roles) |",
+		`| \`${planModeKey}\` | Toggle plan mode |`,
+		"| `Ctrl+R` | Search prompt history |",
+		`| \`${expandToolsKey}\` | Toggle tool output expansion |`,
+		"| `Ctrl+T` | Toggle todo list expansion |",
+		"| `Ctrl+G` | Edit message in external editor |",
+		`| \`${sttKey}\` | Toggle speech-to-text recording |`,
+		"| `#` | Open prompt actions |",
+		"| `/` | Slash commands |",
+		"| `!` | Run bash command |",
+		"| `!!` | Run bash command (excluded from context) |",
+		"| `$` | Run Python in shared kernel |",
+		"| `$$` | Run Python (excluded from context) |",
+	].join("\n");
+}

package/src/prompts/system/system-prompt.md

@@ -155,6 +155,13 @@ You **MUST** use the following tools, as effectively as possible, to complete th
 {{/each}}
 {{/if}}
 
+{{#if mcpDiscoveryMode}}
+### MCP tool discovery
+
+Some MCP tools are intentionally hidden from the initial tool list.
+{{#if hasMCPDiscoveryServers}}Discoverable MCP servers in this session: {{#list mcpDiscoveryServerSummaries join=", "}}{{this}}{{/list}}.{{/if}}
+If the task may involve external systems, SaaS APIs, chat, tickets, databases, deployments, or other non-local integrations, you **SHOULD** call `search_tool_bm25` before concluding no such tool exists.
+{{/if}}
 ## Precedence
 {{#ifAny (includes tools "python") (includes tools "bash")}}
 Pick the right tool for the job:

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

@@ -0,0 +1,34 @@
+Search hidden MCP tool metadata when MCP tool discovery is enabled.
+
+Use this tool to discover MCP tools that are loaded into the session but not exposed to the model by default.
+
+{{#if hasDiscoverableMCPServers}}Discoverable MCP servers in this session: {{#list discoverableMCPServerSummaries join=", "}}{{this}}{{/list}}.{{/if}}
+{{#if discoverableMCPToolCount}}Total discoverable MCP tools loaded: {{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
+
+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:
+  - `name`
+  - `label`
+  - `server_name`
+  - `mcp_tool_name`
+  - `description`
+  - input schema property keys (`schema_keys`)
+
+This is not repository search, file search, or code search. Use it only for MCP tool discovery.
+
+Returns JSON with:
+- `query`
+- `activated_tools` — MCP tools activated by this search call
+- `match_count` — number of ranked matches returned by the search
+- `total_tools`