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

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/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/grep.md

@@ -1,4 +1,4 @@
-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)

package/src/sdk.ts

@@ -9,8 +9,17 @@ import {
 import type { Message, Model } from "@oh-my-pi/pi-ai";
 
 import { prewarmOpenAICodexResponses } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
+import { SearchDb } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { $env, getAgentDbPath, getAgentDir, getProjectDir, logger, postmortem } from "@oh-my-pi/pi-utils";
+import {
+	$env,
+	getAgentDbPath,
+	getAgentDir,
+	getProjectDir,
+	getSearchDbDir,
+	logger,
+	postmortem,
+} from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { AsyncJobManager } from "./async";
 import { createAutoresearchExtension } from "./autoresearch";
@@ -131,6 +140,8 @@ export interface CreateAgentSessionOptions {
 	authStorage?: AuthStorage;
 	/** Model registry. Default: discoverModels(authStorage, agentDir) */
 	modelRegistry?: ModelRegistry;
+	/** Shared native search DB for grep/glob/fuzzyFind-backed workflows. */
+	searchDb?: SearchDb;
 
 	/** Model to use. Default: from settings, else first available */
 	model?: Model;
@@ -381,6 +392,7 @@ function createCustomToolContext(ctx: ExtensionContext): CustomToolContext {
 		sessionManager: ctx.sessionManager,
 		modelRegistry: ctx.modelRegistry,
 		model: ctx.model,
+		searchDb: ctx.searchDb,
 		isIdle: ctx.isIdle,
 		hasQueuedMessages: ctx.hasPendingMessages,
 		abort: ctx.abort,
@@ -862,6 +874,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			})
 		: undefined;
 
+	const searchDb = options.searchDb ?? new SearchDb(getSearchDbDir(agentDir));
 	const pendingActionStore = new PendingActionStore();
 	const toolSession: ToolSession = {
 		cwd,
@@ -911,6 +924,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		modelRegistry,
 		asyncJobManager,
 		pendingActionStore,
+		searchDb,
 	};
 
 	// Initialize internal URL router for internal protocols (agent://, artifact://, memory://, skill://, rule://, mcp://, local://)
@@ -1173,6 +1187,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			sessionManager,
 			modelRegistry,
 			model: agent?.state.model,
+			searchDb,
 			isIdle: () => !session?.isStreaming,
 			hasQueuedMessages: () => (session?.queuedMessageCount ?? 0) > 0,
 			abort: () => session?.abort(),
@@ -1539,6 +1554,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		obfuscator,
 		asyncJobManager,
 		pendingActionStore,
+		searchDb,
 	});
 
 	if (model?.api === "openai-codex-responses") {

package/src/session/agent-session.ts

@@ -50,6 +50,7 @@ import {
 	modelsAreEqual,
 	parseRateLimitReason,
 } from "@oh-my-pi/pi-ai";
+import type { SearchDb } from "@oh-my-pi/pi-natives";
 import { abortableSleep, getAgentDbPath, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import type { AsyncJob, AsyncJobManager } from "../async";
 import type { Rule } from "../capability/rule";
@@ -237,6 +238,8 @@ export interface AgentSessionConfig {
 	obfuscator?: SecretObfuscator;
 	/** Pending action store for preview/apply workflows */
 	pendingActionStore?: PendingActionStore;
+	/** Shared native search DB for grep/glob/fuzzyFind-backed workflows. */
+	searchDb?: SearchDb;
 }
 
 /** Options for AgentSession.prompt() */
@@ -348,6 +351,7 @@ export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
 	readonly settings: Settings;
+	readonly searchDb: SearchDb | undefined;
 
 	#asyncJobManager: AsyncJobManager | undefined = undefined;
 	#scopedModels: Array<{ model: Model; thinkingLevel?: ThinkingLevel }>;
@@ -462,6 +466,7 @@ export class AgentSession {
 		this.agent = config.agent;
 		this.sessionManager = config.sessionManager;
 		this.settings = config.settings;
+		this.searchDb = config.searchDb;
 		this.#asyncJobManager = config.asyncJobManager;
 		this.#scopedModels = config.scopedModels ?? [];
 		this.#thinkingLevel = config.thinkingLevel;
@@ -1888,6 +1893,7 @@ export class AgentSession {
 			sessionManager: this.sessionManager,
 			modelRegistry: this.#modelRegistry,
 			model: this.model,
+			searchDb: this.searchDb,
 			isIdle: () => !this.isStreaming,
 			hasQueuedMessages: () => this.queuedMessageCount > 0,
 			abort: () => {