@herbertgao/pi-extensions 2026.8.3 → 2026.8.5

package/node_modules/pi-lens/dist/clients/security-scan-client.js

@@ -12,6 +12,7 @@
  *
  * Refs: #130, #131, #132
  */
+import { createSubsystemLogger } from "./extension-log.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 export class SecurityScanClient {
     toolName;
@@ -27,7 +28,7 @@ export class SecurityScanClient {
     constructor(toolName, verbose = false) {
         this.toolName = toolName;
         this.log = verbose
-            ? (msg) => console.error(`[${toolName}] ${msg}`)
+            ? createSubsystemLogger(toolName)
             : () => { };
     }
     /**

package/node_modules/pi-lens/dist/clients/session-state-store.js

@@ -13,7 +13,7 @@ import * as path from "node:path";
 import { writeFileAtomicAsync } from "./atomic-write.js";
 import { getProjectDataDir } from "./file-utils.js";
 import { readJsonCacheAsync } from "./json-cache-read.js";
-const STATE_VERSION = 1;
+export const STATE_VERSION = 1;
 export function sessionStartMode(reason, hasPendingForkSnapshot) {
     if (reason === "fork" && hasPendingForkSnapshot)
         return "fork";
@@ -52,7 +52,8 @@ export async function saveSessionState(cwd, sessionId, widget, readGuard) {
         // bestEffort (default): a failed write/rename just means this snapshot is
         // lost, matching this store's documented "start clean" fallback — never
         // throw for the caller. (Tmp naming is now the shared
-        // `${target}.tmp-${pid}` shape rather than this site's former
+        // `${target}.tmp-${pid}-${seq}` shape (unique per call, not just per process,
+        // since #1205) rather than this site's former
         // `${file}.${pid}.tmp` — no behavioral difference: nothing reads the
         // intermediate tmp filename.)
         await writeFileAtomicAsync(file, JSON.stringify(payload));

package/node_modules/pi-lens/dist/clients/sg-runner.js

@@ -4,25 +4,14 @@
  * Extracted from AstGrepClient to simplify the main client.
  * Handles: spawn, spawnSync, temp dir management, JSON parsing.
  */
-import { spawn } from "node:child_process";
+import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getSgCommand } from "./dispatch/runners/utils/runner-helpers.js";
+import { getSgCommand, resolveManagedToolClient, } from "./dispatch/runners/utils/runner-helpers.js";
 import { getProjectIgnoreGlobs } from "./file-utils.js";
 import { findGlobalBinary } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
-/**
- * Escape an argument for Windows cmd.exe shell execution.
- * Handles spaces, quotes, and special characters.
- */
-function escapeWindowsArg(arg) {
-    // If no special characters, return as-is
-    if (!/[\s"]/.test(arg))
-        return arg;
-    // Escape quotes by doubling them
-    return `"${arg.replace(/"/g, '""')}"`;
-}
 /**
  * Build the `bash -c` argv that runs `cmd` with `allArgs` as POSITIONAL
  * parameters. The script is the constant `"$0" "$@"`, so bash re-emits the
@@ -43,6 +32,8 @@ function sgExcludeArgsForProject(rootDir) {
         `!${glob}`,
     ]);
 }
+const DEFAULT_EXEC_TIMEOUT_MS = 30_000;
+const MAX_SG_OUTPUT_BYTES = 8 * 1024 * 1024;
 /**
  * Format metavariable captures for display below a match line.
  * Single captures: $VAR=x  $NAME=foo
@@ -72,6 +63,33 @@ function formatMetaVarCaptures(mv) {
         return undefined;
     return `  ${parts.join("  ")}`;
 }
+/**
+ * Parse ast-grep `--json` stdout into a match array, or return `null` when the
+ * text is not a match payload. ast-grep emits either a JSON array or (rarely) a
+ * single object; both are normalized to an array. A JSON scalar/`null` is
+ * rejected (returns `null`) so a hypothetical error-report scalar on stdout can
+ * never be misread as a phantom match.
+ */
+function tryParseSgMatches(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed !== null && typeof parsed === "object")
+            return [parsed];
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function tryParseNonZeroSgMatches(result) {
+    if (result.outputTruncated || !result.stdout.trim())
+        return null;
+    // Trimmed on purpose: a leading BOM survives JSON.parse's whitespace
+    // tolerance but String.trim() strips it (matches the pre-refactor guard).
+    return tryParseSgMatches(result.stdout.trim());
+}
 export class SgRunner {
     log;
     sgPath = null;
@@ -80,7 +98,7 @@ export class SgRunner {
     ensureInFlight = null;
     constructor(verbose = false) {
         this.log = verbose
-            ? (msg) => console.error(`[sg-runner] ${msg}`)
+            ? createSubsystemLogger("sg-runner")
             : () => { };
     }
     /**
@@ -156,15 +174,19 @@ export class SgRunner {
                 return true;
             }
         }
-        // Step 4: auto-install via pi-lens installer.
-        this.log("ast-grep not found, attempting auto-install...");
-        const { ensureTool } = await import("./installer/index.js");
-        const installedPath = await ensureTool("ast-grep");
-        if (installedPath && (await this.probeCommand(installedPath, []))) {
-            this.sgPath = installedPath;
+        // Step 4: install via the typed shared seam, then validate the returned
+        // absolute binary before publishing it.
+        const installed = await resolveManagedToolClient({
+            toolId: "ast-grep",
+            cwd: process.cwd(),
+            probe: async () => ({ outcome: "missing" }),
+            acceptInstalled: async (installedPath) => (await this.probeCommand(installedPath, [])) ? installedPath : null,
+        });
+        if (installed.outcome === "success") {
+            this.sgPath = installed.value;
             this.sgArgsPrefix = [];
             this.available = true;
-            this.log(`ast-grep auto-installed: ${installedPath}`);
+            this.log(`ast-grep auto-installed: ${installed.value}`);
             return true;
         }
         this.available = false;
@@ -206,7 +228,8 @@ export class SgRunner {
             for (const root of searchRoots) {
                 const candidate = path.join(root, pkgName, exeName);
                 try {
-                    if (fs.existsSync(candidate) && (await this.probeCommand(candidate, []))) {
+                    if (fs.existsSync(candidate) &&
+                        (await this.probeCommand(candidate, []))) {
                         return candidate;
                     }
                 }
@@ -233,7 +256,8 @@ export class SgRunner {
                 return undefined;
             for (const name of ["ast-grep", "sg"]) {
                 const candidate = path.join(prefix, "bin", name);
-                if (fs.existsSync(candidate) && (await this.probeCommand(candidate, []))) {
+                if (fs.existsSync(candidate) &&
+                    (await this.probeCommand(candidate, []))) {
                     return candidate;
                 }
             }
@@ -271,147 +295,140 @@ export class SgRunner {
             argsPrefix: this.sgArgsPrefix,
         };
     }
-    async execRaw(args, timeout = 30000) {
+    failureForSpawnResult(result) {
+        if (result.failure === "aborted")
+            return "aborted";
+        switch (result.spawnFailure?.kind) {
+            case "tool-not-found":
+                return "unavailable";
+            case "timeout":
+                return "timeout";
+            case "killed":
+                return result.failure === "aborted" ? "aborted" : "cli-failure";
+            case "cwd-unresolvable":
+            case "permission-denied":
+            case "spawn-failed":
+            case undefined:
+                return result.error ? "cli-failure" : undefined;
+        }
+    }
+    formatPatternError(stderr, args) {
+        if (stderr.includes("Multiple AST nodes are detected")) {
+            return (`Invalid AST pattern: The pattern appears to contain multiple AST nodes or is malformed.\n` +
+                `Common causes:\n` +
+                `  1. Missing parentheses: use it($TEST) not it"test"\n` +
+                `  2. Raw text without structure: use console.log($MSG) not just "console.log"\n` +
+                `  3. Unclosed quotes or brackets\n\n` +
+                `Original error: ${stderr}`);
+        }
+        if (stderr.includes("Cannot parse query")) {
+            return (`Pattern syntax error: The pattern could not be parsed as valid code.\n` +
+                `Tips:\n` +
+                `  - Patterns must be valid ${args.includes("--lang") ? args[args.indexOf("--lang") + 1] : "language"} syntax\n` +
+                `  - Use metavariables like $NAME, $ARGS for variable parts\n` +
+                `  - Example: 'function $NAME($$$PARAMS) { $$$BODY }'\n\n` +
+                `Original error: ${stderr}`);
+        }
+        return stderr;
+    }
+    async execRaw(args, timeout = DEFAULT_EXEC_TIMEOUT_MS, options = {}) {
         const command = this.getSgCommand();
-        const result = await safeSpawnAsync(command.cmd, [...command.argsPrefix, ...args], { timeout });
+        const result = await safeSpawnAsync(command.cmd, [...command.argsPrefix, ...args], {
+            timeout,
+            deadlineAt: options.deadlineAt,
+            signal: options.signal,
+            maxOutputBytes: MAX_SG_OUTPUT_BYTES,
+        });
+        const failure = this.failureForSpawnResult(result);
         return {
             stdout: result.stdout,
             stderr: result.stderr,
             status: result.status,
             error: result.error?.message,
+            failure,
+            ...(result.outputTruncated ? { outputTruncated: true } : {}),
         };
     }
     /**
-     * Run ast-grep asynchronously, return parsed matches
+     * Run ast-grep asynchronously, return parsed matches. The Windows Git
+     * Bash/MSYS path deliberately remains positional-argument based, but the
+     * child itself now goes through safeSpawnAsync so cancellation, deadlines,
+     * tree-kill, and output caps are shared with every other CLI runner.
      */
-    async exec(args) {
-        return new Promise((resolve) => {
-            const command = this.getSgCommand();
-            const allArgs = [...command.argsPrefix, ...args];
-            // On Windows with Git Bash/MSYS2, we need to use bash to properly
-            // handle $variables in patterns (prevent shell expansion)
-            const isWindows = process.platform === "win32";
-            const hasBash = process.env.MSYSTEM || process.env.GIT_SHELL;
-            const empty = () => ({
-                matches: [],
-                totalMatches: 0,
-                truncated: false,
-            });
-            let proc;
-            try {
-                if (isWindows && hasBash) {
-                    // Run via bash (Git Bash/MSYS2) so $-metavariables in ast-grep
-                    // patterns aren't shell-expanded. Pass the command + args as
-                    // POSITIONAL parameters (`"$0"`/`"$@"`) instead of interpolating
-                    // them into the -c string: bash re-emits `"$@"` verbatim — no
-                    // parameter expansion, no word-splitting — so patterns stay literal
-                    // AND an environment-derived command path cannot inject shell
-                    // (fixes CodeQL js/shell-command-injection-from-environment). This
-                    // also removes the brittle hand-rolled quoting it replaced.
-                    proc = spawn("bash", buildBashRunArgs(command.cmd, allArgs), {
-                        stdio: ["ignore", "pipe", "pipe"],
-                        windowsHide: true,
-                    });
-                }
-                else if (isWindows) {
-                    // Fallback: shell:true needed for npm-installed .cmd wrappers on Windows.
-                    // Pass cmd and args separately — do not concatenate into one string.
-                    proc = spawn(command.cmd, allArgs.map(escapeWindowsArg), {
-                        stdio: ["ignore", "pipe", "pipe"],
-                        shell: true,
-                        windowsHide: true,
-                    });
-                }
-                else {
-                    // Unix: normal spawn without shell
-                    proc = spawn(command.cmd, allArgs, {
-                        stdio: ["ignore", "pipe", "pipe"],
-                    });
-                }
-            }
-            catch (err) {
-                // A SYNCHRONOUS spawn throw (Windows `spawn UNKNOWN`/EINVAL — the
-                // pidusage bug class, #533) would reject this Promise; `exec` is
-                // contracted to always resolve (callers read `error`, never catch),
-                // so resolve gracefully instead of letting it escape as an
-                // unhandledRejection. Async spawn `'error'` events are already
-                // handled by the `proc.on("error", ...)` listener below.
-                resolve({
-                    ...empty(),
-                    error: err instanceof Error ? err.message : String(err),
-                });
-                return;
-            }
-            let stdout = "";
-            let stderr = "";
-            proc.stdout?.on("data", (data) => (stdout += data.toString()));
-            proc.stderr?.on("data", (data) => (stderr += data.toString()));
-            proc.on("error", (err) => {
-                if (err.message.includes("ENOENT")) {
-                    resolve({
-                        ...empty(),
-                        error: "ast-grep CLI not found. Install: npm i -D @ast-grep/cli",
-                    });
-                }
-                else {
-                    resolve({ ...empty(), error: err.message });
-                }
-            });
-            proc.on("close", (code) => {
-                if (code !== 0 && !stdout.trim()) {
-                    const stderrMsg = stderr.trim();
-                    if (code === 1 && !stderrMsg) {
-                        resolve(empty());
-                        return;
-                    }
-                    if (stderrMsg.includes("Multiple AST nodes are detected")) {
-                        resolve({
-                            ...empty(),
-                            error: `Invalid AST pattern: The pattern appears to contain multiple AST nodes or is malformed.\n` +
-                                `Common causes:\n` +
-                                `  1. Missing parentheses: use it($TEST) not it"test"\n` +
-                                `  2. Raw text without structure: use console.log($MSG) not just "console.log"\n` +
-                                `  3. Unclosed quotes or brackets\n\n` +
-                                `Original error: ${stderrMsg}`,
-                        });
-                        return;
-                    }
-                    if (stderrMsg.includes("Cannot parse query")) {
-                        resolve({
-                            ...empty(),
-                            error: `Pattern syntax error: The pattern could not be parsed as valid code.\n` +
-                                `Tips:\n` +
-                                `  - Patterns must be valid ${args.includes("--lang") ? args[args.indexOf("--lang") + 1] : "language"} syntax\n` +
-                                `  - Use metavariables like $NAME, $ARGS for variable parts\n` +
-                                `  - Example: 'function $NAME($$$PARAMS) { $$$BODY }'\n\n` +
-                                `Original error: ${stderrMsg}`,
-                        });
-                        return;
-                    }
-                    resolve({
-                        ...empty(),
-                        error: stderrMsg || `Command failed with exit code ${code}`,
-                    });
-                    return;
-                }
-                if (!stdout.trim()) {
-                    resolve(empty());
-                    return;
-                }
-                try {
-                    const parsed = JSON.parse(stdout);
-                    const matches = Array.isArray(parsed) ? parsed : [parsed];
-                    resolve({
+    async exec(args, options = {}) {
+        const command = this.getSgCommand();
+        const allArgs = [...command.argsPrefix, ...args];
+        const isWindows = process.platform === "win32";
+        const hasBash = Boolean(process.env.MSYSTEM || process.env.GIT_SHELL);
+        const useBash = isWindows && hasBash;
+        const result = await safeSpawnAsync(useBash ? "bash" : command.cmd, useBash ? buildBashRunArgs(command.cmd, allArgs) : allArgs, {
+            timeout: DEFAULT_EXEC_TIMEOUT_MS,
+            deadlineAt: options.deadlineAt,
+            signal: options.signal,
+            maxOutputBytes: MAX_SG_OUTPUT_BYTES,
+        });
+        const empty = () => ({
+            matches: [],
+            totalMatches: 0,
+            truncated: false,
+        });
+        const spawnFailure = this.failureForSpawnResult(result);
+        if (spawnFailure) {
+            return {
+                ...empty(),
+                error: spawnFailure === "unavailable"
+                    ? "ast-grep CLI not found. Install: npm i -D @ast-grep/cli"
+                    : result.error?.message || "ast-grep CLI failed to start",
+            };
+        }
+        if (result.status !== 0) {
+            const stdout = result.stdout.trim();
+            const stderr = result.stderr.trim();
+            // ast-grep's linter-style contract: a rule with `severity: error`
+            // that MATCHES exits 1 with valid JSON matches on stdout (stderr
+            // carries "Scan succeeded and found error level diagnostics"). An
+            // exit code that means "scan succeeded with findings" must never be
+            // classified as a CLI failure — parse the matches. Only fall through
+            // to failure when the JSON isn't parseable (a real diagnostic).
+            if (result.status === 1 && stdout) {
+                const matches = tryParseNonZeroSgMatches(result);
+                if (matches) {
+                    return {
                         matches,
                         totalMatches: matches.length,
                         truncated: false,
-                    });
-                }
-                catch {
-                    resolve({ ...empty(), error: "Failed to parse output" });
+                    };
                 }
-            });
-        });
+            }
+            // ast-grep uses status 1 with no output for a genuine no-match in
+            // some CLI versions. Preserve that historical empty-result behavior;
+            // any stderr (including an invalid kind/YAML diagnostic) is a failure.
+            if (result.status === 1 && !stdout && !stderr)
+                return empty();
+            return {
+                ...empty(),
+                error: this.formatPatternError(stderr || `Command failed with exit code ${result.status}`, args),
+            };
+        }
+        if (!result.stdout.trim())
+            return empty();
+        if (result.outputTruncated) {
+            return {
+                ...empty(),
+                error: "Failed to parse output: output was truncated",
+            };
+        }
+        {
+            const matches = tryParseSgMatches(result.stdout);
+            if (matches) {
+                return {
+                    matches,
+                    totalMatches: matches.length,
+                    truncated: false,
+                };
+            }
+            return { ...empty(), error: "Failed to parse output" };
+        }
     }
     // --- Shared helpers for temp-dir rule scans ---
     prepareTempScan(ruleId, ruleYaml) {
@@ -423,12 +440,6 @@ export class SgRunner {
         fs.writeFileSync(path.join(rulesSubdir, `${ruleId}.yml`), ruleYaml);
         return { sessionDir, configFile };
     }
-    parseScanOutput(output) {
-        if (!output.trim())
-            return [];
-        const items = JSON.parse(output);
-        return Array.isArray(items) ? items : [items];
-    }
     cleanupTempScan(sessionDir) {
         try {
             fs.rmSync(sessionDir, { recursive: true, force: true });
@@ -437,7 +448,67 @@ export class SgRunner {
             this.log(`Cleanup failed: ${err.message}`);
         }
     }
-    async tempScanAsync(dir, ruleId, ruleYaml, timeout = 30000) {
+    interpretScanResult(result, args) {
+        const failure = this.failureForSpawnResult(result);
+        if (failure) {
+            return {
+                matches: [],
+                status: result.status,
+                error: result.error?.message || "ast-grep CLI failed to start",
+                failure,
+            };
+        }
+        if (result.status !== 0) {
+            const stdout = result.stdout.trim();
+            const stderr = result.stderr.trim();
+            // ast-grep's linter-style contract: a rule with `severity: error`
+            // that MATCHES exits 1 with valid JSON matches on stdout (stderr
+            // carries "Scan succeeded and found error level diagnostics"). An
+            // exit code that means "scan succeeded with findings" must never be
+            // classified as a CLI failure — parse the matches. Only fall through
+            // to failure when the JSON isn't parseable (a real diagnostic).
+            if (result.status === 1 && stdout) {
+                const matches = tryParseNonZeroSgMatches(result);
+                if (matches) {
+                    return { matches, status: result.status };
+                }
+            }
+            // Preserve ast-grep's status-1/no-output no-match convention. A
+            // diagnostic on stderr is never treated as a no-match.
+            if (result.status === 1 && !stdout && !stderr) {
+                return { matches: [], status: result.status };
+            }
+            return {
+                matches: [],
+                status: result.status,
+                error: this.formatPatternError(stderr || `ast-grep scan failed with exit code ${result.status}`, args),
+                failure: "cli-failure",
+            };
+        }
+        if (!result.stdout.trim())
+            return { matches: [], status: result.status };
+        if (result.outputTruncated) {
+            return {
+                matches: [],
+                status: result.status,
+                error: "Failed to parse ast-grep scan output: output was truncated",
+                failure: "parse-failure",
+            };
+        }
+        {
+            const matches = tryParseSgMatches(result.stdout);
+            if (matches) {
+                return { matches, status: result.status };
+            }
+            return {
+                matches: [],
+                status: result.status,
+                error: "Failed to parse ast-grep scan output: invalid JSON",
+                failure: "parse-failure",
+            };
+        }
+    }
+    async tempScanDetailedAsync(dir, ruleId, ruleYaml, timeout = DEFAULT_EXEC_TIMEOUT_MS, options = {}) {
         const { sessionDir, configFile } = this.prepareTempScan(ruleId, ruleYaml);
         try {
             const { cmd: sgCmd, args: sgPre } = getSgCommand();
@@ -449,42 +520,81 @@ export class SgRunner {
                 "--json",
                 ...sgExcludeArgsForProject(dir),
                 dir,
-            ], { timeout });
-            return this.parseScanOutput(result.stdout || result.stderr || "");
-        }
-        catch {
-            return [];
+            ], {
+                timeout,
+                deadlineAt: options.deadlineAt,
+                signal: options.signal,
+                maxOutputBytes: MAX_SG_OUTPUT_BYTES,
+            });
+            return this.interpretScanResult(result, ["scan"]);
         }
         finally {
             this.cleanupTempScan(sessionDir);
         }
     }
+    /** Backwards-compatible match-only wrapper for existing session scanners. */
+    async tempScanAsync(dir, ruleId, ruleYaml, timeout = DEFAULT_EXEC_TIMEOUT_MS, options = {}) {
+        const result = await this.tempScanDetailedAsync(dir, ruleId, ruleYaml, timeout, options);
+        return result.matches;
+    }
     /**
      * Run a rule scan with optional fix application.
      * Dry-run: --json (returns matches for preview).
      * Apply:   --update-all (writes fixes defined in the YAML `fix:` field).
      */
-    async tempScanWithFixAsync(dir, ruleId, ruleYaml, applyFixes, timeout = 30000) {
+    async tempScanWithFixAsync(dir, ruleId, ruleYaml, applyFixes, timeout = DEFAULT_EXEC_TIMEOUT_MS, options = {}) {
         const { sessionDir, configFile } = this.prepareTempScan(ruleId, ruleYaml);
         try {
             const { cmd: sgCmd, args: sgPre } = getSgCommand();
+            const scanArgs = [
+                ...sgPre,
+                "scan",
+                "--config",
+                configFile,
+                "--json",
+                ...sgExcludeArgsForProject(dir),
+                dir,
+            ];
+            const spawnOptions = {
+                timeout,
+                deadlineAt: options.deadlineAt,
+                signal: options.signal,
+                maxOutputBytes: MAX_SG_OUTPUT_BYTES,
+            };
             if (!applyFixes) {
-                const result = await safeSpawnAsync(sgCmd, [...sgPre, "scan", "--config", configFile, "--json",
-                    ...sgExcludeArgsForProject(dir), dir], { timeout });
-                return { matches: this.parseScanOutput(result.stdout || result.stderr || "") };
+                const result = await safeSpawnAsync(sgCmd, scanArgs, spawnOptions);
+                const scan = this.interpretScanResult(result, ["scan"]);
+                return scan.failure || scan.error
+                    ? { matches: [], error: scan.error }
+                    : { matches: scan.matches };
             }
             // Apply: capture matches BEFORE writing — once --update-all applies
             // the fix the rule no longer matches, so a post-apply json pass would
             // report zero even on a successful apply. Count first, then write.
-            const jsonResult = await safeSpawnAsync(sgCmd, [...sgPre, "scan", "--config", configFile, "--json",
-                ...sgExcludeArgsForProject(dir), dir], { timeout });
-            const matches = this.parseScanOutput(jsonResult.stdout || jsonResult.stderr || "");
-            const applyResult = await safeSpawnAsync(sgCmd, [...sgPre, "scan", "--config", configFile, "--update-all",
-                ...sgExcludeArgsForProject(dir), dir], { timeout });
-            if (applyResult.error) {
-                return { matches: [], error: applyResult.error.message };
+            const jsonResult = await safeSpawnAsync(sgCmd, scanArgs, spawnOptions);
+            const scan = this.interpretScanResult(jsonResult, ["scan"]);
+            if (scan.failure || scan.error) {
+                return { matches: [], error: scan.error };
+            }
+            const applyResult = await safeSpawnAsync(sgCmd, [
+                ...sgPre,
+                "scan",
+                "--config",
+                configFile,
+                "--update-all",
+                ...sgExcludeArgsForProject(dir),
+                dir,
+            ], spawnOptions);
+            if (applyResult.error ||
+                applyResult.failure ||
+                applyResult.status !== 0) {
+                return {
+                    matches: [],
+                    error: applyResult.error?.message ||
+                        `ast-grep apply failed with exit code ${applyResult.status}`,
+                };
             }
-            return { matches };
+            return { matches: scan.matches };
         }
         catch (err) {
             return { matches: [], error: String(err) };

package/node_modules/pi-lens/dist/clients/slow-fs.js

@@ -27,6 +27,7 @@
  * values are read lazily at call time, not module load, and `Number(...)` is
  * gated through `Number.isFinite` before use.
  */
+import { BoundedLruCache } from "./bounded-cache.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { toPositiveFinite } from "./env-utils.js";
@@ -95,7 +96,7 @@ export function probeSlowFs(rootDir) {
 }
 /** Process-lifetime memo of the slow-FS verdict, keyed by normalized cwd so
  * `/` vs `\` inputs share one entry (see path-key invariant tests). */
-const slowFsVerdictCache = new Map();
+const slowFsVerdictCache = new BoundedLruCache(32);
 /**
  * Resolve (and memoize) the slow-FS verdict for `cwd`. Resolution order:
  *   1. `PI_LENS_ALLOW_SLOW_FS_SCAN=1` — kill switch, always false.