@oh-my-pi/pi-coding-agent 16.1.23 → 16.2.1

package/src/tools/{search.ts → grep.ts}

@@ -2,7 +2,13 @@ import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
 import { formatHashlineHeader } from "@oh-my-pi/hashline";
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type {
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	ToolTier,
+} from "@oh-my-pi/pi-agent-core";
 import { type GrepMatch, GrepOutputMode, type GrepResult, grep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
@@ -14,7 +20,7 @@ import type { LocalProtocolOptions } from "../internal-urls/local-protocol";
 import { InternalUrlRouter } from "../internal-urls/router";
 import type { InternalResource, ResolveContext } from "../internal-urls/types";
 import type { Theme } from "../modes/theme/theme";
-import searchDescription from "../prompts/tools/search.md" with { type: "text" };
+import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead, truncateLine } from "../session/streaming-output";
 import {
 	Ellipsis,
@@ -40,6 +46,7 @@ import {
 	isLineInRanges,
 	type LineRange,
 	parseLineRanges,
+	pathTargetsSsh,
 	type ResolvedSearchTarget,
 	resolveReadPath,
 	resolveToolSearchScope,
@@ -77,7 +84,7 @@ const searchSchema = type({
 		.describe("files to skip before collecting results — use to paginate when the prior call hit the file limit"),
 });
 
-export type SearchToolInput = typeof searchSchema.infer;
+export type GrepToolInput = typeof searchSchema.infer;
 export function toPathList(input: string | string[] | undefined): string[] {
 	return typeof input === "string" ? [input] : (input ?? []);
 }
@@ -110,14 +117,39 @@ const SEARCH_GREP_TIMEOUT_MS = 30_000;
  * line-range selector peeled off the trailing `:N-M` (or `:N+K`, `:N,M`, …)
  * chunk via {@link splitPathAndSel}.
  */
-interface SearchPathSpec {
+interface GrepPathSpec {
 	original: string;
 	clean: string;
 	ranges?: [LineRange, ...LineRange[]];
 }
 
-function parsePathSpecs(rawEntries: readonly string[]): SearchPathSpec[] {
-	const specs: SearchPathSpec[] = [];
+/**
+ * Mirror of read's `parseSel` selector grammar (`read.ts`) so `grep` accepts
+ * exactly the internal-URL selectors `read` accepts: a single chunk that is a
+ * line range, `raw`, or `conflicts`; or a two-chunk compound of exactly one `raw`
+ * plus one line range. Everything else (`:-10`, `:1-1:1-2`, `:conflicts:1-1`,
+ * `:raw:conflicts`) is rejected.
+ *
+ * This mirrors the *accepted set* of `parseSel`; `read` rejects the same shapes
+ * caller-side when a peeled internal-URL selector parses as `none`, so neither
+ * tool silently widens on a malformed compound. Keep in sync with `read.parseSel`.
+ */
+function isReadSelectorGrammar(sel: string): boolean {
+	if (sel.includes(":")) {
+		const chunks = sel.split(":");
+		if (chunks.length !== 2) return false;
+		const [a, b] = chunks as [string, string];
+		const aIsRaw = a.toLowerCase() === "raw";
+		const bIsRaw = b.toLowerCase() === "raw";
+		const rangeChunk = aIsRaw ? b : bIsRaw ? a : null;
+		return rangeChunk !== null && parseLineRanges(rangeChunk) !== null;
+	}
+	const lower = sel.toLowerCase();
+	return lower === "raw" || lower === "conflicts" || parseLineRanges(sel) !== null;
+}
+
+function parsePathSpecs(rawEntries: readonly string[]): GrepPathSpec[] {
+	const specs: GrepPathSpec[] = [];
 	for (const entry of rawEntries) {
 		// Internal URLs (`artifact://`, `skill://`, …) use the URL-aware splitter,
 		// which peels selector-shaped tails only for selector-capable schemes and
@@ -127,11 +159,14 @@ function parsePathSpecs(rawEntries: readonly string[]): SearchPathSpec[] {
 		// still honor any embedded line range as a match filter.
 		const internalSplit = splitInternalUrlSel(entry);
 		if (internalSplit.sel !== undefined) {
-			specs.push({
-				original: entry,
-				clean: internalSplit.path,
-				ranges: selectorLineRanges(internalSplit.sel),
-			});
+			// Reject selectors read's parseSel would reject (`:-10`, `:1-1:1-2`,
+			// `:conflicts:1-1`) instead of silently widening the search or dropping a chunk.
+			if (!isReadSelectorGrammar(internalSplit.sel)) {
+				throw new ToolError(
+					`paths entry "${entry}" has an invalid selector ":${internalSplit.sel}" — use ":N-M" line ranges, ":raw"/":conflicts", a range plus ":raw", or percent-encode a literal ":" as %3A`,
+				);
+			}
+			specs.push({ original: entry, clean: internalSplit.path, ranges: selectorLineRanges(internalSplit.sel) });
 			continue;
 		}
 		const split = splitPathAndSel(entry);
@@ -322,6 +357,11 @@ function indexSearchLines(content: string): IndexedContentLines {
 	return { lines, starts };
 }
 
+function lineAllowed(lineNumber: number, ranges: readonly LineRange[] | undefined): boolean {
+	return !ranges || isLineInRanges(lineNumber, ranges);
+}
+
+/** Binary search for the index of the line containing byte `offset`. */
 function findLineIndex(starts: readonly number[], offset: number): number {
 	if (starts.length === 0) return -1;
 	let low = 0;
@@ -337,8 +377,131 @@ function findLineIndex(starts: readonly number[], offset: number): number {
 	return Math.max(0, high);
 }
 
-function lineAllowed(lineNumber: number, ranges: readonly LineRange[] | undefined): boolean {
-	return !ranges || isLineInRanges(lineNumber, ranges);
+/**
+ * JS-`RegExp` fallback returning matched line indexes for a virtual resource too
+ * large for native grep (>`NATIVE_GREP_MAX_FILE_BYTES`, which native grep silently
+ * skips). Mirrors the native probe's output (sorted, deduped indexes) so
+ * `buildVirtualMatches` rebuilds context/ranges identically; only the regex dialect
+ * differs for these oversized inputs (the pre-RE2-parity behavior).
+ */
+function jsMatchedLineIndexes(
+	content: string,
+	lines: readonly string[],
+	pattern: string,
+	ignoreCase: boolean,
+	multiline: boolean,
+): number[] {
+	const flags = `${ignoreCase ? "i" : ""}${multiline ? "gm" : ""}`;
+	let regex: RegExp;
+	try {
+		regex = new RegExp(pattern, flags);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new ToolError(`Invalid regex: ${message.replace(/^Invalid regular expression:\s*/i, "")}`);
+	}
+	if (!multiline) {
+		const out: number[] = [];
+		for (let i = 0; i < lines.length; i++) {
+			regex.lastIndex = 0;
+			if (regex.test(lines[i] ?? "")) out.push(i);
+		}
+		return out;
+	}
+	const { starts } = indexSearchLines(content);
+	const seen = new Set<number>();
+	const out: number[] = [];
+	let match = regex.exec(content);
+	while (match !== null) {
+		const lineIndex = findLineIndex(starts, match.index);
+		if (lineIndex >= 0 && !seen.has(lineIndex)) {
+			seen.add(lineIndex);
+			out.push(lineIndex);
+		}
+		if (match[0].length === 0) regex.lastIndex++;
+		match = regex.exec(content);
+	}
+	out.sort((a, b) => a - b);
+	return out;
+}
+
+/**
+ * Native-grep an oversized (>NATIVE_GREP_MAX_FILE_BYTES) line-mode virtual resource
+ * in line-boundary chunks (each <= the cap) so it keeps RE2 dialect parity instead of
+ * the JS fallback. Each chunk's matched line numbers are offset by its starting line
+ * index. A single line larger than the cap can't be native-grepped, so that one line
+ * is JS-tested. Returns sorted 0-based line indexes.
+ */
+async function nativeChunkedLineIndexes(
+	dir: string,
+	resourceIdx: number,
+	content: string,
+	pattern: string,
+	ignoreCase: boolean,
+	signal: AbortSignal | undefined,
+): Promise<number[]> {
+	const rawLines = content.split("\n");
+	if (rawLines.length > 0 && rawLines[rawLines.length - 1] === "") rawLines.pop();
+	const indexes: number[] = [];
+	let chunkStart = 0;
+	let chunkBytes = 0;
+	let chunkLines: string[] = [];
+	let chunkSeq = 0;
+	const flush = async (): Promise<void> => {
+		if (chunkLines.length === 0) return;
+		const scratch = path.resolve(dir, `${resourceIdx}-chunk-${chunkSeq++}`);
+		await writeFile(scratch, chunkLines.join("\n"));
+		const probe = await grep(
+			{
+				pattern,
+				path: scratch,
+				ignoreCase,
+				multiline: false,
+				hidden: true,
+				gitignore: false,
+				maxCount: chunkLines.length,
+				contextBefore: 0,
+				contextAfter: 0,
+				maxColumns: DEFAULT_MAX_COLUMN,
+				mode: GrepOutputMode.Content,
+				signal,
+				timeoutMs: SEARCH_GREP_TIMEOUT_MS,
+			},
+			undefined,
+		);
+		for (const match of probe.matches) indexes.push(chunkStart + match.lineNumber - 1);
+		chunkLines = [];
+		chunkBytes = 0;
+	};
+	let lineRegex: RegExp | undefined;
+	for (let i = 0; i < rawLines.length; i++) {
+		const line = rawLines[i];
+		const lineBytes = Buffer.byteLength(line, "utf8") + 1;
+		if (lineBytes > NATIVE_GREP_MAX_FILE_BYTES) {
+			await flush();
+			if (!lineRegex) {
+				try {
+					lineRegex = new RegExp(pattern, ignoreCase ? "i" : "");
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					throw new ToolError(`Invalid regex: ${message.replace(/^Invalid regular expression:\s*/i, "")}`);
+				}
+			}
+			lineRegex.lastIndex = 0;
+			if (lineRegex.test(line)) indexes.push(i);
+			chunkStart = i + 1;
+			continue;
+		}
+		if (chunkLines.length > 0 && chunkBytes + lineBytes > NATIVE_GREP_MAX_FILE_BYTES) {
+			await flush();
+			chunkStart = i;
+		}
+		if (chunkLines.length === 0) chunkStart = i;
+		chunkLines.push(line);
+		chunkBytes += lineBytes;
+	}
+	await flush();
+	indexes.sort((a, b) => a - b);
+	return indexes;
 }
 
 function makeContextLine(lines: readonly string[], lineIndex: number): { lineNumber: number; line: string } {
@@ -426,70 +589,7 @@ function buildVirtualMatches(
 	return matches;
 }
 
-function compileVirtualRegex(pattern: string, ignoreCase: boolean, multiline: boolean): RegExp {
-	const flags = `${ignoreCase ? "i" : ""}${multiline ? "gm" : ""}`;
-	try {
-		return new RegExp(pattern, flags);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new ToolError(`Invalid regex: ${message.replace(/^Invalid regular expression:\s*/i, "")}`);
-	}
-}
-
-function searchVirtualResourceLines(
-	resource: VirtualSearchResource,
-	regex: RegExp,
-	contextBefore: number,
-	contextAfter: number,
-	maxCount: number,
-): { matches: GrepMatch[]; totalMatches: number; limitReached: boolean } {
-	const lines = splitSearchLines(resource.content);
-	const matchedIndexes: number[] = [];
-
-	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-		const lineNumber = lineIndex + 1;
-		if (!lineAllowed(lineNumber, resource.ranges)) continue;
-		regex.lastIndex = 0;
-		if (!regex.test(lines[lineIndex] ?? "")) continue;
-		matchedIndexes.push(lineIndex);
-	}
-
-	const matches = buildVirtualMatches(resource, lines, matchedIndexes, contextBefore, contextAfter, maxCount);
-	return { matches, totalMatches: matchedIndexes.length, limitReached: matchedIndexes.length > matches.length };
-}
-
-function searchVirtualResourceMultiline(
-	resource: VirtualSearchResource,
-	regex: RegExp,
-	contextBefore: number,
-	contextAfter: number,
-	maxCount: number,
-): { matches: GrepMatch[]; totalMatches: number; limitReached: boolean } {
-	const indexed = indexSearchLines(resource.content);
-	const matchedLines = new Set<number>();
-	const matchedIndexes: number[] = [];
-
-	while (true) {
-		const match = regex.exec(resource.content);
-		if (match === null) break;
-		const lineIndex = findLineIndex(indexed.starts, match.index);
-		if (lineIndex >= 0) {
-			const lineNumber = lineIndex + 1;
-			if (!matchedLines.has(lineNumber) && lineAllowed(lineNumber, resource.ranges)) {
-				matchedLines.add(lineNumber);
-				matchedIndexes.push(lineIndex);
-			}
-		}
-		if (match[0].length === 0) {
-			regex.lastIndex++;
-		}
-	}
-
-	const matches = buildVirtualMatches(resource, indexed.lines, matchedIndexes, contextBefore, contextAfter, maxCount);
-	return { matches, totalMatches: matchedIndexes.length, limitReached: matchedIndexes.length > matches.length };
-}
-
-function searchVirtualResources(
+async function searchVirtualResources(
 	resources: readonly VirtualSearchResource[],
 	pattern: string,
 	ignoreCase: boolean,
@@ -497,29 +597,85 @@ function searchVirtualResources(
 	contextBefore: number,
 	contextAfter: number,
 	maxCount: number,
-): GrepResult {
+	signal?: AbortSignal,
+): Promise<GrepResult> {
 	if (resources.length === 0) {
 		return { matches: [], totalMatches: 0, filesWithMatches: 0, filesSearched: 0, limitReached: false };
 	}
-	const regex = compileVirtualRegex(pattern, ignoreCase, multiline);
 	const matches: GrepMatch[] = [];
 	const filesWithMatches = new Set<string>();
 	let totalMatches = 0;
 	let limitReached = false;
-
-	for (const resource of resources) {
-		const remaining = Math.max(maxCount - matches.length, 0);
-		const resourceResult = multiline
-			? searchVirtualResourceMultiline(resource, regex, contextBefore, contextAfter, remaining)
-			: searchVirtualResourceLines(resource, regex, contextBefore, contextAfter, remaining);
-		if (resourceResult.totalMatches > 0) {
-			filesWithMatches.add(resource.path);
+	// Detect matched line numbers with native grep (RE2) — the SAME matcher local
+	// search uses — so a pattern valid for local grep but not JS `RegExp` (`(?i)x`,
+	// `[[:digit:]]`) behaves identically on virtual/remote resources. The JS helpers
+	// below then rebuild the exact forward-only, range-trimmed context windows the
+	// virtual-search contract requires.
+	const dir = await mkdtemp(path.join(tmpdir(), "omp-search-virtual-"));
+	try {
+		for (let idx = 0; idx < resources.length; idx++) {
+			const resource = resources[idx];
+			const remaining = Math.max(maxCount - matches.length, 0);
+			if (remaining === 0) {
+				limitReached = true;
+				break;
+			}
+			const lines = multiline ? indexSearchLines(resource.content).lines : splitSearchLines(resource.content);
+			let matchedIndexes: number[];
+			if (Buffer.byteLength(resource.content, "utf8") > NATIVE_GREP_MAX_FILE_BYTES) {
+				// Native grep skips files above its 4 MiB cap. Search oversized content in
+				// line-boundary chunks so line-mode keeps RE2 parity; multiline can't be chunked
+				// without missing matches that span a chunk boundary, so it falls back to JS
+				// (dialect-as-JS only for these oversized multiline inputs).
+				matchedIndexes = (
+					multiline
+						? jsMatchedLineIndexes(resource.content, lines, pattern, ignoreCase, true)
+						: await nativeChunkedLineIndexes(dir, idx, resource.content, pattern, ignoreCase, signal)
+				).filter(lineIndex => lineAllowed(lineIndex + 1, resource.ranges));
+			} else {
+				const scratch = path.resolve(dir, `${idx}`);
+				await writeFile(scratch, resource.content);
+				const probe = await grep(
+					{
+						pattern,
+						path: scratch,
+						ignoreCase,
+						multiline,
+						hidden: true,
+						gitignore: false,
+						// A ranged selector must see every match so the range filter below never
+						// drops in-range hits that fall after the cap; matches can't exceed the
+						// line count. Unranged search keeps the overall result cap.
+						maxCount: resource.ranges ? Math.max(lines.length, 1) : INTERNAL_TOTAL_CAP,
+						contextBefore: 0,
+						contextAfter: 0,
+						maxColumns: DEFAULT_MAX_COLUMN,
+						mode: GrepOutputMode.Content,
+						signal,
+						timeoutMs: SEARCH_GREP_TIMEOUT_MS,
+					},
+					undefined,
+				);
+				matchedIndexes = [...new Set(probe.matches.map(match => match.lineNumber - 1))]
+					.filter(lineIndex => lineAllowed(lineIndex + 1, resource.ranges))
+					.sort((a, b) => a - b);
+			}
+			const resourceMatches = buildVirtualMatches(
+				resource,
+				lines,
+				matchedIndexes,
+				contextBefore,
+				contextAfter,
+				remaining,
+			);
+			if (matchedIndexes.length > 0) filesWithMatches.add(resource.path);
+			totalMatches += matchedIndexes.length;
+			limitReached = limitReached || matchedIndexes.length > resourceMatches.length;
+			matches.push(...resourceMatches);
 		}
-		totalMatches += resourceResult.totalMatches;
-		limitReached = limitReached || resourceResult.limitReached;
-		matches.push(...resourceResult.matches);
+	} finally {
+		await rm(dir, { recursive: true, force: true }).catch(() => {});
 	}
-
 	return {
 		matches,
 		totalMatches,
@@ -572,7 +728,7 @@ async function expandVirtualInternalResource(
 }
 
 async function resolveInternalSearchInputs(opts: {
-	pathSpecs: readonly SearchPathSpec[];
+	pathSpecs: readonly GrepPathSpec[];
 	resolvedPaths: string[];
 	cwd: string;
 	settings: unknown;
@@ -594,6 +750,7 @@ async function resolveInternalSearchInputs(opts: {
 		signal: opts.signal,
 		localProtocolOptions: opts.localProtocolOptions,
 		skills: opts.skills,
+		skipDirectoryListing: true,
 	};
 
 	for (let idx = 0; idx < paths.length; idx++) {
@@ -601,10 +758,22 @@ async function resolveInternalSearchInputs(opts: {
 		if (!rawPath || opts.archiveDisplayMap.has(rawPath) || !internalRouter.canHandle(rawPath)) {
 			continue;
 		}
-		if (hasGlobPathChars(rawPath)) {
+		// `ssh://[::1]/path` carries `[`/`]` in the IPv6 authority — glob metacharacters
+		// — so check only the path portion for ssh:// (the SSH handler reads a single
+		// remote file; there is no glob expansion). A glob in the remote path still trips.
+		const globTarget = /^ssh:\/\//i.test(rawPath) ? rawPath.replace(/^ssh:\/\/[^/]*/i, "") : rawPath;
+		if (hasGlobPathChars(globTarget)) {
 			throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
 		}
 		const resource = await internalRouter.resolve(rawPath, context);
+		// A directory listing with no backing local path (e.g. a remote ssh:// dir)
+		// has no real contents to grep — searching its listing text would be
+		// misleading. Local/skill/vault dir resources set `sourcePath` and skip this.
+		if (resource.isDirectory && !resource.sourcePath) {
+			throw new ToolError(
+				`search cannot recurse the directory listing at ${rawPath}; search a specific file under it (e.g. ${rawPath.replace(/\/+$/, "")}/<file>) or read ${rawPath} to list its entries`,
+			);
+		}
 		if (resource.sourcePath) {
 			paths[idx] = resource.sourcePath;
 			if (resource.immutable) {
@@ -634,7 +803,7 @@ async function resolveInternalSearchInputs(opts: {
 	};
 }
 
-export interface SearchToolDetails {
+export interface GrepToolDetails {
 	truncation?: TruncationResult;
 	fileLimitReached?: number;
 	perFileLimitReached?: number;
@@ -666,19 +835,20 @@ export interface SearchToolDetails {
 
 type SearchParams = typeof searchSchema.infer;
 
-export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
-	readonly name = "search";
-	readonly approval = "read" as const;
-	readonly label = "Search";
+export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails> {
+	readonly name = "grep";
+	readonly approval = (args: unknown): ToolTier =>
+		toPathList((args as { paths?: string | string[] }).paths).some(pathTargetsSsh) ? "exec" : "read";
+	readonly label = "Grep";
 	readonly loadMode = "discoverable";
-	readonly summary = "Search file contents using ripgrep (fast text search)";
+	readonly summary = "Grep file contents using ripgrep (fast regex search)";
 	readonly description: string;
 	readonly parameters = searchSchema;
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
 		const displayMode = resolveFileDisplayMode(session);
-		this.description = prompt.render(searchDescription, {
+		this.description = prompt.render(grepDescription, {
 			IS_HL_MODE: displayMode.hashLines,
 			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
 		});
@@ -688,9 +858,9 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 		_toolCallId: string,
 		params: SearchParams,
 		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<SearchToolDetails>,
+		_onUpdate?: AgentToolUpdateCallback<GrepToolDetails>,
 		_toolContext?: AgentToolContext,
-	): Promise<AgentToolResult<SearchToolDetails>> {
+	): Promise<AgentToolResult<GrepToolDetails>> {
 		const { pattern, paths: rawPaths, case: caseSensitive, gitignore, skip } = params;
 
 		return untilAborted(signal, async () => {
@@ -773,8 +943,8 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 							`or pass a UTF-8 text member.`,
 					);
 				}
-				const normalizedContextBefore = this.session.settings.get("search.contextBefore");
-				const normalizedContextAfter = this.session.settings.get("search.contextAfter");
+				const normalizedContextBefore = this.session.settings.get("grep.contextBefore");
+				const normalizedContextAfter = this.session.settings.get("grep.contextAfter");
 				const ignoreCase = !(caseSensitive ?? true);
 				const useGitignore = gitignore ?? true;
 				const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
@@ -952,20 +1122,32 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					}
 					if (err instanceof Error && err.message.includes("Aborted: Timeout")) {
 						throw new ToolError(
-							`Search timed out after ${SEARCH_GREP_TIMEOUT_MS / 1000}s; narrow paths or pattern, or scope with \`find\` first`,
+							`Grep timed out after ${SEARCH_GREP_TIMEOUT_MS / 1000}s; narrow paths or pattern, or scope with \`glob\` first`,
 						);
 					}
 					throw err;
 				}
-				const virtualResult = searchVirtualResources(
-					virtualResources,
-					normalizedPattern,
-					ignoreCase,
-					effectiveMultiline,
-					normalizedContextBefore,
-					normalizedContextAfter,
-					INTERNAL_TOTAL_CAP,
-				);
+				let virtualResult: GrepResult;
+				try {
+					virtualResult = await searchVirtualResources(
+						virtualResources,
+						normalizedPattern,
+						ignoreCase,
+						effectiveMultiline,
+						normalizedContextBefore,
+						normalizedContextAfter,
+						INTERNAL_TOTAL_CAP,
+						signal,
+					);
+				} catch (err) {
+					if (err instanceof Error && /^regex(?: parse)? error/i.test(err.message)) {
+						throw new ToolError(err.message.replace(/^regex(?: parse)? error:?\s*/i, "Invalid regex: "));
+					}
+					if (err instanceof SyntaxError) {
+						throw new ToolError(`Invalid regex: ${err.message}`);
+					}
+					throw err;
+				}
 				result = mergeGrepResults(result, virtualResult, INTERNAL_TOTAL_CAP);
 				if (rangesByAbsPath.size > 0) {
 					const filteredMatches: GrepMatch[] = [];
@@ -1108,7 +1290,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						.filter((s): s is string => Boolean(s))
 						.join("\n") || undefined;
 				if (selectedMatches.length === 0) {
-					const details: SearchToolDetails = {
+					const details: GrepToolDetails = {
 						scopePath,
 						searchPath,
 						cwd: this.session.cwd,
@@ -1245,7 +1427,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				const truncated = Boolean(
 					fileLimitReached || perFileLimitReached || result.limitReached || truncation.truncated || linesTruncated,
 				);
-				const details: SearchToolDetails = {
+				const details: GrepToolDetails = {
 					scopePath,
 					searchPath,
 					cwd: this.session.cwd,
@@ -1282,7 +1464,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 // TUI Renderer
 // =============================================================================
 
-interface SearchRenderArgs {
+interface GrepRenderArgs {
 	pattern: string;
 	paths?: string | string[];
 	case?: boolean;
@@ -1298,7 +1480,7 @@ const EXPANDED_TEXT_LIMIT = PREVIEW_LIMITS.EXPANDED_LINES * 2;
 
 const SEARCH_CODE_FRAME_LINE_RE = /^\s*\*?(\d+)│/;
 
-function searchScopeMeta(details: SearchToolDetails | undefined): string | undefined {
+function searchScopeMeta(details: GrepToolDetails | undefined): string | undefined {
 	if (!details?.scopePath) return undefined;
 	const label = details.searchPath ? fileHyperlink(details.searchPath, details.scopePath) : details.scopePath;
 	return `in ${label}`;
@@ -1446,13 +1628,13 @@ function renderBudgetedSearchGroups(
 	return lines;
 }
 
-function searchStatusIcon(uiTheme: Theme): string {
+function grepStatusIcon(uiTheme: Theme): string {
 	return uiTheme.fg("toolTitle", uiTheme.symbol("icon.search"));
 }
 
-export const searchToolRenderer = {
+export const grepToolRenderer = {
 	inline: true,
-	renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+	renderCall(args: GrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const paths = toPathList(args.paths);
 		const meta: string[] = [];
 		if (paths.length) meta.push(`in ${paths.join(", ")}`);
@@ -1461,17 +1643,17 @@ export const searchToolRenderer = {
 		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);
 
 		const text = renderStatusLine(
-			{ icon: "pending", title: "Search", titleColor: "toolTitle", description: args.pattern || "?", meta },
+			{ icon: "pending", title: "Grep", titleColor: "toolTitle", description: args.pattern || "?", meta },
 			uiTheme,
 		);
 		return new Text(text, 1, 0);
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: SearchToolDetails; isError?: boolean },
+		result: { content: Array<{ type: string; text?: string }>; details?: GrepToolDetails; isError?: boolean },
 		options: RenderResultOptions,
 		uiTheme: Theme,
-		args?: SearchRenderArgs,
+		args?: GrepRenderArgs,
 	): Component {
 		const details = result.details;
 
@@ -1491,8 +1673,8 @@ export const searchToolRenderer = {
 			const description = args?.pattern ?? undefined;
 			const header = renderStatusLine(
 				{
-					iconOverride: searchStatusIcon(uiTheme),
-					title: "Search",
+					iconOverride: grepStatusIcon(uiTheme),
+					title: "Grep",
 					titleColor: "toolTitle",
 					description,
 					meta: [formatCount("item", lines.length)],
@@ -1536,7 +1718,7 @@ export const searchToolRenderer = {
 			const scopeMeta = searchScopeMeta(details);
 			if (scopeMeta) meta.push(scopeMeta);
 			const header = renderStatusLine(
-				{ icon: "warning", title: "Search", titleColor: "toolTitle", description: args?.pattern, meta },
+				{ icon: "warning", title: "Grep", titleColor: "toolTitle", description: args?.pattern, meta },
 				uiTheme,
 			);
 			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
@@ -1552,8 +1734,8 @@ export const searchToolRenderer = {
 		const description = args?.pattern ?? undefined;
 		const header = renderStatusLine(
 			{
-				...(truncated ? { icon: "warning" as const } : { iconOverride: searchStatusIcon(uiTheme) }),
-				title: "Search",
+				...(truncated ? { icon: "warning" as const } : { iconOverride: grepStatusIcon(uiTheme) }),
+				title: "Grep",
 				titleColor: "toolTitle",
 				description,
 				meta,