@oh-my-pi/pi-coding-agent 13.16.5 → 13.17.0

package/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 ## [Unreleased]
 
+## [13.17.0] - 2026-03-30
+
+### Added
+
+- Added `marketplace.autoUpdate` setting (`off`/`notify`/`auto`, default `notify`) for automatic plugin update checking on startup
+- Added background marketplace catalog refresh on startup when catalogs are stale (>24h)
+- Added `/marketplace upgrade [name@marketplace]` slash command to upgrade outdated plugins
+- Added `omp plugin upgrade [name@marketplace]` CLI command for plugin upgrades
+- Added `checkForUpdates()`, `upgradePlugin()`, `upgradeAllPlugins()`, and `refreshStaleMarketplaces()` to MarketplaceManager
+- Added marketplace plugin system: registry types, ID helpers, atomic read/write for `marketplaces.json` and `installed_plugins.json` (Claude Code-compatible format)
+- Added `MarketplaceManager` orchestrator for marketplace and plugin lifecycle (add/remove/update marketplaces, install/uninstall/enable plugins)
+- Added marketplace fetcher with source classification (GitHub, git, URL, local) and catalog validation
+- Added plugin source resolver with `pathIsWithin` containment checks and versioned cache manager
+- Added CLI commands: `omp plugin marketplace add|remove|update|list`, `omp plugin discover [marketplace]`
+- Added `classifyInstallTarget()` to distinguish `name@marketplace` from npm install targets
+- Extended `listClaudePluginRoots()` to read OMP's installed plugins registry alongside Claude Code's, with OMP as authoritative for duplicate plugin IDs
+- Added `--plugin-dir <path>` repeatable CLI flag for loading plugins from local directories
+- Added `/reload-plugins` slash command that invalidates fs content cache and plugin roots cache
+- Added `printPluginHelp()` entries for marketplace and discover commands
+- Added MCP server loading from marketplace plugin `.mcp.json` files with `${CLAUDE_PLUGIN_ROOT}` variable substitution
+- Added skill and command namespacing for marketplace plugins (`plugin-name:skill-name`)
+- Added LSP config loading from marketplace plugin roots via `getPreloadedPluginRoots()`
+- Wired `--plugin-dir` runtime injection into plugin roots at session startup with highest precedence
+- Added git (GitHub, SSH, HTTPS) and HTTP URL marketplace source fetching
+- Added `/marketplace` TUI slash command with subcommands: add, remove, update, list, discover, install, uninstall, installed
+- Added `/plugins` TUI slash command to view all installed plugins (npm + marketplace) and enable/disable marketplace plugins
+
+### Changed
+
+- Changed marketplace clone promotion to occur after duplicate and drift checks, improving safety of concurrent marketplace operations
+
+### Removed
+
+- Removed grep.app code search provider support; code search now uses Exa exclusively
+- Removed `providers.codeSearch` setting and related configuration options
+
+### Fixed
+
+- Fixed git-subdir plugin source resolution to properly clean up temporary clone directories on path validation errors
+- Fixed LSP config loading to use correct filenames variable when scanning plugin roots
+- Fixed plugin selector UI to request render on cancel, preventing stale display state
+- Fixed marketplace install command error handling to display user-friendly error messages instead of crashing
+- Fixed MCP tools from newly added servers not being activated after `/mcp add` — `refreshMCPTools` preserves prior MCP tool selections, so brand-new servers had their tools registered in the registry but never passed to the agent; tools are now explicitly activated on successful connection
+- Fixed `skill://` URI resolver to handle namespaced skills via longest-prefix matching against registered skill names
+
 ## [13.16.5] - 2026-03-29
 
 ### Fixed

package/package.json

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

package/src/cli/args.ts

@@ -38,6 +38,7 @@ export interface Args {
 	hooks?: string[];
 	extensions?: string[];
 	noExtensions?: boolean;
+	pluginDirs?: string[];
 	print?: boolean;
 	export?: string;
 	noSkills?: boolean;
@@ -151,6 +152,9 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 		} else if ((arg === "--extension" || arg === "-e") && i + 1 < args.length) {
 			result.extensions = result.extensions ?? [];
 			result.extensions.push(args[++i]);
+		} else if (arg === "--plugin-dir" && i + 1 < args.length) {
+			result.pluginDirs = result.pluginDirs ?? [];
+			result.pluginDirs.push(args[++i]);
 		} else if (arg === "--no-extensions") {
 			result.noExtensions = true;
 		} else if (arg === "--no-skills") {
@@ -262,6 +266,9 @@ ${chalk.bold("Available Tools (default-enabled unless noted):")}
   web_search    - Search the web
   ask           - Ask user questions (interactive mode only)
 
+${chalk.bold("Plugin Options:")}
+  --plugin-dir <path>        Load plugin from directory (repeatable)
+
 ${chalk.bold("Useful Commands:")}
   omp agents unpack           - Export bundled subagents to ~/.omp/agent/agents (default)
   omp agents unpack --project - Export bundled subagents to ./.omp/agents`;

package/src/cli/classify-install-target.ts

@@ -0,0 +1,50 @@
+/**
+ * Classify an install spec as a marketplace plugin reference or a plain npm package.
+ *
+ * Rules (applied in order):
+ *  1. Starts with `@` (scoped npm) -> always npm.
+ *  2. Contains `@` after the first character -> split on the LAST `@`.
+ *     If the right-hand side is a known marketplace name, it's a marketplace ref.
+ *     Otherwise it's an npm spec (e.g. `pkg@1.2.3`).
+ *  3. No `@` -> npm.
+ */
+// Common npm dist-tags that should never be interpreted as marketplace names
+const NPM_DIST_TAGS = new Set([
+	"latest",
+	"next",
+	"beta",
+	"alpha",
+	"canary",
+	"rc",
+	"dev",
+	"stable",
+	"nightly",
+	"experimental",
+]);
+
+// Semver-like: starts with digit, or contains version range prefixes
+const LOOKS_LIKE_VERSION = /^[\d~^>=<]/;
+
+export function classifyInstallTarget(
+	spec: string,
+	knownMarketplaces: Set<string>,
+): { type: "marketplace"; name: string; marketplace: string } | { type: "npm"; spec: string } {
+	// Rule 1: scoped npm package — @ at position 0 is never a marketplace separator.
+	if (spec.startsWith("@")) return { type: "npm", spec };
+	// Rule 2: @ somewhere after the first character.
+	const atIdx = spec.lastIndexOf("@");
+	if (atIdx > 0) {
+		const rhs = spec.slice(atIdx + 1);
+		// Dist-tags and version specifiers are never marketplace names.
+		if (NPM_DIST_TAGS.has(rhs) || LOOKS_LIKE_VERSION.test(rhs)) {
+			return { type: "npm", spec };
+		}
+		if (knownMarketplaces.has(rhs)) {
+			return { type: "marketplace", name: spec.slice(0, atIdx), marketplace: rhs };
+		}
+		// Not a known marketplace — treat as npm version specifier.
+		return { type: "npm", spec };
+	}
+	// Rule 3: no @ at all.
+	return { type: "npm", spec };
+}

package/src/cli/plugin-cli.ts

@@ -7,6 +7,13 @@
 import { APP_NAME } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { PluginManager, parseSettingValue, validateSetting } from "../extensibility/plugins";
+import {
+	getInstalledPluginsRegistryPath,
+	getMarketplacesCacheDir,
+	getMarketplacesRegistryPath,
+	getPluginsCacheDir,
+	MarketplaceManager,
+} from "../extensibility/plugins/marketplace/index.js";
 import { theme } from "../modes/theme/theme";
 
 // =============================================================================
@@ -22,7 +29,10 @@ export type PluginAction =
 	| "features"
 	| "config"
 	| "enable"
-	| "disable";
+	| "disable"
+	| "marketplace"
+	| "discover"
+	| "upgrade";
 
 export interface PluginCommandArgs {
 	action: PluginAction;
@@ -53,6 +63,9 @@ const VALID_ACTIONS: PluginAction[] = [
 	"config",
 	"enable",
 	"disable",
+	"marketplace",
+	"discover",
+	"upgrade",
 ];
 
 /**
@@ -108,6 +121,10 @@ export function parsePluginArgs(args: string[]): PluginCommandArgs | undefined {
 	return result;
 }
 
+import { classifyInstallTarget } from "./classify-install-target";
+
+export { classifyInstallTarget } from "./classify-install-target";
+
 // =============================================================================
 // Command Handlers
 // =============================================================================
@@ -146,6 +163,153 @@ export async function runPluginCommand(cmd: PluginCommandArgs): Promise<void> {
 		case "disable":
 			await handleDisable(manager, cmd.args, cmd.flags);
 			break;
+		case "marketplace":
+			await handleMarketplace(cmd.args, cmd.flags);
+			break;
+		case "discover":
+			await handleDiscover(cmd.args, cmd.flags);
+			break;
+		case "upgrade":
+			await handleUpgrade(cmd.args, cmd.flags);
+			break;
+	}
+}
+
+// =============================================================================
+// Marketplace Handlers
+// =============================================================================
+
+function makeMarketplaceManager(): MarketplaceManager {
+	return new MarketplaceManager({
+		marketplacesRegistryPath: getMarketplacesRegistryPath(),
+		installedRegistryPath: getInstalledPluginsRegistryPath(),
+		marketplacesCacheDir: getMarketplacesCacheDir(),
+		pluginsCacheDir: getPluginsCacheDir(),
+	});
+}
+
+async function handleMarketplace(args: string[], _flags: PluginCommandArgs["flags"]): Promise<void> {
+	const subcommand = args[0] ?? "list";
+	const manager = makeMarketplaceManager();
+
+	switch (subcommand) {
+		case "add": {
+			const source = args[1];
+			if (!source) {
+				console.error(chalk.red(`Usage: ${APP_NAME} plugin marketplace add <source>`));
+				process.exit(1);
+			}
+			try {
+				await manager.addMarketplace(source);
+				console.log(chalk.green(`${theme.status.success} Added marketplace: ${source}`));
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to add marketplace: ${err}`));
+				process.exit(1);
+			}
+			break;
+		}
+		case "remove":
+		case "rm": {
+			const name = args[1];
+			if (!name) {
+				console.error(chalk.red(`Usage: ${APP_NAME} plugin marketplace remove <name>`));
+				process.exit(1);
+			}
+			try {
+				await manager.removeMarketplace(name);
+				console.log(chalk.green(`${theme.status.success} Removed marketplace: ${name}`));
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to remove marketplace: ${err}`));
+				process.exit(1);
+			}
+			break;
+		}
+		case "update": {
+			try {
+				const name = args[1];
+				if (name) {
+					await manager.updateMarketplace(name);
+					console.log(chalk.green(`${theme.status.success} Updated marketplace: ${name}`));
+				} else {
+					const results = await manager.updateAllMarketplaces();
+					console.log(chalk.green(`${theme.status.success} Updated ${results.length} marketplace(s)`));
+				}
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to update marketplace: ${err}`));
+				process.exit(1);
+			}
+			break;
+		}
+		default: {
+			if (subcommand !== "list") {
+				console.error(chalk.red(`Unknown marketplace subcommand: ${subcommand}`));
+				console.error(chalk.dim("Valid subcommands: add, remove, update, list"));
+				process.exit(1);
+			}
+			try {
+				const marketplaces = await manager.listMarketplaces();
+				if (marketplaces.length === 0) {
+					console.log(chalk.dim("No marketplaces configured"));
+					console.log(chalk.dim(`\nAdd one with: ${APP_NAME} plugin marketplace add <source>`));
+					return;
+				}
+				console.log(chalk.bold("Configured Marketplaces:\n"));
+				for (const mp of marketplaces) {
+					console.log(`  ${chalk.cyan(mp.name)}  ${chalk.dim(mp.sourceUri)}`);
+				}
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to list marketplaces: ${err}`));
+				process.exit(1);
+			}
+			break;
+		}
+	}
+}
+
+async function handleDiscover(args: string[], _flags: PluginCommandArgs["flags"]): Promise<void> {
+	const marketplace = args[0];
+	const manager = makeMarketplaceManager();
+	try {
+		const plugins = await manager.listAvailablePlugins(marketplace);
+
+		if (plugins.length === 0) {
+			console.log(chalk.dim(marketplace ? `No plugins found in ${marketplace}` : "No plugins available"));
+			return;
+		}
+
+		console.log(chalk.bold(`Available Plugins${marketplace ? ` (${marketplace})` : ""}:\n`));
+		for (const plugin of plugins) {
+			console.log(`  ${chalk.cyan(plugin.name)}${plugin.version ? `@${plugin.version}` : ""}`);
+			if (plugin.description) {
+				console.log(chalk.dim(`    ${plugin.description}`));
+			}
+		}
+	} catch (err) {
+		console.error(chalk.red(`${theme.status.error} Failed to discover plugins: ${err}`));
+		process.exit(1);
+	}
+}
+
+async function handleUpgrade(args: string[], _flags: PluginCommandArgs["flags"]): Promise<void> {
+	const manager = makeMarketplaceManager();
+	const pluginId = args[0];
+	try {
+		if (pluginId) {
+			const result = await manager.upgradePlugin(pluginId);
+			console.log(chalk.green(`Upgraded ${pluginId} to ${result.version}`));
+		} else {
+			const results = await manager.upgradeAllPlugins();
+			if (results.length === 0) {
+				console.log("All marketplace plugins are up to date.");
+			} else {
+				for (const r of results) {
+					console.log(chalk.green(`  ${r.pluginId}: ${r.from} -> ${r.to}`));
+				}
+			}
+		}
+	} catch (err) {
+		console.error(chalk.red(`Failed to upgrade: ${err}`));
+		process.exit(1);
 	}
 }
 
@@ -158,13 +322,35 @@ async function handleInstall(
 		console.error(chalk.red(`Usage: ${APP_NAME} plugin install <package[@version]>[features] ...`));
 		console.error(chalk.dim("Examples:"));
 		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa`));
-		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa[search,websets]`));
-		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa[*]  # all features`));
-		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa[]   # no optional features`));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install name@marketplace`));
 		process.exit(1);
 	}
 
+	// Build known marketplace set for classification
+	const mktMgr = makeMarketplaceManager();
+	const knownMarketplaces = new Set((await mktMgr.listMarketplaces()).map(m => m.name));
+
 	for (const spec of packages) {
+		const target = classifyInstallTarget(spec, knownMarketplaces);
+
+		if (target.type === "marketplace") {
+			try {
+				const entry = await mktMgr.installPlugin(target.name, target.marketplace, {
+					force: flags.force,
+				});
+				console.log(
+					chalk.green(
+						`${theme.status.success} Installed ${target.name} from ${target.marketplace} (${entry.version})`,
+					),
+				);
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to install ${spec}: ${err}`));
+				process.exit(1);
+			}
+			continue;
+		}
+
+		// npm path
 		try {
 			const result = await manager.install(spec, { force: flags.force, dryRun: flags.dryRun });
 
@@ -196,10 +382,27 @@ async function handleUninstall(manager: PluginManager, packages: string[], flags
 		process.exit(1);
 	}
 
+	// For uninstall, check the installed plugins registry directly.
+	// This works even if the marketplace entry was later removed from marketplaces.json.
+	const mktMgr = makeMarketplaceManager();
+	const installedPlugins = new Set((await mktMgr.listInstalledPlugins()).map(p => p.id));
+
 	for (const name of packages) {
+		if (installedPlugins.has(name)) {
+			// Exact match against installed marketplace plugin IDs (name@marketplace)
+			try {
+				await mktMgr.uninstallPlugin(name);
+				console.log(chalk.green(`${theme.status.success} Uninstalled ${name}`));
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to uninstall ${name}: ${err}`));
+				process.exit(1);
+			}
+			continue;
+		}
+
+		// npm path
 		try {
 			await manager.uninstall(name);
-
 			if (flags.json) {
 				console.log(JSON.stringify({ uninstalled: name }));
 			} else {
@@ -213,44 +416,53 @@ async function handleUninstall(manager: PluginManager, packages: string[], flags
 }
 
 async function handleList(manager: PluginManager, flags: { json?: boolean }): Promise<void> {
-	const plugins = await manager.list();
+	const npmPlugins = await manager.list();
+	const mktMgr = makeMarketplaceManager();
+	const mktPlugins = await mktMgr.listInstalledPlugins();
 
 	if (flags.json) {
-		console.log(JSON.stringify(plugins, null, 2));
+		console.log(JSON.stringify({ npm: npmPlugins, marketplace: mktPlugins }, null, 2));
 		return;
 	}
 
-	if (plugins.length === 0) {
+	if (npmPlugins.length === 0 && mktPlugins.length === 0) {
 		console.log(chalk.dim("No plugins installed"));
 		console.log(chalk.dim(`\nInstall plugins with: ${APP_NAME} plugin install <package>`));
 		return;
 	}
 
-	console.log(chalk.bold("Installed Plugins:\n"));
-
-	for (const plugin of plugins) {
-		const status = plugin.enabled ? chalk.green(theme.status.enabled) : chalk.dim(theme.status.disabled);
-		const nameVersion = `${plugin.name}@${plugin.version}`;
-		console.log(`${status} ${nameVersion}`);
-
-		if (plugin.manifest.description) {
-			console.log(chalk.dim(`  ${plugin.manifest.description}`));
-		}
-
-		if (plugin.enabledFeatures && plugin.enabledFeatures.length > 0) {
-			console.log(chalk.dim(`  Features: ${plugin.enabledFeatures.join(", ")}`));
+	if (npmPlugins.length > 0) {
+		console.log(chalk.bold("npm Plugins:\n"));
+		for (const plugin of npmPlugins) {
+			const status = plugin.enabled ? chalk.green(theme.status.enabled) : chalk.dim(theme.status.disabled);
+			const nameVersion = `${plugin.name}@${plugin.version}`;
+			console.log(`${status} ${nameVersion}`);
+			if (plugin.manifest.description) {
+				console.log(chalk.dim(`  ${plugin.manifest.description}`));
+			}
+			if (plugin.enabledFeatures && plugin.enabledFeatures.length > 0) {
+				console.log(chalk.dim(`  Features: ${plugin.enabledFeatures.join(", ")}`));
+			}
+			if (plugin.manifest.features) {
+				const availableFeatures = Object.keys(plugin.manifest.features);
+				if (availableFeatures.length > 0) {
+					const enabledSet = new Set(plugin.enabledFeatures ?? []);
+					const featureDisplay = availableFeatures
+						.map(f => (enabledSet.has(f) ? chalk.green(f) : chalk.dim(f)))
+						.join(", ");
+					console.log(chalk.dim(`  Available: [${featureDisplay}]`));
+				}
+			}
 		}
+	}
 
-		// Show available features if manifest has them
-		if (plugin.manifest.features) {
-			const availableFeatures = Object.keys(plugin.manifest.features);
-			if (availableFeatures.length > 0) {
-				const enabledSet = new Set(plugin.enabledFeatures ?? []);
-				const featureDisplay = availableFeatures
-					.map(f => (enabledSet.has(f) ? chalk.green(f) : chalk.dim(f)))
-					.join(", ");
-				console.log(chalk.dim(`  Available: [${featureDisplay}]`));
-			}
+	if (mktPlugins.length > 0) {
+		if (npmPlugins.length > 0) console.log();
+		console.log(chalk.bold("Marketplace Plugins:\n"));
+		for (const plugin of mktPlugins) {
+			const entry = plugin.entries[0];
+			const version = entry?.version ?? "unknown";
+			console.log(`  ${plugin.id} (${version})`);
 		}
 	}
 }
@@ -630,6 +842,8 @@ ${chalk.bold("Commands:")}
   config <cmd> <pkg> [key] [val] Manage plugin settings
   enable <pkg>                   Enable a disabled plugin
   disable <pkg>                  Disable plugin without uninstalling
+  marketplace <cmd>            Manage marketplace sources (add, remove, update, list)
+  discover [marketplace]        Browse available marketplace plugins
 
 ${chalk.bold("Feature Syntax:")}
   pkg                Install with default features

package/src/commands/plugin.ts

@@ -15,6 +15,9 @@ const ACTIONS: PluginAction[] = [
 	"config",
 	"enable",
 	"disable",
+	"marketplace",
+	"discover",
+	"upgrade",
 ];
 
 export default class Plugin extends Command {

package/src/config/settings-schema.ts

@@ -198,6 +198,18 @@ export const SETTINGS_SCHEMA = {
 
 	extensions: { type: "array", default: EMPTY_STRING_ARRAY },
 
+	"marketplace.autoUpdate": {
+		type: "enum",
+		values: ["off", "notify", "auto"] as const,
+		default: "notify",
+		ui: {
+			tab: "tools",
+			label: "Marketplace Auto-Update",
+			description: "Check for plugin updates on startup (off/notify/auto)",
+			submenu: true,
+		},
+	},
+
 	enabledModels: { type: "array", default: EMPTY_STRING_ARRAY },
 
 	disabledProviders: { type: "array", default: EMPTY_STRING_ARRAY },
@@ -1490,19 +1502,6 @@ export const SETTINGS_SCHEMA = {
 			submenu: true,
 		},
 	},
-
-	"providers.codeSearch": {
-		type: "enum",
-		values: ["grep", "exa"] as const,
-		default: "grep",
-		ui: {
-			tab: "providers",
-			label: "Code Search Provider",
-			description: "Provider for code search tool",
-			submenu: true,
-		},
-	},
-
 	"providers.image": {
 		type: "enum",
 		values: ["auto", "gemini", "openrouter"] as const,

package/src/cursor.ts

@@ -7,7 +7,12 @@ import type {
 	AgentToolResult,
 	AgentToolUpdateCallback,
 } from "@oh-my-pi/pi-agent-core";
-import type { CursorMcpCall, CursorExecHandlers as ICursorExecHandlers, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type {
+	CursorMcpCall,
+	CursorShellStreamCallbacks,
+	CursorExecHandlers as ICursorExecHandlers,
+	ToolResultMessage,
+} from "@oh-my-pi/pi-ai";
 import { resolveToCwd } from "./tools/path-utils";
 
 interface CursorExecBridgeOptions {
@@ -204,6 +209,66 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		return toolResultMessage;
 	}
 
+	async shellStream(
+		args: Parameters<NonNullable<ICursorExecHandlers["shellStream"]>>[0],
+		callbacks: CursorShellStreamCallbacks,
+	) {
+		const toolCallId = decodeToolCallId(args.toolCallId);
+		const toolName = "bash";
+		const tool = this.options.tools.get(toolName);
+		if (!tool) {
+			const result = buildToolErrorResult(`Tool "${toolName}" not available`);
+			return createToolResultMessage(toolCallId, toolName, result, true);
+		}
+
+		const timeoutSeconds = args.timeout && args.timeout > 0 ? args.timeout : undefined;
+		const toolArgs: Record<string, unknown> = {
+			command: args.command,
+			cwd: args.workingDirectory || undefined,
+			timeout: timeoutSeconds,
+		};
+
+		this.options.emitEvent?.({ type: "tool_execution_start", toolCallId, toolName, args: toolArgs });
+
+		let result: AgentToolResult<unknown>;
+		let isError = false;
+
+		// Track previously streamed text so we only forward deltas.
+		let streamedLen = 0;
+		const onUpdate: AgentToolUpdateCallback<unknown> = partialResult => {
+			this.options.emitEvent?.({
+				type: "tool_execution_update",
+				toolCallId,
+				toolName,
+				args: toolArgs,
+				partialResult,
+			});
+			const text = partialResult.content.map(c => (c.type === "text" ? c.text : "")).join("");
+			if (text.length > streamedLen) {
+				callbacks.onStdout(text.slice(streamedLen));
+				streamedLen = text.length;
+			}
+		};
+
+		try {
+			result = await tool.execute(toolCallId, toolArgs, undefined, onUpdate, this.options.getToolContext?.());
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			result = buildToolErrorResult(message);
+			isError = true;
+		}
+
+		// onUpdate may not fire for every chunk — flush any remaining output
+		// from the final result that wasn't already streamed.
+		const finalText = result.content.map(c => (c.type === "text" ? c.text : "")).join("");
+		if (finalText.length > streamedLen) {
+			callbacks.onStdout(finalText.slice(streamedLen));
+		}
+
+		this.options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result, isError });
+		return createToolResultMessage(toolCallId, toolName, result, isError);
+	}
+
 	async diagnostics(args: Parameters<NonNullable<ICursorExecHandlers["diagnostics"]>>[0]) {
 		const toolCallId = decodeToolCallId(args.toolCallId);
 		const toolResultMessage = await executeTool(this.options, "lsp", toolCallId, {