pi-lens 3.8.63 → 3.8.65

package/dist/clients/package-manager.js

@@ -0,0 +1,223 @@
+/**
+ * Node.js package-manager resolution and command building.
+ *
+ * Single source of truth for "which package manager should we use here, and how
+ * do we spell each command (run script / install / exec / global bin) for it".
+ * Supports npm, pnpm, yarn and bun so pi-lens works on whatever manager the
+ * machine actually ships.
+ *
+ * Resolution order (see `resolveNodePackageManager`):
+ *   1. What the project declares — lockfile, then the corepack `packageManager`
+ *      field — *if that manager is actually installed*.
+ *   2. Otherwise the first installed manager in `PREFERENCE` (npm first for
+ *      maximum compatibility, bun last).
+ *   3. `npm` as a final fallback so callers always get a usable value.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { isCommandAvailableAsync, safeSpawnAsync } from "./safe-spawn.js";
+/**
+ * Fallback preference when nothing is declared (or the declared manager is
+ * missing). npm first for maximum compatibility; bun last. A project lockfile
+ * always overrides this order.
+ */
+const PREFERENCE = ["npm", "pnpm", "yarn", "bun"];
+function onWindows() {
+    return process.platform === "win32";
+}
+function isNodePackageManager(value) {
+    return (value === "npm" || value === "pnpm" || value === "yarn" || value === "bun");
+}
+// ============================================================================
+// DETECTION
+// ============================================================================
+/**
+ * Detect the package manager a Node.js project declares, without checking
+ * whether it is installed. Lockfiles win over the corepack `packageManager`
+ * field. Returns `undefined` when the project makes no declaration.
+ */
+export function detectNodePackageManager(targetPath) {
+    if (fs.existsSync(path.join(targetPath, "bun.lockb")) ||
+        fs.existsSync(path.join(targetPath, "bun.lock"))) {
+        return "bun";
+    }
+    if (fs.existsSync(path.join(targetPath, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (fs.existsSync(path.join(targetPath, "yarn.lock"))) {
+        return "yarn";
+    }
+    if (fs.existsSync(path.join(targetPath, "package-lock.json"))) {
+        return "npm";
+    }
+    return readPackageManagerField(targetPath);
+}
+/** Read the corepack `"packageManager": "pnpm@8.15.0"` field from package.json. */
+function readPackageManagerField(targetPath) {
+    try {
+        const pkgPath = path.join(targetPath, "package.json");
+        if (!fs.existsSync(pkgPath))
+            return undefined;
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (typeof pkg.packageManager !== "string")
+            return undefined;
+        const name = pkg.packageManager.split("@")[0].trim().toLowerCase();
+        return isNodePackageManager(name) ? name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// ============================================================================
+// AVAILABILITY (cached per process; reset in tests)
+// ============================================================================
+const availabilityCache = new Map();
+function isAvailable(pm) {
+    let cached = availabilityCache.get(pm);
+    if (!cached) {
+        cached = isCommandAvailableAsync(pm);
+        availabilityCache.set(pm, cached);
+    }
+    return cached;
+}
+/** Clear the process-wide availability cache. Intended for tests. */
+export function _resetPackageManagerCache() {
+    availabilityCache.clear();
+}
+// ============================================================================
+// RESOLUTION
+// ============================================================================
+/**
+ * Resolve which package manager to use for `cwd`: the project's declared manager
+ * if installed, otherwise the first installed manager in `PREFERENCE`, otherwise
+ * `npm`.
+ */
+export async function resolveNodePackageManager(cwd = process.cwd()) {
+    const declared = detectNodePackageManager(cwd);
+    if (declared && (await isAvailable(declared))) {
+        return declared;
+    }
+    for (const pm of PREFERENCE) {
+        if (await isAvailable(pm))
+            return pm;
+    }
+    return "npm";
+}
+// ============================================================================
+// COMMAND BUILDERS
+// ============================================================================
+/** Platform-specific executable name (`.cmd`/`.exe` on Windows). */
+export function pmBinary(pm) {
+    if (!onWindows())
+        return pm;
+    return pm === "bun" ? "bun.exe" : `${pm}.cmd`;
+}
+/** Args to run a package.json script — `run <script>` works for all managers. */
+export function runScriptArgs(script) {
+    return ["run", script];
+}
+/** Human-readable "run script" command for display (bare manager name). */
+export function formatRunScript(pm, script) {
+    return `${pm} run ${script}`;
+}
+/**
+ * Args to install a single package. npm uses `install`; pnpm/yarn/bun use `add`.
+ * `--legacy-peer-deps` is npm-only and silently dropped for other managers.
+ */
+export function installArgs(pm, pkg, options = {}) {
+    const args = [pm === "npm" ? "install" : "add"];
+    if (options.ignoreScripts)
+        args.push("--ignore-scripts");
+    if (options.legacyPeerDeps && pm === "npm")
+        args.push("--legacy-peer-deps");
+    args.push(pkg);
+    return args;
+}
+/**
+ * Args to install a single package **globally** (`-g`). npm/pnpm/bun spell this
+ * `install -g` / `add -g`; yarn uses `global add` (yarn classic — Berry removed
+ * global installs, but pi-lens's manager resolution prefers npm/pnpm first, so
+ * yarn is only chosen when it is the declared/only manager). The resulting
+ * binary is found again by `allAvailableGlobalBinDirs`, which covers every
+ * manager's global bin dir.
+ */
+export function globalInstallArgs(pm, pkg) {
+    switch (pm) {
+        case "yarn":
+            return ["global", "add", pkg];
+        case "npm":
+            return ["install", "-g", pkg];
+        default: // pnpm, bun
+            return ["add", "-g", pkg];
+    }
+}
+/**
+ * Command + args to run a package's binary without a global install — the
+ * `npx --no <pkg>` equivalent for each manager (`bun x`, `pnpm dlx`, `yarn dlx`).
+ */
+export function execArgs(pm, pkg, args = []) {
+    switch (pm) {
+        case "bun":
+            return { command: pmBinary("bun"), args: ["x", pkg, ...args] };
+        case "pnpm":
+            return { command: pmBinary("pnpm"), args: ["dlx", pkg, ...args] };
+        case "yarn":
+            return { command: pmBinary("yarn"), args: ["dlx", pkg, ...args] };
+        default:
+            // --no prevents silently downloading an uncached package.
+            return {
+                command: onWindows() ? "npx.cmd" : "npx",
+                args: ["--no", pkg, ...args],
+            };
+    }
+}
+// ============================================================================
+// GLOBAL BIN DISCOVERY
+// ============================================================================
+/** Directories where a given manager installs global binaries. */
+async function globalBinDirsFor(pm) {
+    if (pm === "bun") {
+        // bun has no per-call query cost — the global bin dir is deterministic.
+        const base = process.env.BUN_INSTALL || path.join(os.homedir(), ".bun");
+        return [path.join(base, "bin")];
+    }
+    const query = pm === "npm"
+        ? ["config", "get", "prefix"]
+        : pm === "pnpm"
+            ? ["bin", "-g"]
+            : ["global", "bin"]; // yarn
+    const res = await safeSpawnAsync(pmBinary(pm), query, { timeout: 5000 });
+    if (res.status !== 0 || res.error)
+        return [];
+    const out = res.stdout.trim();
+    if (!out)
+        return [];
+    // npm reports a prefix; binaries live in `<prefix>/bin` on Unix, `<prefix>`
+    // on Windows. pnpm/yarn already print the bin dir directly.
+    if (pm === "npm") {
+        return [onWindows() ? out : path.join(out, "bin")];
+    }
+    return [out];
+}
+/**
+ * Global bin directories for every installed manager, deduped. Used to locate a
+ * globally-installed tool binary when PATH is stale (e.g. right after an
+ * `install -g`) or when the tool was installed via a non-npm manager.
+ */
+export async function allAvailableGlobalBinDirs() {
+    const dirs = [];
+    const seen = new Set();
+    for (const pm of PREFERENCE) {
+        if (!(await isAvailable(pm)))
+            continue;
+        for (const dir of await globalBinDirsFor(pm)) {
+            const normalized = path.resolve(dir);
+            if (seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            dirs.push(normalized);
+        }
+    }
+    return dirs;
+}

package/dist/clients/pipeline.js

@@ -30,12 +30,25 @@ import { emitLensAnalysisComplete } from "./lens-events.js";
 import { getLSPService } from "./lsp/index.js";
 import { clearGraphCache } from "./review-graph/builder.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
-import { safeSpawnAsync } from "./safe-spawn.js";
+import { getAmbientAbortSignal, safeSpawnAsync } from "./safe-spawn.js";
+import { combineAbortSignals } from "./deadline-utils.js";
 import { getAutofixPolicyForFile, getPreferredAutofixTools, getRubocopCommand, hasBiomeConfig, hasDetektConfig, hasEslintConfig, hasGolangciConfig, hasKtfmtConfig, hasOxlintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, } from "./tool-policy.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
 const AUTOFIX_CHANGED_FILE_SCAN_LIMIT = 5000;
+/**
+ * Hard ceiling for the pre-dispatch LSP sync (`resyncLspFile`). The sync sends a
+ * didChange/didOpen; that write can backpressure indefinitely when the language
+ * server's stdin isn't being drained (a wedged/CPU-bound server), which would
+ * hang the whole edit with no per-call bound — client acquisition is capped, but
+ * the notify write is not. So the sync is abandoned after this budget (the edit
+ * proceeds; the dispatch LSP runner, which has its own 30s cap, still tries).
+ */
+function lspSyncBudgetMs() {
+    const raw = Number(process.env.PI_LENS_LSP_SYNC_BUDGET_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : 3000;
+}
 // Scan one directory's entries into `snapshot`, pushing walkable subdirs onto
 // `stack`. Extracted from the walk loop to keep each function's cognitive
 // complexity low. Excluded/ignored dirs are not descended; ignored/vanished
@@ -615,12 +628,52 @@ export async function resyncLspFile(filePath, fileContent, needsContentRefresh,
             // the cache clear (no preserveDiagnostics) so the wait resolves on fresh,
             // correctly-positioned diagnostics rather than stale pre-edit ones — the
             // didChange triggers a server recompute regardless of cache preservation.
-            await lspService.touchFile(filePath, fileContent, {
+            //
+            // The touch is client-wait-capped, but its didChange/didOpen *write* can
+            // backpressure forever on a wedged server (stdin not drained), which would
+            // hang the whole edit with no bound and — until this — no log. Race it
+            // against a hard budget + the turn's abort signal (Escape): whichever wins,
+            // the edit proceeds. A wedged server no longer parks the pipeline.
+            const budgetMs = lspSyncBudgetMs();
+            const abort = getAmbientAbortSignal();
+            if (abort?.aborted)
+                return;
+            const bail = combineAbortSignals(abort, AbortSignal.timeout(budgetMs));
+            const startedAt = Date.now();
+            const touch = lspService
+                .touchFile(filePath, fileContent, {
                 diagnostics: "none",
                 source: "lsp_sync",
                 clientScope: "primary",
                 maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
+            })
+                .then(() => "done")
+                .catch((err) => {
+                dbg(`LSP resync after autofix error: ${err}`);
+                return "done";
             });
+            const bailed = new Promise((resolve) => {
+                if (!bail || bail.aborted)
+                    return resolve("bailed");
+                bail.addEventListener("abort", () => resolve("bailed"), { once: true });
+            });
+            const outcome = await Promise.race([touch, bailed]);
+            if (outcome === "bailed") {
+                // Abandon the still-pending write; the edit continues. Log it so this
+                // stall — previously an invisible hang — is queryable in latency.log.
+                logLatency({
+                    type: "phase",
+                    phase: "lsp_sync_abandoned",
+                    filePath,
+                    durationMs: Date.now() - startedAt,
+                    metadata: {
+                        source: "lsp_sync",
+                        reason: abort?.aborted ? "aborted" : "timeout",
+                        budgetMs,
+                    },
+                });
+                dbg(`LSP resync ${abort?.aborted ? "aborted (Escape)" : `timed out after ${budgetMs}ms`}; server slow/wedged for ${filePath}`);
+            }
         }
     }
     catch (err) {

package/dist/clients/project-metadata.js

@@ -11,6 +11,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { detectNodePackageManager, formatRunScript, } from "./package-manager.js";
 // --- Detection Functions ---
 /**
  * Detect project metadata from a target directory.
@@ -204,24 +205,6 @@ function detectNodeProject(targetPath) {
     }
     return metadata;
 }
-/**
- * Detect Node.js package manager from lockfiles
- */
-function detectNodePackageManager(targetPath) {
-    if (fs.existsSync(path.join(targetPath, "bun.lockb")) || fs.existsSync(path.join(targetPath, "bun.lock"))) {
-        return "bun";
-    }
-    if (fs.existsSync(path.join(targetPath, "pnpm-lock.yaml"))) {
-        return "pnpm";
-    }
-    if (fs.existsSync(path.join(targetPath, "yarn.lock"))) {
-        return "yarn";
-    }
-    if (fs.existsSync(path.join(targetPath, "package-lock.json"))) {
-        return "npm";
-    }
-    return undefined;
-}
 /**
  * Detect Python project from pyproject.toml, setup.py, requirements.txt
  */
@@ -663,13 +646,10 @@ export function getAvailableCommands(metadata) {
         for (const priority of scriptPriority) {
             const matching = Object.entries(metadata.scripts).find(([name]) => name.toLowerCase().includes(priority));
             if (matching) {
-                const runCmd = metadata.packageManager === "bun" ? "bun run" :
-                    metadata.packageManager === "pnpm" ? "pnpm" :
-                        metadata.packageManager === "yarn" ? "yarn" :
-                            "npm run";
+                const pm = (metadata.packageManager ?? "npm");
                 commands.push({
                     action: priority,
-                    command: `${runCmd} ${matching[0]}`,
+                    command: formatRunScript(pm, matching[0]),
                 });
             }
         }

package/dist/clients/safe-spawn.js

@@ -35,6 +35,15 @@ let ambientAbortSignal;
 export function setAmbientAbortSignal(signal) {
     ambientAbortSignal = signal;
 }
+/**
+ * The current turn's abort signal, for in-process awaits that aren't child
+ * spawns (e.g. an LSP JSON-RPC write that can backpressure on a wedged server).
+ * Child spawns read the ambient signal internally; this getter lets the
+ * interactive pipeline honor Escape on non-spawn LSP calls too.
+ */
+export function getAmbientAbortSignal() {
+    return ambientAbortSignal;
+}
 // ============================================================================
 // INTERNAL HELPERS
 // ============================================================================

package/dist/clients/tree-sitter-client.js

@@ -94,6 +94,53 @@ export class TreeSitterClient {
             return cwdCandidate;
         return undefined;
     }
+    /**
+     * The `grammars/` dir bundled inside the pi-lens package (the core grammars
+     * shipped in the tarball, so common languages parse offline on every package
+     * manager). Resolved from the package root; cached. Absent in a source
+     * checkout where `prepare` hasn't populated it.
+     */
+    _bundledGrammarsDir;
+    bundledGrammarsDir() {
+        // Cache only a positive hit; keep re-checking until it exists (prepare may
+        // not have populated it yet at first probe).
+        if (this._bundledGrammarsDir)
+            return this._bundledGrammarsDir;
+        try {
+            const dir = resolvePackagePath(import.meta.url, "grammars");
+            if (fs.existsSync(dir))
+                this._bundledGrammarsDir = dir;
+            return this._bundledGrammarsDir;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * All directories that may hold grammar wasms, in precedence order: the
+     * bundled core dir, the resolved `this.grammarsDir`, and the web-tree-sitter
+     * grammars dir (the lazy-fetch write target). Deduped.
+     */
+    grammarSourceDirs() {
+        const dirs = [];
+        const push = (d) => {
+            if (d && !dirs.includes(d))
+                dirs.push(d);
+        };
+        push(this.bundledGrammarsDir());
+        push(this.grammarsDir || undefined);
+        push(this.resolveWebTreeSitterAsset("grammars"));
+        return dirs;
+    }
+    /** Absolute path to `grammarFile` across all source dirs, else undefined. */
+    resolveGrammarFile(grammarFile) {
+        for (const dir of this.grammarSourceDirs()) {
+            const candidate = path.join(dir, grammarFile);
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        return undefined;
+    }
     /** Find tree-sitter grammar directory */
     findGrammarsDir() {
         const grammarsDir = this.resolveWebTreeSitterAsset("grammars");
@@ -101,7 +148,8 @@ export class TreeSitterClient {
             fs.existsSync(path.join(grammarsDir, "tree-sitter-typescript.wasm"))) {
             return grammarsDir;
         }
-        // Fallback: tree-sitter-wasms package (real installs, not npm:null)
+        // Fallback: a real `tree-sitter-wasms` package, if the user installed one
+        // (it is not a pi-lens dependency — grammars ship bundled / lazy-fetched).
         try {
             const wasmsOut = path.join(path.dirname(_require.resolve("tree-sitter-wasms/package.json")), "out");
             if (fs.existsSync(wasmsOut))
@@ -145,7 +193,7 @@ export class TreeSitterClient {
      * throws.
      */
     async ensureGrammar(grammarFile) {
-        if (this.grammarsDir && fs.existsSync(path.join(this.grammarsDir, grammarFile))) {
+        if (this.resolveGrammarFile(grammarFile)) {
             return true;
         }
         const inflight = this.grammarEnsurePromises.get(grammarFile);
@@ -166,7 +214,14 @@ export class TreeSitterClient {
                 console.error(`[pi-lens] fetched missing tree-sitter grammar ${grammarFile} at runtime (install scripts were skipped by the package manager)`);
             }
             else {
-                this.dbg(`grammar fetch failed for ${grammarFile}`);
+                // Surface the degradation once per grammar (the promise cache dedupes)
+                // instead of failing silently — otherwise pnpm/bun users offline get
+                // no signal that a language's tree-sitter features are unavailable.
+                console.error(`[pi-lens] tree-sitter grammar '${grammarFile}' is unavailable — ` +
+                    `symbol search, module reports and structural rules for this language will be degraded. ` +
+                    `The package manager skipped install scripts and the runtime download failed (offline or CDN unreachable). ` +
+                    `Fix: reinstall with a manager that runs postinstall, allow its build scripts ` +
+                    `(pnpm approve-builds / bun trustedDependencies), or restore network access.`);
             }
             return ok;
         })();
@@ -238,14 +293,14 @@ export class TreeSitterClient {
             this.dbg(`No grammar file for ${languageId}`);
             return null;
         }
-        let grammarPath = this.grammarsDir
-            ? path.join(this.grammarsDir, grammarFile)
-            : "";
-        // Lazily fetch the grammar if the postinstall download was skipped
-        // (pnpm/bun). Only the language actually being parsed is fetched.
-        if (!grammarPath || !fs.existsSync(grammarPath)) {
+        // Look across the bundled core `grammars/` dir and the postinstall/lazy
+        // dir. Lazily fetch only if the grammar is in neither (pnpm/bun skip
+        // postinstall; the long-tail grammars aren't bundled). Only the language
+        // actually being parsed is fetched.
+        let grammarPath = this.resolveGrammarFile(grammarFile);
+        if (!grammarPath) {
             if (await this.ensureGrammar(grammarFile)) {
-                grammarPath = path.join(this.grammarsDir, grammarFile);
+                grammarPath = this.resolveGrammarFile(grammarFile);
             }
         }
         this.dbg(`Grammar path: ${grammarPath}, exists: ${grammarPath && fs.existsSync(grammarPath)}`);
@@ -356,14 +411,17 @@ export class TreeSitterClient {
         this.dbg(`Found ${injections.length} injections in ${filePath}`);
         return injections;
     }
-    /** Check if tree-sitter is available (grammars installed) */
+    /** Check if tree-sitter is available (a core grammar resolves somewhere). */
     isAvailable() {
-        if (fs.existsSync(this.grammarsDir))
+        // Available if the core TS grammar resolves in ANY source dir — the bundled
+        // `grammars/` counts even when web-tree-sitter/grammars is empty (no
+        // postinstall on pnpm/bun, or a fresh CI checkout).
+        if (this.resolveGrammarFile("tree-sitter-typescript.wasm"))
             return true;
-        // Re-evaluate in case grammars were installed after process start
+        // Re-evaluate the legacy dir in case grammars were installed after start.
         const dir = this.findGrammarsDir();
         this.grammarsDir = dir;
-        return fs.existsSync(dir);
+        return !!dir && fs.existsSync(dir);
     }
     /** Check if specific language is supported */
     async isLanguageSupported(languageId) {

package/dist/index.js

@@ -1548,6 +1548,22 @@ export default function (pi) {
         // Publish this turn's abort signal so the dispatch's linter/type-check
         // child processes are killed if the agent is interrupted (#197 ctx.signal).
         setAmbientAbortSignal(ctx?.signal);
+        // Earliest possible marker for the edit pipeline: the first instrumented
+        // phase is `read_file` deep inside runPipeline, so a stall before that (or
+        // upstream, before pi-lens even received the event) leaves NO trace — that
+        // is exactly why a wedged-LSP edit hang was invisible in latency.log. This
+        // row means "pi-lens received this edit"; if it is present but nothing
+        // follows, the stall is in the pipeline; if it is absent, it is upstream.
+        const rtToolName = event?.toolName;
+        if (rtToolName === "edit" || rtToolName === "write") {
+            logLatency({
+                type: "phase",
+                phase: "tool_result_received",
+                filePath: event?.input?.path ?? "<unknown>",
+                durationMs: 0,
+                metadata: { toolName: rtToolName },
+            });
+        }
         try {
             const { biomeClient, ruffClient, metricsClient, agentBehaviorClient } = await loadBootstrapClients();
             return await handleToolResult({

package/dist/mcp/server.js

@@ -483,13 +483,15 @@ async function callTool(name, args) {
     }
     if (name === "pilens_rebuild") {
         const outcome = await runRebuild(REPO_ROOT, REBUILD_SCRIPT);
+        const runCmd = `${outcome.packageManager} run ${outcome.script}`;
         const headline = outcome.ok
-            ? `✓ rebuild succeeded (npm run ${outcome.script}, ${outcome.durationMs}ms). Fresh analyses now reflect the latest build.`
-            : `✗ rebuild FAILED (npm run ${outcome.script}, ${outcome.durationMs}ms).`;
+            ? `✓ rebuild succeeded (${runCmd}, ${outcome.durationMs}ms). Fresh analyses now reflect the latest build.`
+            : `✗ rebuild FAILED (${runCmd}, ${outcome.durationMs}ms).`;
         return {
             ...toolText(outcome.ok ? headline : `${headline}\n\n${outcome.output}`, {
                 ok: outcome.ok,
                 script: outcome.script,
+                packageManager: outcome.packageManager,
                 durationMs: outcome.durationMs,
                 repoRoot: REPO_ROOT,
             }),

package/dist/tools/ast-grep-search.js

@@ -7,6 +7,7 @@ import { Type } from "../clients/deps/typebox.js";
 import { astGrepRemediationHint, classifyAstGrepError, logAstGrepToolEvent, } from "../clients/ast-grep-tool-logger.js";
 import { hasStructuralIntent, synthesizeRule, } from "../clients/ast-grep-yaml-synth.js";
 import { compactRenderResult } from "./render-compact.js";
+import { combineAbortSignals } from "../clients/deadline-utils.js";
 import { LANGUAGES } from "./shared.js";
 /**
  * Build the agent-facing error text, appending a remediation hint derived from
@@ -303,6 +304,9 @@ export function createAstGrepSearchTool(astGrepClient) {
             })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            // Escape aborts the turn via ctx.signal; the positional signal is the
+            // tool-call one. Honor both so a broad search cancels on Escape.
+            const abortSignal = combineAbortSignals(_signal, ctx.signal);
             const startedAt = Date.now();
             const { paths, selector, context, skip, maxMatches, groupByFile, strictness, rule, insideKind, hasKind, follows, precedes, validateOnly, } = params;
             const pattern = typeof params.pattern === "string" ? params.pattern : "";
@@ -398,7 +402,7 @@ export function createAstGrepSearchTool(astGrepClient) {
                         details: {},
                     };
                 }
-                if (_signal.aborted)
+                if (abortSignal?.aborted)
                     return abortError();
                 if (!(await astGrepClient.ensureAvailable())) {
                     logOutcome("error", {
@@ -415,7 +419,7 @@ export function createAstGrepSearchTool(astGrepClient) {
                         details: {},
                     };
                 }
-                if (_signal.aborted)
+                if (abortSignal?.aborted)
                     return abortError();
                 if (!hasRawRule && looksLikeRuleYamlOrPlainText(pattern)) {
                     logOutcome("error", {
@@ -503,10 +507,10 @@ export function createAstGrepSearchTool(astGrepClient) {
                 }
                 // Phase 4: raw YAML rule passthrough — routes through sg scan --config
                 if (effectiveRule && effectiveRule.trim().length > 0) {
-                    if (_signal.aborted)
+                    if (abortSignal?.aborted)
                         return abortError();
                     const ruleResult = await astGrepClient.searchWithRule(effectiveRule, searchPaths);
-                    if (_signal.aborted)
+                    if (abortSignal?.aborted)
                         return abortError();
                     if (ruleResult.error) {
                         logOutcome("error", { errorRaw: ruleResult.error });
@@ -555,14 +559,14 @@ export function createAstGrepSearchTool(astGrepClient) {
                         },
                     };
                 }
-                if (_signal.aborted)
+                if (abortSignal?.aborted)
                     return abortError();
                 const result = await astGrepClient.search(pattern, lang, searchPaths, {
                     selector,
                     context,
                     strictness,
                 });
-                if (_signal.aborted)
+                if (abortSignal?.aborted)
                     return abortError();
                 if (result.error) {
                     logOutcome("error", { errorRaw: result.error });