@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/tools/index.ts

@@ -203,6 +203,8 @@ export interface ToolSession {
 	 * Runtime discovery only; never threaded into capability loading.
 	 */
 	home?: string;
+	/** Resolver-owned classification for the session's selected agent directory. */
+	profileAuthority?: "default" | "custom";
 	skills?: Skill[];
 	/** Currently executing skill prompt, when this tool session is inside one. */
 	getActiveSkillState?: () => Pick<SkillActiveEntry, "skill" | "session_id"> | undefined;
@@ -249,6 +251,14 @@ export interface ToolSession {
 	waitForUserSteering?: (signal: AbortSignal) => Promise<void>;
 	/** Get session ID */
 	getSessionId?: () => string | null;
+	/**
+	 * Opaque async-job ownership/lookup endpoint key. This is not a workflow or
+	 * path identity: workflow/session consumers must use getSessionId(). Only
+	 * AsyncJobManager ownership and endpoint-first lookup may use this accessor
+	 * (subagent-inherited managers are registered under the parent's endpoint;
+	 * review thread P1).
+	 */
+	getAsyncEndpointId?: () => string | null;
 	/** Get credential-selection session identity. */
 	getCredentialSessionId?: () => string | null;
 	/** Scope-held MCP facade for mcp:// resolution. */

package/src/tools/job.ts

@@ -105,7 +105,9 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	): Promise<AgentToolResult<JobToolDetails>> {
 		const manager =
 			this.session.getAsyncJobManager?.() ??
-			AsyncJobManager.forEndpoint(this.session.getSessionId?.() ?? undefined) ??
+			AsyncJobManager.forEndpoint(
+				this.session.getAsyncEndpointId?.() ?? this.session.getSessionId?.() ?? undefined,
+			) ??
 			AsyncJobManager.instance();
 		if (!manager) {
 			return {
@@ -254,10 +256,21 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 				},
 			});
 		};
-		const progressTimer = onUpdate ? setInterval(emitProgress, PROGRESS_INTERVAL_MS) : undefined;
-		emitProgress();
+		const { promise: progressError, reject: rejectProgress } = Promise.withResolvers<never>();
+		racePromises.push(progressError);
+		let progressTimer: Timer | undefined;
 
 		try {
+			progressTimer = onUpdate
+				? setInterval(() => {
+						try {
+							emitProgress();
+						} catch (error) {
+							rejectProgress(error);
+						}
+					}, PROGRESS_INTERVAL_MS)
+				: undefined;
+			emitProgress();
 			if (signal) {
 				const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<void>();
 				const onAbort = () => abortResolve();
@@ -396,7 +409,11 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			const generation = manager.getJob?.(job.id)?.generation;
 			if (!generation) continue;
 			// The endpoint disambiguates concurrent sessions' same job ids (review P1).
-			const registration = lookupOwnedRegistration(job.id, generation, this.session.getSessionId?.() ?? "local");
+			const registration = lookupOwnedRegistration(
+				job.id,
+				generation,
+				this.session.getAsyncEndpointId?.() ?? this.session.getSessionId?.() ?? "local",
+			);
 			if (registration) unregisterOwnedRegistration(registration);
 		}
 

package/src/tools/monitor.ts

@@ -119,7 +119,9 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 		// different concurrent top-level session (review thread P1).
 		const manager =
 			this.session.getAsyncJobManager?.() ??
-			AsyncJobManager.forEndpoint(this.session.getSessionId?.() ?? undefined) ??
+			AsyncJobManager.forEndpoint(
+				this.session.getAsyncEndpointId?.() ?? this.session.getSessionId?.() ?? undefined,
+			) ??
 			AsyncJobManager.instance();
 		if (!manager) {
 			throw new ToolError("Async execution is disabled; the monitor tool is unavailable in this session.");
@@ -197,7 +199,11 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 			// endpoint-less fallback scan could attach a foreign session's
 			// registration (review thread P2).
 			const registration = generation
-				? lookupOwnedRegistration(jobId, generation, this.session.getSessionId?.() ?? "local")
+				? lookupOwnedRegistration(
+						jobId,
+						generation,
+						this.session.getAsyncEndpointId?.() ?? this.session.getSessionId?.() ?? "local",
+					)
 				: undefined;
 			const ownedCompletion = registration
 				? {

package/src/tools/path-utils.ts

@@ -696,6 +696,8 @@ export interface ToolScopeOptions {
 	surfaceExactFilePaths?: boolean;
 	/** Extra hint appended to "Path not found" when stat fails and the user supplied multiple paths. */
 	multipathStatHint?: string;
+	/** Cancels internal-URL resolution and prevents further scope work. */
+	signal?: AbortSignal;
 }
 
 export interface ToolScopeResolution {
@@ -719,6 +721,7 @@ export interface ToolScopeResolution {
  */
 export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<ToolScopeResolution> {
 	const { rawPaths: inputs, cwd, internalUrlAction, getArtifactsDir, getAuthorizedArtifactsDirs } = opts;
+	opts.signal?.throwIfAborted();
 	const rawPaths = inputs.map(normalizePathLikeInput);
 	if (rawPaths.some(rawPath => rawPath.length === 0)) {
 		throw new ToolError("`paths` must contain non-empty paths or globs");
@@ -727,6 +730,7 @@ export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<To
 	const resolvedPathInputs: string[] = [];
 	const immutableSourcePaths = new Set<string>();
 	for (const rawPath of rawPaths) {
+		opts.signal?.throwIfAborted();
 		if (!internalRouter.canHandle(rawPath)) {
 			resolvedPathInputs.push(rawPath);
 			continue;
@@ -739,7 +743,9 @@ export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<To
 			getArtifactsDir,
 			getAuthorizedArtifactsDirs,
 			mcpManager: opts.mcpManager,
+			signal: opts.signal,
 		});
+		opts.signal?.throwIfAborted();
 		if (!resource.sourcePath) {
 			throw new ToolError(`Cannot ${internalUrlAction} internal URL without a backing file: ${rawPath}`);
 		}
@@ -753,6 +759,7 @@ export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<To
 	let effectivePaths = resolvedPathInputs;
 	if (resolvedPathInputs.length > 1) {
 		const partition = await partitionExistingPaths(resolvedPathInputs, cwd, parseSearchPath);
+		opts.signal?.throwIfAborted();
 		if (partition.valid.length === 0) {
 			throw new ToolError(`Path not found: ${partition.missing.join(", ")}`);
 		}

package/src/tools/read.ts

@@ -818,10 +818,22 @@ export async function streamLinesFromFile(
 					fitBytes += separatorBytes + currentLineLength;
 				} else {
 					transitionToSplit();
-					pushSplit(lineIndex, lineText, currentLineLength, currentLineDropped, capturePartialPreview());
+					pushSplit(
+						lineIndex,
+						lineText,
+						currentLineLength,
+						currentLineDropped,
+						currentLineDropped || currentLineLength > ringBudgetBytes ? capturePartialPreview() : undefined,
+					);
 				}
 			} else {
-				pushSplit(lineIndex, lineText, currentLineLength, currentLineDropped, capturePartialPreview());
+				pushSplit(
+					lineIndex,
+					lineText,
+					currentLineLength,
+					currentLineDropped,
+					currentLineDropped || currentLineLength > ringBudgetBytes ? capturePartialPreview() : undefined,
+				);
 			}
 		}
 

package/src/tools/render-utils.ts

@@ -308,6 +308,7 @@ export function formatDiagnostics(
 	// Count total diagnostics for "... X more" calculation
 	const totalParsedDiags = files.reduce((sum, [, diags]) => sum + diags.length, 0);
 	const totalDiags = totalParsedDiags + unparsed.length;
+	const willShowAllRemaining = totalDiags <= maxDiags;
 
 	// Helper to check if this is the very last item in the tree
 	const isTreeEnd = (fileIdx: number, diagIdx: number | null, unparsedIdx: number | null): boolean => {
@@ -329,9 +330,6 @@ export function formatDiagnostics(
 	for (let fi = 0; fi < files.length && diagsShown < maxDiags; fi++) {
 		const [filePath, diagnostics] = files[fi];
 		// File is "last" only if no more files AND no unparsed AND we'll show all diags AND no "... X more"
-		const remainingDiagsInFile = diagnostics.length;
-		const remainingDiagsAfter = files.slice(fi + 1).reduce((sum, [, d]) => sum + d.length, 0) + unparsed.length;
-		const willShowAllRemaining = diagsShown + remainingDiagsInFile + remainingDiagsAfter <= maxDiags;
 		const isLastFileNode = fi === files.length - 1 && unparsed.length === 0 && willShowAllRemaining;
 		const fileBranch = isLastFileNode ? theme.tree.last : theme.tree.branch;
 

package/src/tools/resource-gc.ts

@@ -106,7 +106,10 @@ const defaultDeps: ResourceGcDeps = {
 };
 
 // ── Controller state (process-global; tabs/browsers are module-global too) ──────────────────
-const activeSessions = new Map<string, { settings: Settings; cwd: () => string }>();
+const activeSessions = new Map<
+	string,
+	{ settings: Settings; cwd: () => string; memoryGuardGeneration: symbol; memoryGuardEnabled: boolean }
+>();
 const scheduler = new MemoryGuardHost({
 	run: async () => {
 		await sweepOnce(deps);
@@ -141,12 +144,26 @@ function resolveSessionSweepIntervalMs(settings: Settings): number {
 export function registerResourceGcSession(reg: ResourceGcRegistration): () => void {
 	const registeredCwd = reg.cwd;
 	const cwd = typeof registeredCwd === "function" ? registeredCwd : () => registeredCwd ?? process.cwd();
-	activeSessions.set(reg.sessionId, { settings: reg.settings, cwd });
+	const registration = {
+		settings: reg.settings,
+		cwd,
+		memoryGuardGeneration: Symbol(),
+		memoryGuardEnabled: resolveMemoryGuardPolicy(reg.settings).enabled,
+	};
+	activeSessions.set(reg.sessionId, registration);
 	const unregisterSchedule = scheduler.register({
 		ownerId: reg.sessionId,
 		intervalMs: resolveSessionSweepIntervalMs(reg.settings),
 	});
 	const unregisterSettings = reg.settings.onChanged(path => {
+		if (path === "memoryGuard.enabled") {
+			const enabled = resolveMemoryGuardPolicy(reg.settings).enabled;
+			if (enabled !== registration.memoryGuardEnabled) {
+				// Fence samples already in flight, even if the guard is re-enabled before they settle.
+				registration.memoryGuardGeneration = Symbol();
+				registration.memoryGuardEnabled = enabled;
+			}
+		}
 		if (
 			path === "memoryGuard.enabled" ||
 			path === "memoryGuard.checkIntervalMs" ||
@@ -498,8 +515,8 @@ function sweepMemoryPressureGuard(d: ResourceGcDeps): Promise<void> | undefined
 }
 async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void> {
 	const now = d.monotonicNow();
-	const dueSessions: Array<{ sessionId: string; policy: MemoryGuardPolicy; cwd: string }> = [];
-	for (const [sessionId, { settings, cwd: resolveCwd }] of activeSessions) {
+	const dueSessions: Array<{ sessionId: string; policy: MemoryGuardPolicy; cwd: string; generation: symbol }> = [];
+	for (const [sessionId, { settings, cwd: resolveCwd, memoryGuardGeneration }] of activeSessions) {
 		const policy = resolveMemoryGuardPolicy(settings);
 		const cwd = resolveCwd();
 		if (!policy.enabled) {
@@ -511,14 +528,15 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 		const lastEvaluated = memoryGuardLastEvaluatedAt.get(sessionId);
 		if (lastEvaluated !== undefined && now - lastEvaluated < policy.checkIntervalMs) continue;
 		memoryGuardLastEvaluatedAt.set(sessionId, now);
-		dueSessions.push({ sessionId, policy, cwd });
+		dueSessions.push({ sessionId, policy, cwd, generation: memoryGuardGeneration });
 	}
 	if (dueSessions.length === 0) return;
 
 	const snapshot = await d.memorySnapshot();
 	let gcRequested = false;
-	const gcTelemetry: Array<{ sessionId: string } & Record<string, unknown>> = [];
-	for (const { sessionId, policy } of dueSessions) {
+	const gcTelemetry: Array<{ sessionId: string; generation: symbol } & Record<string, unknown>> = [];
+	for (const { sessionId, policy, generation } of dueSessions) {
+		if (activeSessions.get(sessionId)?.memoryGuardGeneration !== generation) continue;
 		const pressure = __selectMemoryPressureDomainForTest(snapshot, policy.policyLimitBytes);
 		const limit = resolveEffectiveMemoryLimit({
 			hardCapBytes: pressure.hardCapBytes,
@@ -548,6 +566,7 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 				gcRequested = true;
 				gcTelemetry.push({
 					sessionId,
+					generation,
 					parentBytes: pressure.parentBytes,
 					totalUsageBytes: pressure.totalUsageBytes,
 					effectiveLimitBytes: limit.effectiveBytes,
@@ -587,7 +606,8 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 	if (gcRequested) {
 		try {
 			d.runGc();
-			for (const { sessionId, ...telemetry } of gcTelemetry) {
+			for (const { sessionId, generation, ...telemetry } of gcTelemetry) {
+				if (activeSessions.get(sessionId)?.memoryGuardGeneration !== generation) continue;
 				memoryGuardGcActive.add(sessionId);
 				d.logWarn("Memory guard: GC threshold reached", { sessionId, ...telemetry });
 			}

package/src/tools/search.ts

@@ -5,7 +5,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { GrepMatch, GrepResult, grep as grepFn } from "@gajae-code/natives";
 import type { Component } from "@gajae-code/tui";
 import { Text } from "@gajae-code/tui";
-import { prompt, untilAborted } from "@gajae-code/utils";
+import { prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import { getFileReadCache } from "../edit/file-read-cache";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -35,7 +35,7 @@ import {
 	PREVIEW_LIMITS,
 	splitGroupsByBlankLine,
 } from "./render-utils";
-import { ToolError } from "./tool-errors";
+import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
 let searchNativesLoad:
@@ -71,6 +71,7 @@ const searchSchema = z
 			.number()
 			.optional()
 			.describe("files to skip before collecting results — use to paginate when the prior call hit the file limit"),
+		timeout: z.number().min(0.5).max(60).default(5).describe("timeout in seconds (0.5–60)").optional(),
 	})
 	.strict();
 
@@ -90,6 +91,9 @@ export const SINGLE_FILE_MATCHES = 200;
  * (DEFAULT_FILE_LIMIT files × MULTI_FILE_PER_FILE_MATCHES matches) plus
  * pagination headroom so the caller can see total file count. */
 const INTERNAL_TOTAL_CAP = 2000;
+const DEFAULT_SEARCH_TIMEOUT_MS = 5000;
+const MIN_SEARCH_TIMEOUT_MS = 500;
+const MAX_SEARCH_TIMEOUT_MS = 60_000;
 
 /**
  * Detect a `,` that is not inside a `{…}` brace expansion. Used to catch
@@ -130,6 +134,7 @@ function containsTopLevelComma(entry: string): boolean {
 async function resolveArchiveSearchPaths(
 	paths: string[],
 	cwd: string,
+	signal?: AbortSignal,
 ): Promise<{
 	resolvedPaths: string[];
 	displayMap: Map<string, string>;
@@ -143,64 +148,71 @@ async function resolveArchiveSearchPaths(
 	const unreadable: string[] = [];
 	let tempDir: string | undefined;
 	const archiveCache = new Map<string, ArchiveReader>();
+	const cleanup = async () => {
+		const directory = tempDir;
+		tempDir = undefined;
+		if (directory) await rm(directory, { recursive: true, force: true }).catch(() => {});
+	};
 
-	for (let idx = 0; idx < paths.length; idx++) {
-		const entry = paths[idx];
-		const candidates = parseArchivePathCandidates(entry);
-		// Longest archive prefix first; we want the one whose member portion is non-empty.
-		const member = candidates.find(c => c.subPath !== "" && c.archivePath !== entry);
-		if (!member) continue;
+	try {
+		for (let idx = 0; idx < paths.length; idx++) {
+			signal?.throwIfAborted();
+			const entry = paths[idx];
+			const candidates = parseArchivePathCandidates(entry);
+			// Longest archive prefix first; we want the one whose member portion is non-empty.
+			const member = candidates.find(c => c.subPath !== "" && c.archivePath !== entry);
+			if (!member) continue;
+
+			const archiveAbs = resolveReadPath(member.archivePath, cwd);
+			let archive = archiveCache.get(archiveAbs);
+			if (!archive) {
+				try {
+					archive = await openArchive(archiveAbs);
+				} catch (err) {
+					unreadable.push(`${entry} (cannot open archive: ${(err as Error).message})`);
+					continue;
+				}
+				archiveCache.set(archiveAbs, archive);
+			}
 
-		const archiveAbs = resolveReadPath(member.archivePath, cwd);
-		let archive = archiveCache.get(archiveAbs);
-		if (!archive) {
+			let extracted: ExtractedArchiveFile;
 			try {
-				archive = await openArchive(archiveAbs);
+				extracted = await archive.readFile(member.subPath);
 			} catch (err) {
-				unreadable.push(`${entry} (cannot open archive: ${(err as Error).message})`);
+				unreadable.push(`${entry} (${(err as Error).message})`);
+				continue;
+			}
+			signal?.throwIfAborted();
+			// UTF-8 only — binary members would just produce noise through ripgrep.
+			if (extracted.bytes.some(byte => byte === 0)) {
+				unreadable.push(`${entry} (binary archive entry)`);
+				continue;
+			}
+			let text: string;
+			try {
+				text = new TextDecoder("utf-8", { fatal: true }).decode(extracted.bytes);
+			} catch {
+				unreadable.push(`${entry} (non-UTF-8 archive entry)`);
 				continue;
 			}
-			archiveCache.set(archiveAbs, archive);
-		}
-
-		let extracted: ExtractedArchiveFile;
-		try {
-			extracted = await archive.readFile(member.subPath);
-		} catch (err) {
-			unreadable.push(`${entry} (${(err as Error).message})`);
-			continue;
-		}
-		// UTF-8 only — binary members would just produce noise through ripgrep.
-		if (extracted.bytes.some(byte => byte === 0)) {
-			unreadable.push(`${entry} (binary archive entry)`);
-			continue;
-		}
-		let text: string;
-		try {
-			text = new TextDecoder("utf-8", { fatal: true }).decode(extracted.bytes);
-		} catch {
-			unreadable.push(`${entry} (non-UTF-8 archive entry)`);
-			continue;
-		}
 
-		if (!tempDir) {
-			tempDir = await mkdtemp(path.join(tmpdir(), "gjc-search-archive-"));
+			if (!tempDir) {
+				tempDir = await mkdtemp(path.join(tmpdir(), "gjc-search-archive-"));
+			}
+			// Per-entry filename keeps the scratch path unique even when two selectors
+			// resolve to members with the same basename.
+			const safeBase = path.basename(member.subPath).replace(/[^\w.-]+/g, "_") || "entry";
+			const tempPath = path.join(tempDir, `${idx}-${safeBase}`);
+			await writeFile(tempPath, text);
+			resolvedPaths[idx] = tempPath;
+			displayMap.set(tempPath, entry);
+			displaySet.add(entry);
 		}
-		// Per-entry filename keeps the scratch path unique even when two selectors
-		// resolve to members with the same basename.
-		const safeBase = path.basename(member.subPath).replace(/[^\w.-]+/g, "_") || "entry";
-		const tempPath = path.join(tempDir, `${idx}-${safeBase}`);
-		await writeFile(tempPath, text);
-		resolvedPaths[idx] = tempPath;
-		displayMap.set(tempPath, entry);
-		displaySet.add(entry);
+	} catch (error) {
+		await cleanup();
+		throw error;
 	}
 
-	const cleanup = async () => {
-		if (tempDir) {
-			await rm(tempDir, { recursive: true, force: true }).catch(() => {});
-		}
-	};
 	return { resolvedPaths, displayMap, displaySet, unreadable, cleanup };
 }
 
@@ -235,6 +247,8 @@ export interface SearchToolOptions {
 	context?: number;
 	/** Per-call total match cap used by Cursor's native Pi grep frame. */
 	totalMatchLimit?: number;
+	/** Test or remote override for the native grep implementation. */
+	grep?: typeof grepFn;
 }
 
 type SearchParams = z.infer<typeof searchSchema>;
@@ -266,12 +280,23 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 		_onUpdate?: AgentToolUpdateCallback<SearchToolDetails>,
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<SearchToolDetails>> {
-		const { pattern, i, gitignore, skip } = params;
+		const { pattern, i, gitignore, skip, timeout } = params;
 		// Recurring real-world failure mode: models omit `paths` for repo-wide
 		// searches. Default to the working directory instead of failing the call.
 		const paths = params.paths ?? ["."];
+		const requestedTimeoutMs = timeout != null ? Math.round(timeout * 1000) : DEFAULT_SEARCH_TIMEOUT_MS;
+		const timeoutMs = Math.min(MAX_SEARCH_TIMEOUT_MS, Math.max(MIN_SEARCH_TIMEOUT_MS, requestedTimeoutMs));
+		const deadlineAt = Date.now() + timeoutMs;
+		const timeoutSignal = AbortSignal.timeout(timeoutMs);
+		const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+		const throwIfSearchCancelled = (): void => {
+			signal?.throwIfAborted();
+			if (Date.now() >= deadlineAt) throw new Error("Aborted: Timeout");
+			combinedSignal.throwIfAborted();
+		};
 
-		return untilAborted(signal, async () => {
+		try {
+			throwIfSearchCancelled();
 			const normalizedPattern = pattern.trim();
 			if (!normalizedPattern) {
 				throw new ToolError("Pattern must not be empty");
@@ -292,8 +317,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				displaySet: archiveDisplaySet,
 				unreadable: archiveUnreadable,
 				cleanup: cleanupArchiveScratch,
-			} = await resolveArchiveSearchPaths(paths, this.session.cwd);
+			} = await resolveArchiveSearchPaths(paths, this.session.cwd, combinedSignal);
+			let completedResult: AgentToolResult<SearchToolDetails> | undefined;
 			try {
+				throwIfSearchCancelled();
 				if (archiveUnreadable.length > 0 && resolvedPaths.length === archiveUnreadable.length) {
 					// All inputs were archive selectors we couldn't materialize; surface the
 					// reason instead of a downstream "path not found" from the scope resolver.
@@ -324,7 +351,9 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					trackImmutableSources: true,
 					surfaceExactFilePaths: true,
 					multipathStatHint: " (`paths` entries must each exist relative to cwd)",
+					signal: combinedSignal,
 				});
+				throwIfSearchCancelled();
 				const { searchPath, isDirectory, multiTargets, exactFilePaths, missingPaths, immutableSourcePaths } = scope;
 				// When the only input was an archive selector, surface that selector instead
 				// of the temp scratch path the resolver substituted in.
@@ -345,7 +374,8 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				const baseDisplayMode = resolveFileDisplayMode(this.session);
 				const immutableDisplayMode = resolveFileDisplayMode(this.session, { immutable: true });
 
-				const { GrepOutputMode, grep } = await searchNatives();
+				const { GrepOutputMode, grep: nativeGrep } = await searchNatives();
+				const grep = this.options.grep ?? nativeGrep;
 				const effectiveOutputMode = GrepOutputMode.Content;
 				// Multi-scope = more than one file may match. We fetch up to
 				// INTERNAL_TOTAL_CAP matches from native grep, then in JS group by
@@ -363,7 +393,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						let totalMatches = 0;
 						let filesSearched = 0;
 						const targets = exactFilePaths
-							? exactFilePaths.map(filePath => ({ basePath: filePath, glob: undefined as string | undefined }))
+							? exactFilePaths.map(filePath => ({
+									basePath: filePath,
+									glob: undefined as string | undefined,
+								}))
 							: (multiTargets ?? []);
 						for (const target of targets) {
 							const targetResult = await grep(
@@ -381,9 +414,12 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 									contextAfter: normalizedContextAfter,
 									maxColumns: DEFAULT_MAX_COLUMN,
 									mode: effectiveOutputMode,
+									signal: combinedSignal,
+									timeoutMs,
 								},
 								undefined,
 							);
+							throwIfSearchCancelled();
 							limitReached = limitReached || Boolean(targetResult.limitReached);
 							totalMatches += targetResult.totalMatches;
 							filesSearched += targetResult.filesSearched;
@@ -416,9 +452,12 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 								contextAfter: normalizedContextAfter,
 								maxColumns: DEFAULT_MAX_COLUMN,
 								mode: effectiveOutputMode,
+								signal: combinedSignal,
+								timeoutMs,
 							},
 							undefined,
 						);
+						throwIfSearchCancelled();
 					}
 				} catch (err) {
 					if (err instanceof Error && err.message.startsWith("regex parse error")) {
@@ -518,7 +557,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						missingPaths: missingPaths.length > 0 ? missingPaths : undefined,
 					};
 					const text = warningNote ? `No matches found\n${warningNote}` : "No matches found";
-					return toolResult(details).text(text).done();
+					const noMatchResult = toolResult(details).text(text).done();
+					await cleanupArchiveScratch();
+					throwIfSearchCancelled();
+					return noMatchResult;
 				}
 				const outputLines: string[] = [];
 				let linesTruncated = false;
@@ -644,11 +686,25 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				if (truncation.truncated) {
 					resultBuilder.truncation(truncation, { direction: "head" });
 				}
-				return resultBuilder.done();
+				throwIfSearchCancelled();
+				completedResult = resultBuilder.done();
 			} finally {
 				await cleanupArchiveScratch();
 			}
-		});
+			throwIfSearchCancelled();
+			if (!completedResult) throw new Error("Search result assembly did not complete");
+			return completedResult;
+		} catch (error) {
+			const nativeTimedOut = error instanceof Error && error.message === "Aborted: Timeout";
+			if ((timeoutSignal.aborted || nativeTimedOut) && !signal?.aborted) {
+				const seconds = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}` : (timeoutMs / 1000).toFixed(1);
+				throw new ToolError(`Search timed out after ${seconds}s; increase timeout or narrow paths/pattern`);
+			}
+			if (combinedSignal.aborted || (error instanceof Error && error.name === "AbortError")) {
+				throw new ToolAbortError();
+			}
+			throw error;
+		}
 	}
 }
 
@@ -662,6 +718,7 @@ interface SearchRenderArgs {
 	i?: boolean;
 	gitignore?: boolean;
 	skip?: number;
+	timeout?: number;
 }
 
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
@@ -674,6 +731,7 @@ export const searchToolRenderer = {
 		if (args.i) meta.push("case:insensitive");
 		if (args.gitignore === false) meta.push("gitignore:false");
 		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);
+		if (args.timeout !== undefined && args.timeout !== 5) meta.push(`timeout:${args.timeout}s`);
 
 		const text = renderStatusLine(
 			{ icon: "pending", title: "Search", description: args.pattern || "?", meta },

package/src/tools/skill-discovery.ts

@@ -76,9 +76,14 @@ export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema
 	): Promise<AgentToolResult<SkillDiscoveryToolDetails>> {
 		return untilAborted(signal, async () => {
 			const source = input.source ?? "all";
+			const agentDir =
+				this.#session.getSessionAgentDir?.() ??
+				(this.#session.home === undefined ? this.#session.settings.getAgentDir() : undefined);
 			const result = await discoverRuntimeSkills({
 				cwd: this.#session.cwd,
 				home: this.#session.home,
+				agentDir,
+				profileAuthority: this.#session.profileAuthority,
 				query: input.query,
 				source,
 				limit: input.limit,