@oh-my-pi/pi-coding-agent 13.16.0 → 13.16.2

package/src/ipy/kernel.ts

@@ -2,6 +2,7 @@ import { $env, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { Settings } from "../config/settings";
 import { htmlToBasicMarkdown } from "../web/scrapers/types";
+import { createCancellationError, getAbortReason, getExecutionCancellationError } from "./cancellation";
 import { acquireSharedGateway, releaseSharedGateway, shutdownSharedGateway } from "./gateway-coordinator";
 import { loadPythonModules } from "./modules";
 import { PYTHON_PRELUDE } from "./prelude";
@@ -35,6 +36,94 @@ function getExternalGatewayConfig(): ExternalGatewayConfig | null {
 	};
 }
 
+const STARTUP_CLEANUP_TIMEOUT_MS = 2_000;
+const WEBSOCKET_CONNECT_TIMEOUT_MS = 10_000;
+
+interface KernelLifecycleOptions {
+	signal?: AbortSignal;
+	deadlineMs?: number;
+}
+
+interface KernelShutdownOptions {
+	signal?: AbortSignal;
+	timeoutMs?: number;
+}
+
+function getRemainingTimeMs(deadlineMs?: number): number | undefined {
+	if (deadlineMs === undefined) return undefined;
+	return Math.max(0, deadlineMs - Date.now());
+}
+
+function throwIfStartupExecutionFailed(
+	result: Pick<KernelExecuteResult, "cancelled" | "status" | "timedOut">,
+	signal: AbortSignal | undefined,
+	failureMessage: string,
+): void {
+	if (result.cancelled) {
+		throw getExecutionCancellationError(result, signal, failureMessage);
+	}
+	if (result.status === "error") {
+		throw new Error(failureMessage);
+	}
+}
+
+function createAbortedSignal(reason: Error): AbortSignal {
+	const controller = new AbortController();
+	controller.abort(reason);
+	return controller.signal;
+}
+
+function combineAbortSignal(
+	options: KernelLifecycleOptions,
+	timeoutCapMs?: number,
+	fallbackReason = "Operation aborted",
+): AbortSignal | undefined {
+	if (options.signal?.aborted) {
+		return options.signal;
+	}
+
+	const signals: AbortSignal[] = [];
+	if (options.signal) {
+		signals.push(options.signal);
+	}
+
+	const remainingMs = getRemainingTimeMs(options.deadlineMs);
+	const timeoutMs =
+		remainingMs === undefined
+			? timeoutCapMs
+			: timeoutCapMs === undefined
+				? remainingMs
+				: Math.min(remainingMs, timeoutCapMs);
+
+	if (timeoutMs !== undefined) {
+		if (timeoutMs <= 0) {
+			return createAbortedSignal(createCancellationError("TimeoutError", fallbackReason));
+		}
+		signals.push(AbortSignal.timeout(timeoutMs));
+	}
+
+	if (signals.length === 0) return undefined;
+	return signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+}
+
+function throwIfAborted(signal: AbortSignal | undefined, fallbackReason: string): void {
+	if (!signal?.aborted) return;
+	throw getAbortReason(signal, fallbackReason);
+}
+
+function getStartupExecuteOptions(options: KernelLifecycleOptions): Pick<KernelExecuteOptions, "signal" | "timeoutMs"> {
+	return {
+		signal: combineAbortSignal(options, undefined, "Python kernel startup aborted"),
+		timeoutMs: getRemainingTimeMs(options.deadlineMs),
+	};
+}
+
+function getStartupCleanupTimeoutMs(deadlineMs?: number): number {
+	const remainingMs = getRemainingTimeMs(deadlineMs);
+	if (remainingMs === undefined || remainingMs <= 0) return STARTUP_CLEANUP_TIMEOUT_MS;
+	return Math.min(STARTUP_CLEANUP_TIMEOUT_MS, remainingMs);
+}
+
 export interface JupyterHeader {
 	msg_id: string;
 	session: string;
@@ -93,7 +182,7 @@ export interface PreludeHelper {
 	category: string;
 }
 
-interface KernelStartOptions {
+interface KernelStartOptions extends KernelLifecycleOptions {
 	cwd: string;
 	env?: Record<string, string | undefined>;
 	useSharedGateway?: boolean;
@@ -339,9 +428,12 @@ export class PythonKernel {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
 		}
 
+		const startup = { signal: options.signal, deadlineMs: options.deadlineMs };
+		const startupSignal = combineAbortSignal(startup, undefined, "Python kernel startup aborted");
+
 		const externalConfig = getExternalGatewayConfig();
 		if (externalConfig) {
-			return PythonKernel.#startWithExternalGateway(externalConfig, options.cwd, options.env);
+			return PythonKernel.#startWithExternalGateway(externalConfig, options.cwd, options.env, startup);
 		}
 
 		if (options.useSharedGateway === false) {
@@ -349,6 +441,7 @@ export class PythonKernel {
 		}
 
 		for (let attempt = 0; attempt < 2; attempt += 1) {
+			throwIfAborted(startupSignal, "Python kernel startup aborted");
 			try {
 				const sharedResult = await logger.timeAsync("PythonKernel.start:acquireSharedGateway", () =>
 					acquireSharedGateway(options.cwd),
@@ -357,7 +450,7 @@ export class PythonKernel {
 					throw new Error("Shared Python gateway unavailable");
 				}
 				const kernel = await logger.timeAsync("PythonKernel.start:startWithSharedGateway", () =>
-					PythonKernel.#startWithSharedGateway(sharedResult.url, options.cwd, options.env),
+					PythonKernel.#startWithSharedGateway(sharedResult.url, options.cwd, options.env, startup),
 				);
 				return kernel;
 			} catch (err) {
@@ -382,16 +475,20 @@ export class PythonKernel {
 		config: ExternalGatewayConfig,
 		cwd: string,
 		env?: Record<string, string | undefined>,
+		startup: KernelLifecycleOptions = {},
 	): Promise<PythonKernel> {
 		const headers: Record<string, string> = { "Content-Type": "application/json" };
 		if (config.token) {
 			headers.Authorization = `token ${config.token}`;
 		}
 
+		const startupSignal = combineAbortSignal(startup, undefined, "Python kernel startup aborted");
+		throwIfAborted(startupSignal, "Python kernel startup aborted");
 		const createResponse = await fetch(`${config.url}/api/kernels`, {
 			method: "POST",
 			headers,
 			body: JSON.stringify({ name: "python3" }),
+			signal: startupSignal,
 		});
 
 		if (!createResponse.ok) {
@@ -412,16 +509,23 @@ export class PythonKernel {
 		);
 
 		try {
-			await kernel.#connectWebSocket();
-			await kernel.#initializeKernelEnvironment(cwd, env);
-			const preludeResult = await kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false });
-			if (preludeResult.cancelled || preludeResult.status === "error") {
-				throw new Error("Failed to initialize Python kernel prelude");
-			}
-			await loadPythonModules(kernel, { cwd });
+			await kernel.#connectWebSocket(startup);
+			await kernel.#initializeKernelEnvironment(cwd, env, startup);
+			const preludeOptions = getStartupExecuteOptions(startup);
+			const preludeResult = await kernel.execute(PYTHON_PRELUDE, {
+				...preludeOptions,
+				silent: true,
+				storeHistory: false,
+			});
+			throwIfStartupExecutionFailed(
+				preludeResult,
+				preludeOptions.signal,
+				"Failed to initialize Python kernel prelude",
+			);
+			await loadPythonModules(kernel, { cwd, signal: startup.signal, deadlineMs: startup.deadlineMs });
 			return kernel;
 		} catch (err: unknown) {
-			await kernel.shutdown();
+			await kernel.shutdown({ timeoutMs: getStartupCleanupTimeoutMs(startup.deadlineMs) });
 			throw err;
 		}
 	}
@@ -430,12 +534,16 @@ export class PythonKernel {
 		gatewayUrl: string,
 		cwd: string,
 		env?: Record<string, string | undefined>,
+		startup: KernelLifecycleOptions = {},
 	): Promise<PythonKernel> {
+		const startupSignal = combineAbortSignal(startup, undefined, "Python kernel startup aborted");
+		throwIfAborted(startupSignal, "Python kernel startup aborted");
 		const createResponse = await logger.timeAsync("startWithSharedGateway:createKernel", () =>
 			fetch(`${gatewayUrl}/api/kernels`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
 				body: JSON.stringify({ name: "python3" }),
+				signal: startupSignal,
 			}),
 		);
 
@@ -458,46 +566,70 @@ export class PythonKernel {
 		const kernel = new PythonKernel(Snowflake.next(), kernelId, gatewayUrl, Snowflake.next(), "omp", true);
 
 		try {
-			await logger.timeAsync("startWithSharedGateway:connectWS", () => kernel.#connectWebSocket());
-			await logger.timeAsync("startWithSharedGateway:initEnv", () => kernel.#initializeKernelEnvironment(cwd, env));
+			await logger.timeAsync("startWithSharedGateway:connectWS", () => kernel.#connectWebSocket(startup));
+			await logger.timeAsync("startWithSharedGateway:initEnv", () =>
+				kernel.#initializeKernelEnvironment(cwd, env, startup),
+			);
+			const preludeOptions = getStartupExecuteOptions(startup);
 			const preludeResult = await logger.timeAsync("startWithSharedGateway:prelude", () =>
-				kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false }),
+				kernel.execute(PYTHON_PRELUDE, {
+					...preludeOptions,
+					silent: true,
+					storeHistory: false,
+				}),
+			);
+			throwIfStartupExecutionFailed(
+				preludeResult,
+				preludeOptions.signal,
+				"Failed to initialize Python kernel prelude",
+			);
+			await logger.timeAsync("startWithSharedGateway:loadModules", () =>
+				loadPythonModules(kernel, { cwd, signal: startup.signal, deadlineMs: startup.deadlineMs }),
 			);
-			if (preludeResult.cancelled || preludeResult.status === "error") {
-				throw new Error("Failed to initialize Python kernel prelude");
-			}
-			await logger.timeAsync("startWithSharedGateway:loadModules", () => loadPythonModules(kernel, { cwd }));
 			return kernel;
 		} catch (err: unknown) {
-			await kernel.shutdown();
+			await kernel.shutdown({ timeoutMs: getStartupCleanupTimeoutMs(startup.deadlineMs) });
 			throw err;
 		}
 	}
 
-	async #connectWebSocket(): Promise<void> {
+	async #connectWebSocket(options: KernelLifecycleOptions = {}): Promise<void> {
 		const wsBase = this.gatewayUrl.replace(/^http/, "ws");
 		let wsUrl = `${wsBase}/api/kernels/${this.kernelId}/channels`;
 		if (this.#authToken) {
 			wsUrl += `?token=${encodeURIComponent(this.#authToken)}`;
 		}
 
+		const connectSignal = combineAbortSignal(options, WEBSOCKET_CONNECT_TIMEOUT_MS, "WebSocket connection timeout");
+		throwIfAborted(connectSignal, "WebSocket connection timeout");
+
 		const { promise, resolve, reject } = Promise.withResolvers<void>();
 		const ws = new WebSocket(wsUrl);
 		ws.binaryType = "arraybuffer";
 		let settled = false;
 
-		const timeout = setTimeout(() => {
-			ws.close();
-			if (!settled) {
-				settled = true;
-				reject(new Error("WebSocket connection timeout"));
+		const finalize = (): void => {
+			if (connectSignal) {
+				connectSignal.removeEventListener("abort", onAbort);
 			}
-		}, 10000);
+		};
+
+		const onAbort = () => {
+			ws.close();
+			if (settled) return;
+			settled = true;
+			finalize();
+			reject(getAbortReason(connectSignal, "WebSocket connection timeout"));
+		};
+
+		if (connectSignal) {
+			connectSignal.addEventListener("abort", onAbort, { once: true });
+		}
 
 		ws.onopen = () => {
 			if (settled) return;
 			settled = true;
-			clearTimeout(timeout);
+			finalize();
 			this.#ws = ws;
 			resolve();
 		};
@@ -506,7 +638,7 @@ export class PythonKernel {
 			const error = new Error(`WebSocket error: ${event}`);
 			if (!settled) {
 				settled = true;
-				clearTimeout(timeout);
+				finalize();
 				reject(error);
 				return;
 			}
@@ -520,7 +652,7 @@ export class PythonKernel {
 			this.#ws = null;
 			if (!settled) {
 				settled = true;
-				clearTimeout(timeout);
+				finalize();
 				reject(new Error("WebSocket closed before connection"));
 				return;
 			}
@@ -561,7 +693,11 @@ export class PythonKernel {
 		return promise;
 	}
 
-	async #initializeKernelEnvironment(cwd: string, env?: Record<string, string | undefined>): Promise<void> {
+	async #initializeKernelEnvironment(
+		cwd: string,
+		env?: Record<string, string | undefined>,
+		options: KernelLifecycleOptions = {},
+	): Promise<void> {
 		const envEntries = Object.entries(env ?? {}).filter(([, value]) => value !== undefined);
 		const envPayload = Object.fromEntries(envEntries);
 		const initScript = [
@@ -572,10 +708,13 @@ export class PythonKernel {
 			"for __omp_key, __omp_val in __omp_env.items():\n    os.environ[__omp_key] = __omp_val",
 			"if __omp_cwd not in sys.path:\n    sys.path.insert(0, __omp_cwd)",
 		].join("\n");
-		const result = await this.execute(initScript, { silent: true, storeHistory: false });
-		if (result.cancelled || result.status === "error") {
-			throw new Error("Failed to initialize Python kernel environment");
-		}
+		const executeOptions = getStartupExecuteOptions(options);
+		const result = await this.execute(initScript, {
+			...executeOptions,
+			silent: true,
+			storeHistory: false,
+		});
+		throwIfStartupExecutionFailed(result, executeOptions.signal, "Failed to initialize Python kernel environment");
 	}
 
 	#abortPendingExecutions(reason: string): void {
@@ -842,16 +981,23 @@ export class PythonKernel {
 		}
 	}
 
-	async shutdown(): Promise<void> {
+	async shutdown(options?: KernelShutdownOptions): Promise<void> {
 		if (this.#disposed) return;
 		this.#disposed = true;
 		this.#alive = false;
 		this.#abortPendingExecutions("Kernel shutdown");
 
+		const shutdownSignal = combineAbortSignal(
+			{ signal: options?.signal },
+			options?.timeoutMs,
+			"Python kernel shutdown timed out",
+		);
+
 		try {
 			await fetch(`${this.gatewayUrl}/api/kernels/${this.kernelId}`, {
 				method: "DELETE",
 				headers: this.#authHeaders(),
+				signal: shutdownSignal,
 			});
 		} catch (err: unknown) {
 			logger.warn("Failed to delete kernel via API", { error: err instanceof Error ? err.message : String(err) });

package/src/ipy/modules.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getAgentModulesDir, getProjectDir, getProjectModulesDir } from "@oh-my-pi/pi-utils";
+import { getExecutionCancellationError } from "./cancellation";
 
 export type PythonModuleSource = "user" | "project";
 
@@ -13,13 +14,14 @@ export interface PythonModuleEntry {
 export interface PythonModuleExecuteResult {
 	status: "ok" | "error";
 	cancelled: boolean;
+	timedOut?: boolean;
 	error?: { name: string; value: string; traceback: string[] };
 }
 
 export interface PythonModuleExecutor {
 	execute: (
 		code: string,
-		options?: { silent?: boolean; storeHistory?: boolean },
+		options?: { signal?: AbortSignal; timeoutMs?: number; silent?: boolean; storeHistory?: boolean },
 	) => Promise<PythonModuleExecuteResult>;
 }
 
@@ -30,6 +32,12 @@ export interface DiscoverPythonModulesOptions {
 	agentDir?: string;
 }
 
+export interface LoadPythonModulesOptions extends DiscoverPythonModulesOptions {
+	signal?: AbortSignal;
+	timeoutMs?: number;
+	deadlineMs?: number;
+}
+
 interface ModuleCandidate {
 	name: string;
 	path: string;
@@ -61,6 +69,25 @@ async function readModuleContent(candidate: ModuleCandidate): Promise<PythonModu
 	}
 }
 
+function createTimeoutError(message: string): Error {
+	const error = new Error(message);
+	error.name = "TimeoutError";
+	return error;
+}
+
+function requireModuleExecutionTimeoutMs(options: LoadPythonModulesOptions): number | undefined {
+	if (options.deadlineMs === undefined) {
+		return options.timeoutMs;
+	}
+
+	const remainingMs = options.deadlineMs - Date.now();
+	if (remainingMs <= 0) {
+		throw createTimeoutError("Python module loading timed out");
+	}
+
+	return remainingMs;
+}
+
 /**
  * Discover Python prelude extension modules from user and project directories.
  */
@@ -95,12 +122,20 @@ export async function discoverPythonModules(options: DiscoverPythonModulesOption
  */
 export async function loadPythonModules(
 	executor: PythonModuleExecutor,
-	options: DiscoverPythonModulesOptions = {},
+	options: LoadPythonModulesOptions = {},
 ): Promise<PythonModuleEntry[]> {
 	const modules = await discoverPythonModules(options);
 	for (const module of modules) {
-		const result = await executor.execute(module.content, { silent: true, storeHistory: false });
-		if (result.cancelled || result.status === "error") {
+		const result = await executor.execute(module.content, {
+			signal: options.signal,
+			timeoutMs: requireModuleExecutionTimeoutMs(options),
+			silent: true,
+			storeHistory: false,
+		});
+		if (result.cancelled) {
+			throw getExecutionCancellationError(result, options.signal, `Failed to load Python module ${module.path}`);
+		}
+		if (result.status === "error") {
 			const details = result.error ? `${result.error.name}: ${result.error.value}` : "unknown error";
 			throw new Error(`Failed to load Python module ${module.path}: ${details}`);
 		}

package/src/modes/acp/acp-agent.ts

@@ -832,6 +832,7 @@ export class AcpAgent implements Agent {
 			},
 			{
 				getModel: () => this.#session.model,
+				getSearchDb: () => this.#session.searchDb,
 				isIdle: () => !this.#session.isStreaming,
 				abort: () => {
 					void this.#session.abort();

package/src/modes/components/assistant-message.ts

@@ -76,7 +76,7 @@ export class AssistantMessageComponent extends Container {
 						image.data,
 						image.mimeType,
 						{ fallbackColor: (text: string) => theme.fg("toolOutput", text) },
-						{ maxWidthCells: 60 },
+						{ maxWidthCells: settings.get("tui.maxInlineImageColumns") },
 					),
 				);
 				continue;

package/src/modes/components/tool-execution.ts

@@ -14,6 +14,7 @@ import {
 	type TUI,
 } from "@oh-my-pi/pi-tui";
 import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
+import { settings } from "../../config/settings";
 import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
 import { computeEditDiff, computeHashlineDiff, computePatchDiff, type DiffError, type DiffResult } from "../../patch";
@@ -530,7 +531,7 @@ export class ToolExecutionComponent extends Container {
 						imageData,
 						imageMimeType,
 						{ fallbackColor: (s: string) => theme.fg("toolOutput", s) },
-						{ maxWidthCells: 60 },
+						{ maxWidthCells: settings.get("tui.maxInlineImageColumns") },
 					);
 					this.#imageComponents.push(imageComponent);
 					this.addChild(imageComponent);

package/src/modes/controllers/extension-ui-controller.ts

@@ -123,6 +123,7 @@ export class ExtensionUiController {
 		};
 		const contextActions: ExtensionContextActions = {
 			getModel: () => this.ctx.session.model,
+			getSearchDb: () => this.ctx.session.searchDb,
 			isIdle: () => !this.ctx.session.isStreaming,
 			abort: () => this.ctx.session.abort(),
 			hasPendingMessages: () => this.ctx.session.queuedMessageCount > 0,
@@ -384,6 +385,7 @@ export class ExtensionUiController {
 		};
 		const contextActions: ExtensionContextActions = {
 			getModel: () => this.ctx.session.model,
+			getSearchDb: () => this.ctx.session.searchDb,
 			isIdle: () => !this.ctx.session.isStreaming,
 			abort: () => this.ctx.session.abort(),
 			hasPendingMessages: () => this.ctx.session.queuedMessageCount > 0,
@@ -581,6 +583,7 @@ export class ExtensionUiController {
 						sessionManager: this.ctx.session.sessionManager,
 						modelRegistry: this.ctx.session.modelRegistry,
 						model: this.ctx.session.model,
+						searchDb: this.ctx.session.searchDb,
 						isIdle: () => !this.ctx.session.isStreaming,
 						hasPendingMessages: () => this.ctx.session.queuedMessageCount > 0,
 						hasQueuedMessages: () => this.ctx.session.queuedMessageCount > 0,

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

@@ -550,6 +550,7 @@ export class InputController {
 		return createPromptActionAutocompleteProvider({
 			commands,
 			basePath,
+			searchDb: this.ctx.session.searchDb,
 			keybindings: this.ctx.keybindings,
 			copyCurrentLine: () => this.handleCopyCurrentLine(),
 			copyPrompt: () => this.handleCopyPrompt(),

package/src/modes/print-mode.ts

@@ -76,6 +76,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			// ExtensionContextActions
 			{
 				getModel: () => session.model,
+				getSearchDb: () => session.searchDb,
 				isIdle: () => !session.isStreaming,
 				abort: () => session.abort(),
 				hasPendingMessages: () => session.queuedMessageCount > 0,

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

@@ -1,3 +1,4 @@
+import type { SearchDb } from "@oh-my-pi/pi-natives";
 import {
 	type AutocompleteItem,
 	type AutocompleteProvider,
@@ -23,6 +24,7 @@ interface PromptActionAutocompleteItem extends AutocompleteItem {
 interface PromptActionAutocompleteOptions {
 	commands: SlashCommand[];
 	basePath: string;
+	searchDb?: SearchDb;
 	keybindings: KeybindingsManager;
 	copyCurrentLine: () => void;
 	copyPrompt: () => void;
@@ -90,8 +92,8 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	#baseProvider: CombinedAutocompleteProvider;
 	#actions: PromptActionDefinition[];
 
-	constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[]) {
-		this.#baseProvider = new CombinedAutocompleteProvider(commands, basePath);
+	constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[], searchDb?: SearchDb) {
+		this.#baseProvider = new CombinedAutocompleteProvider(commands, basePath, searchDb);
 		this.#actions = actions;
 	}
 
@@ -227,5 +229,5 @@ export function createPromptActionAutocompleteProvider(
 		},
 	];
 
-	return new PromptActionAutocompleteProvider(options.commands, options.basePath, actions);
+	return new PromptActionAutocompleteProvider(options.commands, options.basePath, actions, options.searchDb);
 }

package/src/modes/rpc/rpc-mode.ts

@@ -404,6 +404,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			// ExtensionContextActions
 			{
 				getModel: () => session.agent.state.model,
+				getSearchDb: () => session.searchDb,
 				isIdle: () => !session.isStreaming,
 				abort: () => session.abort(),
 				hasPendingMessages: () => session.queuedMessageCount > 0,

package/src/prompts/tools/ast-edit.md

@@ -2,7 +2,7 @@ Performs structural AST-aware rewrites via native ast-grep.
 
 <instruction>
 - Use for codemods and structural rewrites where plain text replace is unsafe
-- Narrow scope with `path` before replacing (`path` accepts files, directories, glob patterns, or comma/space-separated path lists; use `glob` for an additional filter relative to `path`)
+- Narrow scope with `path` before replacing (`path` accepts files, directories, glob patterns, or comma-separated path lists; use `glob` for an additional filter relative to `path`)
 - Default to language-scoped rewrites in mixed repositories: set `lang` and keep `path`/`glob` narrow
 - Treat parse issues as a scoping or pattern-shape signal: tighten `path`/`lang`, or rewrite the pattern into valid syntax before retrying
 - Metavariables captured in each rewrite pattern (`$A`, `$$$ARGS`) are substituted into that entry's rewrite template

package/src/prompts/tools/ast-grep.md

@@ -2,7 +2,7 @@ Performs structural code search using AST matching via native ast-grep.
 
 <instruction>
 - Use this when syntax shape matters more than raw text (calls, declarations, specific language constructs)
-- Prefer a precise `path` scope to keep results targeted and deterministic (`path` accepts files, directories, glob patterns, or comma/space-separated path lists; use `glob` for an additional filter relative to `path`)
+- Prefer a precise `path` scope to keep results targeted and deterministic (`path` accepts files, directories, glob patterns, or comma-separated path lists; use `glob` for an additional filter relative to `path`)
 - Default to language-scoped search in mixed repositories: pair `path` + `glob` + explicit `lang` to avoid parse-noise from non-source files
 - `pat` is required and must include at least one non-empty AST pattern; `lang` is optional (`lang` is inferred per file extension when omitted)
 - Multiple patterns run in one native pass; results are merged and then `offset`/`limit` are applied to the combined match set

package/src/prompts/tools/find.md

@@ -2,7 +2,7 @@ Finds files using fast pattern matching that works with any codebase size.
 
 <instruction>
 - Pattern includes the search path: `src/**/*.ts`, `lib/*.json`, `**/*.md`
-- You may provide comma/space-separated path lists, for example `apps/,packages/,phases/` or `apps/ packages/ phases/`; each item is searched and results are merged
+- You may provide comma-separated path lists, for example `apps/,packages/,phases/`
 - Simple patterns like `*.ts` automatically search recursively from cwd
 - Includes hidden files by default (use `hidden: false` to exclude)
 - You **SHOULD** perform multiple searches in parallel when potentially useful

package/src/prompts/tools/grep.md

@@ -1,8 +1,8 @@
-Searches files using powerful regex matching built on ripgrep.
+Searches files using powerful regex matching.
 
 <instruction>
 - Supports full regex syntax (e.g., `log.*Error`, `function\\s+\\w+`); literal braces need escaping (`interface\\{\\}` for `interface{}` in Go)
-- `path` may be a file, directory, glob path, or comma/space-separated path list; pair it with `glob` when you need an additional relative file filter
+- `path` may be a file, directory, glob path, or comma-separated path list; pair it with `glob` when you need an additional relative file filter
 - Filter files with `glob` (e.g., `*.js`, `**/*.tsx`) or `type` (e.g., `js`, `py`, `rust`)
 - Respects `.gitignore` by default; set `gitignore: false` to include ignored files
 - For cross-line patterns like `struct \\{[\\s\\S]*?field`, set `multiline: true` if needed