@kenkaiiii/ggcoder 5.38.0 → 5.39.1

package/dist/tools/grep-recall.test.js

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { createReadStream } from "node:fs";
+import { createGrepTool } from "./grep.js";
+function context() {
+    return { signal: new AbortController().signal, toolCallId: "test" };
+}
+async function makeFixture(files) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "gg-grep-recall-"));
+    for (const [rel, content] of Object.entries(files)) {
+        const abs = path.join(dir, rel);
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        await fs.writeFile(abs, content);
+    }
+    return dir;
+}
+/** Both scanner paths, so recall is asserted for whichever one a host uses. */
+const scanners = [
+    { label: "in-process", useExternalScanner: () => false },
+    { label: "external", useExternalScanner: () => true },
+];
+describe.each(scanners)("grep recall ($label)", ({ useExternalScanner }) => {
+    const grep = (dir) => createGrepTool(dir, undefined, { useExternalScanner });
+    it("searches dot-directories", async () => {
+        const dir = await makeFixture({
+            ".github/workflows/ci.yml": "jobs:\n  build:\n    runs-on: ubuntu-latest\n",
+            "README.md": "no jobs here\n",
+        });
+        const result = await grep(dir).execute({ pattern: "runs-on" }, context());
+        expect(result).toContain(path.join(".github", "workflows", "ci.yml") + ":3:");
+    });
+    it("skips files matched by .gitignore", async () => {
+        const dir = await makeFixture({
+            ".gitignore": "dist/\n*.log\n",
+            "src/app.ts": "export const marker = 1;\n",
+            "dist/app.js": "export const marker = 1;\n",
+            "debug.log": "marker\n",
+        });
+        const result = await grep(dir).execute({ pattern: "marker" }, context());
+        expect(result).toContain(path.join("src", "app.ts") + ":1:");
+        expect(result).not.toContain("dist");
+        expect(result).not.toContain("debug.log");
+    });
+    it("still searches an ignored directory when it is the explicit path", async () => {
+        const dir = await makeFixture({
+            ".gitignore": "dist/\n",
+            "dist/app.js": "export const marker = 1;\n",
+        });
+        const result = await grep(dir).execute({ pattern: "marker", path: "dist" }, context());
+        expect(result).toContain("app.js:1:");
+    });
+    it("never scans node_modules or .git", async () => {
+        const dir = await makeFixture({
+            "node_modules/dep/index.js": "marker\n",
+            ".git/COMMIT_EDITMSG": "marker\n",
+            "src/keep.ts": "marker\n",
+        });
+        const result = await grep(dir).execute({ pattern: "marker" }, context());
+        expect(result).toContain(path.join("src", "keep.ts") + ":1:");
+        expect(result).not.toContain("node_modules");
+        expect(result).not.toContain(".git");
+    });
+});
+describe("grep scan ordering", () => {
+    it("matches a sequential scan over the same candidate list", async () => {
+        const files = {};
+        // Enough files to fill several scan waves, with matches spread across them.
+        for (let i = 0; i < 50; i++) {
+            files[`pkg${String(i).padStart(2, "0")}/mod.ts`] =
+                `line one\nconst marker${i} = ${i};\nmarker tail\n`;
+        }
+        const dir = await makeFixture(files);
+        const parallel = await createGrepTool(dir, undefined, {
+            useExternalScanner: () => false,
+        }).execute({ pattern: "marker", max_results: 500 }, context());
+        const expected = await sequentialScan(dir, /marker/g);
+        expect(String(parallel).split("\n\n")[0]).toBe(expected.join("\n"));
+    });
+});
+/**
+ * Reference implementation: one file at a time, candidates in sorted order.
+ *
+ * fast-glob always yields POSIX-separated paths, while the tool reports
+ * `path.relative` output — native separators, so backslashes on Windows.
+ * Normalizing here keeps this test about ORDER and CONTENT; asserting the raw
+ * glob strings instead silently made it a path-format test that only failed on
+ * Windows.
+ */
+async function sequentialScan(dir, regex) {
+    const fg = await import("fast-glob");
+    const entries = (await fg.default("**/*", { cwd: dir, dot: true, onlyFiles: true, suppressErrors: true }))
+        .sort()
+        .map((entry) => path.normalize(entry));
+    const results = [];
+    for (const entry of entries) {
+        const rl = readline.createInterface({
+            input: createReadStream(path.join(dir, entry), "utf-8"),
+            crlfDelay: Infinity,
+        });
+        let lineNum = 0;
+        for await (const line of rl) {
+            lineNum++;
+            regex.lastIndex = 0;
+            if (regex.test(line))
+                results.push(`${entry}:${lineNum}:${line}`);
+        }
+        rl.close();
+    }
+    return results;
+}
+//# sourceMappingURL=grep-recall.test.js.map

package/dist/tools/grep-recall.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep-recall.test.js","sourceRoot":"","sources":["../../src/tools/grep-recall.test.ts"],"names":[],"mappings":"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"}

package/dist/tools/grep-spawn.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grep-spawn.test.d.ts.map

package/dist/tools/grep-spawn.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep-spawn.test.d.ts","sourceRoot":"","sources":["../../src/tools/grep-spawn.test.ts"],"names":[],"mappings":""}

package/dist/tools/grep-spawn.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const spawnMock = vi.hoisted(() => vi.fn());
+// Importing `spawn` from the mocked module would hand back the mock itself, so
+// delegating to it recurses. Capture the genuine implementation inside the mock
+// factory instead.
+const actualSpawn = vi.hoisted(() => ({ fn: undefined }));
+vi.mock("node:child_process", async () => {
+    const actual = await vi.importActual("node:child_process");
+    actualSpawn.fn = actual.spawn;
+    return { ...actual, spawn: spawnMock };
+});
+const { createGrepTool, detectExternalScanner, resetExternalScannerProbe } = await import("./grep.js");
+function context() {
+    return { signal: new AbortController().signal, toolCallId: "test" };
+}
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gg-grep-spawn-"));
+    await fs.writeFile(path.join(tmpDir, "a.ts"), "const marker = 1;\n");
+    resetExternalScannerProbe();
+    spawnMock.mockReset();
+    // Delegate to the genuine spawn so the tool behaves normally; we only assert
+    // the options it was handed.
+    spawnMock.mockImplementation((...args) => actualSpawn.fn(...args));
+});
+afterEach(async () => {
+    resetExternalScannerProbe();
+    await fs.rm(tmpDir, { recursive: true, force: true });
+});
+describe("grep external scanner spawn options", () => {
+    it("hides the console window when probing for the scanner", async () => {
+        await detectExternalScanner();
+        expect(spawnMock).toHaveBeenCalledWith("rg", ["--version"], expect.objectContaining({ windowsHide: true }));
+    });
+    it("hides the console window when running a search", async () => {
+        const tool = createGrepTool(tmpDir, undefined, { useExternalScanner: () => true });
+        await tool.execute({ pattern: "marker" }, context());
+        const searchCall = spawnMock.mock.calls.find((call) => Array.isArray(call[1]) && !call[1].includes("--version"));
+        // `rg` is optional. When it is absent the in-process path legitimately
+        // never spawns — but assert that is the actual reason, so this test can
+        // never pass merely because the search silently failed to run.
+        if (!searchCall) {
+            expect(await detectExternalScanner()).toBeUndefined();
+            return;
+        }
+        expect(searchCall[2]).toEqual(expect.objectContaining({ windowsHide: true }));
+        expect(searchCall[2]).toEqual(expect.objectContaining({ cwd: tmpDir }));
+    });
+    it("never spawns a scan once the budget is already spent", async () => {
+        const tool = createGrepTool(tmpDir, undefined, {
+            useExternalScanner: () => true,
+            deadlineMs: 0,
+        });
+        const result = String(await tool.execute({ pattern: "marker" }, context()));
+        // The child's budget is floored at 1ms, so spawning here would race the
+        // scanner: whenever the child won, an expired budget still returned real
+        // matches — and only sometimes, which is how it slipped through as a flake.
+        expect(spawnMock).not.toHaveBeenCalled();
+        expect(result).toContain("No matches found.");
+        expect(result).not.toContain("a.ts:1:");
+    });
+});
+//# sourceMappingURL=grep-spawn.test.js.map

package/dist/tools/grep-spawn.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep-spawn.test.js","sourceRoot":"","sources":["../../src/tools/grep-spawn.test.ts"],"names":[],"mappings":"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"}

package/dist/tools/grep.d.ts

@@ -8,8 +8,18 @@ declare const GrepParams: z.ZodObject<{
     max_results: z.ZodOptional<z.ZodNumber>;
     case_insensitive: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-export declare function createGrepTool(cwd: string, ops?: ToolOperations, 
-/** Wall-clock budget for one call. Overridable so tests can trip it without a 5s wait. */
-deadlineMs?: number): AgentTool<typeof GrepParams>;
+export interface GrepToolOptions {
+    /** Wall-clock budget for one call. Overridable so tests can trip it without a 5s wait. */
+    deadlineMs?: number;
+    /**
+     * Whether the external `rg` scanner may be used when it is on PATH. Read
+     * lazily so a settings change takes effect without rebuilding the toolset.
+     */
+    useExternalScanner?: () => boolean;
+}
+export declare function createGrepTool(cwd: string, ops?: ToolOperations, options?: GrepToolOptions): AgentTool<typeof GrepParams>;
+export declare function detectExternalScanner(): Promise<string | undefined>;
+/** Test seam: forget the cached probe result. */
+export declare function resetExternalScannerProbe(): void;
 export {};
 //# sourceMappingURL=grep.d.ts.map

package/dist/tools/grep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../src/tools/grep.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAIrD,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEvE,QAAA,MAAM,UAAU;;;;;;iBAWd,CAAC;AAiHH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,cAAgC;AACrC,0FAA0F;AAC1F,UAAU,GAAE,MAAyB,GACpC,SAAS,CAAC,OAAO,UAAU,CAAC,CA+F9B"}
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../src/tools/grep.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAIrD,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEvE,QAAA,MAAM,UAAU;;;;;;iBAcd,CAAC;AA0HH,MAAM,WAAW,eAAe;IAC9B,0FAA0F;IAC1F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,OAAO,CAAC;CACpC;AAED,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,cAAgC,EACrC,OAAO,GAAE,eAAoB,GAC5B,SAAS,CAAC,OAAO,UAAU,CAAC,CA4F9B;AA6JD,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAgBnE;AAED,iDAAiD;AACjD,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}

package/dist/tools/grep.js

@@ -1,5 +1,6 @@
 import readline from "node:readline";
 import path from "node:path";
+import { spawn } from "node:child_process";
 import { z } from "zod";
 import { sliceHead } from "@kenkaiiii/gg-ai";
 import { resolvePath } from "./path-utils.js";
@@ -8,7 +9,10 @@ import { localOperations } from "./operations.js";
 const GrepParams = z.object({
     pattern: z.string().describe("Search pattern (JavaScript regex; leading (?i) is supported)"),
     path: z.string().optional().describe("File or directory to search (defaults to cwd)"),
-    include: z.string().optional().describe("Glob pattern to filter files (e.g. '*.ts')"),
+    include: z
+        .string()
+        .optional()
+        .describe("Glob pattern to filter files, matched at any depth (e.g. '*.ts')"),
     max_results: z
         .number()
         .int()
@@ -24,6 +28,15 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024;
 const MAX_CANDIDATE_FILES = 10_000;
 /** Wall-clock budget for a single grep call — catastrophic backtracking is count-bounded but not time-bounded */
 const GREP_DEADLINE_MS = 5_000;
+/**
+ * Files scanned concurrently on the in-process path. A grep call is almost
+ * entirely I/O wait, so scanning one file at a time turned "slow" into
+ * "incomplete": the wall-clock budget expired mid-directory and the model saw a
+ * partial answer as if it were the whole one.
+ */
+const SCAN_CONCURRENCY = 12;
+/** Cap on bytes accepted from the external scanner before results are ranked. */
+const MAX_EXTERNAL_OUTPUT_BYTES = 8 * 1024 * 1024;
 /** Long patterns are almost always mistakes and raise the cost of every pathological shape */
 const MAX_PATTERN_LENGTH = 1_000;
 /** Check the clock every N lines inside a file scan — cheap enough to be free, dense enough to bound one bad line */
@@ -118,13 +131,19 @@ function containsQuantifier(body) {
     }
     return false;
 }
-export function createGrepTool(cwd, ops = localOperations, 
-/** Wall-clock budget for one call. Overridable so tests can trip it without a 5s wait. */
-deadlineMs = GREP_DEADLINE_MS) {
+export function createGrepTool(cwd, ops = localOperations, options = {}) {
+    const deadlineMs = options.deadlineMs ?? GREP_DEADLINE_MS;
+    // The external scanner reads the real filesystem, so it is only valid when
+    // this tool is also pointed at the real filesystem. Remote operations
+    // (SSH/Docker) must stay on the in-process path.
+    const externalAllowed = ops === localOperations;
     return {
         name: "grep",
-        description: "Search file contents using regex. Returns filepath:line_number:content for matches. " +
-            "Respects .gitignore. Skips binary files.",
+        description: "Search file contents using regex. Returns filepath:line_number:content for matches, " +
+            "ordered by path. Skips files matched by the search root's .gitignore (pass an explicit " +
+            "`path` inside an ignored directory to search it anyway), skips binary files, and searches " +
+            "dot-directories. " +
+            "Lookaround and backreferences are supported but scan more slowly.",
         parameters: GrepParams,
         async execute({ pattern, path: searchPath, include, max_results, case_insensitive }) {
             const dir = searchPath ? resolvePath(cwd, searchPath) : cwd;
@@ -158,46 +177,327 @@ deadlineMs = GREP_DEADLINE_MS) {
                 const results = await searchFile(dir, regex, cwd, maxResults, ops, deadline);
                 return formatResults(results, maxResults, false, deadline.hit, deadlineMs);
             }
-            // Enumerate files
-            const fg = await import("fast-glob");
-            // Backslashes are picomatch ESCAPES, not separators: a Windows-shaped
-            // `include` (e.g. `src\**\*.ts`) would match nothing.
-            const globPattern = (include ?? "**/*").replace(/\\/g, "/");
-            const entries = await fg.default(globPattern, {
-                cwd: dir,
-                dot: false,
-                onlyFiles: true,
-                ignore: ["**/node_modules/**", "**/.git/**"],
-                suppressErrors: true,
-                followSymbolicLinks: false,
-                objectMode: true,
-                stats: false,
-            });
-            const results = [];
-            let scannedCandidates = 0;
-            let candidateLimitHit = false;
-            for (const item of entries) {
-                if (results.length >= maxResults)
-                    break;
-                if (isExpired(deadline))
-                    break;
-                if (scannedCandidates >= MAX_CANDIDATE_FILES) {
-                    candidateLimitHit = true;
-                    break;
+            // An already-spent budget must not start a scan it cannot honour.
+            // `runExternalScan` floors the child's budget at 1ms, so without this
+            // guard an expired deadline still races ripgrep and returns real matches
+            // whenever the child wins — reporting results the caller's budget had
+            // already ruled out, and non-deterministically at that. The in-process
+            // path below reports the expiry directly instead.
+            const useExternal = externalAllowed &&
+                !isExpired(deadline) &&
+                (options.useExternalScanner?.() ?? true) &&
+                isExternallySupported(normalizedPattern) &&
+                (await detectExternalScanner()) !== undefined;
+            if (useExternal) {
+                const external = await runExternalScan({
+                    dir,
+                    cwd,
+                    pattern: normalizedPattern,
+                    include,
+                    caseInsensitive: flags.includes("i"),
+                    maxResults,
+                    deadline,
+                    deadlineMs,
+                });
+                // A scanner failure is a tooling problem, not a search result — retry
+                // the query in-process rather than reporting a false "no matches".
+                if (external) {
+                    return formatResults(external, maxResults, false, deadline.hit, deadlineMs);
                 }
-                scannedCandidates += 1;
-                const entry = typeof item === "string" ? item : item.path;
-                const ext = path.extname(entry).toLowerCase();
-                if (BINARY_EXTENSIONS.has(ext))
-                    continue;
-                const filePath = path.join(dir, entry);
-                const fileResults = await searchFile(filePath, regex, cwd, maxResults - results.length, ops, deadline);
-                results.push(...fileResults);
             }
+            const { files, candidateLimitHit } = await enumerateCandidates(dir, include);
+            const results = await scanFiles(files, dir, regex, cwd, maxResults, ops, deadline);
             return formatResults(results, maxResults, candidateLimitHit, deadline.hit, deadlineMs);
         },
     };
 }
+/**
+ * Build the candidate file list for one directory scan.
+ *
+ * Two recall fixes live here. Dot-entries are included, because `.github/`,
+ * `.changeset/` and similar directories hold real, searchable project files.
+ * And `.gitignore` is applied for real (it previously was not, despite being
+ * advertised), so build output and vendored trees stop crowding out source.
+ * An explicit `path` INTO an ignored directory still searches it: the ignore
+ * file is read relative to the scan root, so scoping past it is the escape
+ * hatch.
+ *
+ * The list is sorted so results are deterministic and byte-comparable across
+ * scanners; the parallel scan below relies on that order too.
+ */
+async function enumerateCandidates(dir, include) {
+    const fg = await import("fast-glob");
+    const ignoreModule = await import("ignore");
+    const ig = ignoreModule.default();
+    ig.add(await loadIgnorePatterns(dir));
+    const globPattern = normalizeIncludeGlob(include);
+    const entries = await fg.default(globPattern, {
+        cwd: dir,
+        dot: true,
+        onlyFiles: true,
+        ignore: ["**/node_modules/**", "**/.git/**"],
+        suppressErrors: true,
+        followSymbolicLinks: false,
+    });
+    const kept = entries
+        .filter((entry) => !BINARY_EXTENSIONS.has(path.extname(entry).toLowerCase()))
+        .filter((entry) => !ig.ignores(entry))
+        .sort();
+    return {
+        files: kept.slice(0, MAX_CANDIDATE_FILES),
+        candidateLimitHit: kept.length > MAX_CANDIDATE_FILES,
+    };
+}
+/**
+ * Normalize an `include` glob to gitignore-style semantics: a bare pattern
+ * with no separator matches at any depth. Models write `*.ts` meaning "every
+ * TypeScript file", and a root-only interpretation silently returned nothing
+ * for any project that keeps its sources in a subdirectory.
+ */
+function normalizeIncludeGlob(include) {
+    // Backslashes are picomatch ESCAPES, not separators: a Windows-shaped
+    // `include` (e.g. `src\**\*.ts`) would match nothing.
+    const normalized = (include ?? "**/*").replace(/\\/g, "/");
+    return normalized.includes("/") ? normalized : `**/${normalized}`;
+}
+async function fileExists(filePath) {
+    try {
+        const fs = await import("node:fs/promises");
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function loadIgnorePatterns(dir) {
+    try {
+        const fs = await import("node:fs/promises");
+        const content = await fs.readFile(path.join(dir, ".gitignore"), "utf-8");
+        return content
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith("#"));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Scan candidates with a bounded worker pool, emitting results in candidate
+ * order regardless of completion order: each file writes into its own slot and
+ * the slots are flattened at the end. Ordering is therefore identical to a
+ * sequential scan over the same list.
+ *
+ * Scheduling stops as soon as enough matches exist. Because candidates are in
+ * sorted order and every scheduled index precedes every unscheduled one, the
+ * first `maxResults` entries of the flattened array are exactly the ones a
+ * sequential scan would have produced before stopping.
+ */
+async function scanFiles(files, dir, regex, cwd, maxResults, ops, deadline) {
+    const slots = new Array(files.length).fill(undefined).map(() => []);
+    let next = 0;
+    let collected = 0;
+    const worker = async () => {
+        for (;;) {
+            if (collected >= maxResults || isExpired(deadline))
+                return;
+            const index = next++;
+            if (index >= files.length)
+                return;
+            // Each worker owns a private RegExp: `lastIndex` on a shared global regex
+            // is mutated during `test`, so concurrent scans would corrupt each other.
+            const own = new RegExp(regex.source, regex.flags);
+            const fileResults = await searchFile(path.join(dir, files[index]), own, cwd, maxResults, ops, deadline);
+            slots[index] = fileResults;
+            collected += fileResults.length;
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(SCAN_CONCURRENCY, files.length || 1) }, () => worker()));
+    const results = [];
+    for (const slot of slots) {
+        for (const line of slot) {
+            results.push(line);
+            if (results.length >= maxResults)
+                return results;
+        }
+    }
+    return results;
+}
+/**
+ * Constructs the external scanner's regex engine cannot execute. It uses a
+ * finite-automaton engine with linear-time guarantees, which is exactly why it
+ * is fast — and exactly why lookaround and backreferences are missing. Those
+ * patterns fall back to the in-process backtracking scanner, which is the
+ * semantic reference for this tool.
+ */
+const EXTERNALLY_UNSUPPORTED = /\(\?=|\(\?!|\(\?</;
+const BACKREFERENCE = /\\[1-9]/;
+function isExternallySupported(pattern) {
+    return !EXTERNALLY_UNSUPPORTED.test(pattern) && !BACKREFERENCE.test(pattern);
+}
+/** Resolved once per process: probing costs a spawn, and the answer cannot change. */
+let externalScannerProbe;
+export function detectExternalScanner() {
+    externalScannerProbe ??= new Promise((resolve) => {
+        let child;
+        try {
+            // windowsHide: a bare spawn pops a console window on Windows. `grep` is
+            // one of the most-called tools, so without it a search session strobes
+            // the user's screen. No-op on other platforms.
+            child = spawn("rg", ["--version"], { stdio: "ignore", windowsHide: true });
+        }
+        catch {
+            resolve(undefined);
+            return;
+        }
+        child.once("error", () => resolve(undefined));
+        child.once("close", (code) => resolve(code === 0 ? "rg" : undefined));
+    });
+    return externalScannerProbe;
+}
+/** Test seam: forget the cached probe result. */
+export function resetExternalScannerProbe() {
+    externalScannerProbe = undefined;
+}
+/**
+ * Run the external scanner and format its output exactly like the in-process
+ * path: same relative paths, same line truncation, same path ordering.
+ *
+ * Returns `undefined` when the scanner could not complete, which makes the
+ * caller retry in-process. Reporting "no matches" for a spawn failure would be
+ * a silent recall loss — the failure mode this whole path exists to remove.
+ */
+async function runExternalScan(req) {
+    const args = [
+        "--no-config",
+        "--line-number",
+        "--no-heading",
+        "--with-filename",
+        "--color",
+        "never",
+        "--no-messages",
+        "--hidden",
+        // Apply exactly one ignore file — the scan root's .gitignore, wired in
+        // below — and nothing else: no nested, parent, global, or non-VCS ignore
+        // files. The in-process scanner is this tool's semantic reference and it
+        // reads that one file; anything wider would make the two paths disagree
+        // about which files exist.
+        "--no-ignore",
+        "--max-filesize",
+        String(MAX_FILE_SIZE),
+        "--max-count",
+        String(req.maxResults),
+        "--glob",
+        "!**/.git/**",
+        "--glob",
+        "!**/node_modules/**",
+    ];
+    const rootIgnore = path.join(req.dir, ".gitignore");
+    if (await fileExists(rootIgnore))
+        args.push("--ignore-file", rootIgnore);
+    if (req.caseInsensitive)
+        args.push("--ignore-case");
+    if (req.include)
+        args.push("--glob", req.include.replace(/\\/g, "/"));
+    // Relative root on purpose — `formatExternalMatches` parses `path:line:text`
+    // by first colon, which an absolute Windows path would break.
+    args.push("--regexp", req.pattern, "--", ".");
+    const remainingMs = Math.max(1, req.deadline.expiresAt - Date.now());
+    const output = await new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn("rg", args, { cwd: req.dir, windowsHide: true });
+        }
+        catch {
+            resolve(undefined);
+            return;
+        }
+        let stdout = "";
+        let bytes = 0;
+        let timedOut = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+        }, remainingMs);
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        child.stdout?.setEncoding("utf-8");
+        child.stdout?.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > MAX_EXTERNAL_OUTPUT_BYTES) {
+                child.kill("SIGKILL");
+                return;
+            }
+            stdout += chunk;
+        });
+        child.stderr?.resume();
+        child.once("error", () => finish(undefined));
+        // Exit 0 = matches, 1 = no matches. Anything else is a real failure.
+        child.once("close", (code) => finish({ stdout, ok: code === 0 || code === 1, timedOut }));
+    });
+    if (!output)
+        return undefined;
+    if (output.timedOut)
+        req.deadline.hit = true;
+    else if (!output.ok)
+        return undefined;
+    return formatExternalMatches(output.stdout, req);
+}
+/**
+ * Parse `path:line:text` records into this tool's output shape. The scanner
+ * emits paths relative to the scan root, so they are re-based onto the tool's
+ * cwd and re-sorted into candidate order before truncation.
+ */
+function formatExternalMatches(stdout, req) {
+    const byPath = new Map();
+    for (const raw of stdout.split("\n")) {
+        if (!raw)
+            continue;
+        // Splitting on the first colon is only safe because the scan is rooted at a
+        // RELATIVE path (see the `.` argument above), so no Windows drive prefix
+        // ("C:\") can appear here. Keep it that way: the guards below fail CLOSED,
+        // so a misparsed line number drops the match silently — the exact
+        // "silence looks like no results" failure this scanner exists to avoid.
+        const firstSep = raw.indexOf(":");
+        if (firstSep <= 0)
+            continue;
+        const secondSep = raw.indexOf(":", firstSep + 1);
+        if (secondSep < 0)
+            continue;
+        const lineNum = raw.slice(firstSep + 1, secondSep);
+        if (!/^\d+$/.test(lineNum))
+            continue;
+        const scanRelative = raw.slice(0, firstSep).replace(/^\.[\\/]/, "");
+        if (BINARY_EXTENSIONS.has(path.extname(scanRelative).toLowerCase()))
+            continue;
+        const text = raw.slice(secondSep + 1).replace(/\r$/, "");
+        const relPath = path.relative(req.cwd, path.join(req.dir, scanRelative));
+        const truncated = text.length > MAX_LINE_LENGTH ? sliceHead(text, MAX_LINE_LENGTH) + "…" : text;
+        const key = scanRelative.replace(/\\/g, "/");
+        const bucket = byPath.get(key);
+        const formatted = `${relPath}:${lineNum}:${truncated}`;
+        if (bucket)
+            bucket.push(formatted);
+        else
+            byPath.set(key, [formatted]);
+    }
+    const results = [];
+    for (const key of [...byPath.keys()].sort()) {
+        for (const line of byPath.get(key)) {
+            results.push(line);
+            if (results.length >= req.maxResults)
+                return results;
+        }
+    }
+    return results;
+}
 async function searchFile(filePath, regex, cwd, maxResults, ops, deadline) {
     const results = [];
     const relPath = path.relative(cwd, filePath);