pi-lens 3.8.65 → 3.8.67

package/dist/clients/dispatch/runners/tree-sitter.js

@@ -7,22 +7,14 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { RuleCache } from "../../cache/rule-cache.js";
+import { isTestFile } from "../../file-utils.js";
 import { resolvePackagePath } from "../../package-root.js";
 import { buildOrUpdateGraph, computeImpactCascade, recordEntitySnapshotDiff, } from "../../review-graph/service.js";
-import { TreeSitterClient } from "../../tree-sitter-client.js";
+import { getSharedTreeSitterClient, isTreeSitterWasmAborted, markTreeSitterWasmAborted, resolveTreeSitterLanguage, } from "../../tree-sitter-shared.js";
 import { logTreeSitter } from "../../tree-sitter-logger.js";
 import { isDisabledQueryFilePath, queryLoader, } from "../../tree-sitter-query-loader.js";
 import { classifyDefect } from "../diagnostic-taxonomy.js";
 import { PRIORITY } from "../priorities.js";
-// Module-level singleton: web-tree-sitter WASM must only be initialized once per process.
-// Creating a new TreeSitterClient() on every write resets TRANSFER_BUFFER (a module-level
-// WASM pointer) — concurrent writes race on _ts_init() and corrupt shared WASM state → crash.
-let _sharedClient = null;
-// Once the wasm runtime aborts, the entire module-level wasm heap is corrupted — no
-// recovery is possible within this process. Flag it and skip all further tree-sitter work
-// rather than re-invoking the dead runtime (which prints "Aborted()" on every call and
-// leaks memory on each retry).
-let _wasmAborted = false;
 const blastCooldownByFile = new Map();
 const BLAST_COOLDOWN_MS = 5_000;
 function runBlastRadiusInBackground(cwd, filePath, languageId, facts) {
@@ -286,14 +278,6 @@ function isLineInModifiedRanges(line, ranges) {
         return true;
     return ranges.some((r) => line >= r.start && line <= r.end);
 }
-function getSharedClient() {
-    if (_wasmAborted)
-        return null;
-    if (!_sharedClient) {
-        _sharedClient = new TreeSitterClient();
-    }
-    return _sharedClient;
-}
 /**
  * Calculate total lines changed in modified ranges.
  * Used to skip expensive entity extraction for trivial changes.
@@ -305,46 +289,6 @@ function getTotalLinesChanged(ranges) {
 }
 /** Threshold: skip entity extraction for changes under 5 lines */
 const ENTITY_EXTRACTION_LINE_THRESHOLD = 5;
-function resolveTreeSitterLanguage(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    const EXT_TO_LANG = {
-        ".ts": "typescript",
-        ".mts": "typescript",
-        ".cts": "typescript",
-        ".tsx": "tsx",
-        ".js": "javascript",
-        ".mjs": "javascript",
-        ".cjs": "javascript",
-        ".jsx": "javascript",
-        ".py": "python",
-        ".go": "go",
-        ".rs": "rust",
-        ".rb": "ruby",
-        ".c": "c",
-        ".h": "c",
-        ".cc": "cpp",
-        ".cpp": "cpp",
-        ".cxx": "cpp",
-        ".c++": "cpp",
-        ".hh": "cpp",
-        ".hpp": "cpp",
-        ".hxx": "cpp",
-        ".inl": "cpp",
-        ".ipp": "cpp",
-        ".tpp": "cpp",
-        ".txx": "cpp",
-        ".cu": "cpp",
-        ".hip": "cpp",
-        ".cs": "csharp",
-        ".php": "php",
-        ".phtml": "php",
-        ".php3": "php",
-        ".php4": "php",
-        ".php5": "php",
-        ".css": "css",
-    };
-    return EXT_TO_LANG[ext];
-}
 const treeSitterRunner = {
     id: "tree-sitter",
     appliesTo: ["jsts", "python", "go", "rust", "ruby", "cxx", "csharp", "php", "css"],
@@ -353,13 +297,13 @@ const treeSitterRunner = {
     skipTestFiles: false, // Run on test files too (structural issues matter there)
     async run(ctx) {
         // Use singleton client — WASM must never be re-initialized after first call
-        const client = getSharedClient();
+        const client = getSharedTreeSitterClient();
         logTreeSitter({ phase: "runner_start", filePath: ctx.filePath });
         if (!client || !client.isAvailable()) {
             logTreeSitter({
                 phase: "runner_skip",
                 filePath: ctx.filePath,
-                reason: _wasmAborted ? "wasm_aborted" : "client_unavailable",
+                reason: isTreeSitterWasmAborted() ? "wasm_aborted" : "client_unavailable",
                 status: "skipped",
             });
             return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -460,9 +404,13 @@ const treeSitterRunner = {
         // Run all queries regardless of blockingOnly — warning-tier results are logged
         // for diagnostic history but filtered from agent output by the dispatcher.
         // Only skip "review" tier queries on write (too noisy / expensive).
-        const effectiveQueries = ctx.blockingOnly
+        // Per-rule test-file carve-out (#440): rules that are noise in tests (e.g.
+        // python-assert-production — `assert` is the idiomatic test assertion) opt
+        // out via `skip_test_files` while the runner otherwise runs on test files.
+        const fileIsTest = isTestFile(filePath);
+        const effectiveQueries = (ctx.blockingOnly
             ? languageQueries.filter((q) => q.inline_tier !== "review")
-            : languageQueries;
+            : languageQueries).filter((q) => !(fileIsTest && q.skip_test_files));
         logTreeSitter({
             phase: "queries_loaded",
             filePath,
@@ -547,8 +495,7 @@ const treeSitterRunner = {
                     // Emscripten abort() corrupts the entire module-level wasm heap.
                     // Poison the singleton so no further queries attempt to use the dead runtime.
                     if (msg.includes("Aborted") || msg.includes("abort()")) {
-                        _wasmAborted = true;
-                        _sharedClient = null;
+                        markTreeSitterWasmAborted();
                         logTreeSitter({
                             phase: "query_error",
                             filePath,

package/dist/clients/dispatch/runners/utils/runner-helpers.js

@@ -12,6 +12,7 @@ import { fileURLToPath } from "node:url";
 import { getGlobalPiLensDir } from "../../../file-utils.js";
 import { ensureTool } from "../../../installer/index.js";
 import { getServersForFileWithConfig, isServerDisabled, } from "../../../lsp/config.js";
+import { findGlobalBinary } from "../../../package-manager.js";
 import { safeSpawnAsync } from "../../../safe-spawn.js";
 import { getToolCommandSpec, shouldAutoInstallTool, } from "../../../tool-policy.js";
 /**
@@ -257,34 +258,6 @@ export async function resolveAvailableOrInstall(checker, toolId, cwd) {
     return installed ?? null;
 }
 // =============================================================================
-// CONFIG FILE FINDER FACTORY
-// =============================================================================
-/**
- * Create a config file finder for rule directories.
- * Common pattern used by slop runners and similar tools.
- */
-export function createConfigFinder(ruleDirName) {
-    return (cwd) => {
-        // Check for local config first
-        const localPath = path.join(cwd, "rules", ruleDirName, ".sgconfig.yml");
-        if (fs.existsSync(localPath)) {
-            return localPath;
-        }
-        // Fall back to extension rules
-        const extensionPaths = [
-            `rules/${ruleDirName}/.sgconfig.yml`,
-            `../rules/${ruleDirName}/.sgconfig.yml`,
-        ];
-        for (const candidate of extensionPaths) {
-            const fullPath = path.resolve(cwd, candidate);
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-        return undefined;
-    };
-}
-// =============================================================================
 // SHARED AST-GREP AVAILABILITY
 // =============================================================================
 // Shared ast-grep availability cache across all slop runners
@@ -354,6 +327,17 @@ export async function isSgAvailableAsync() {
                 return true;
             }
         }
+        // 2b. Any package manager's global bin dir (npm/pnpm/yarn/bun) — catches
+        // `pnpm add -g @ast-grep/cli` installs whose bin dir is off PATH (#375).
+        for (const name of ["ast-grep", "sg"]) {
+            const globalBin = await findGlobalBinary(name);
+            if (globalBin && (await probeAstGrepCommandAsync(globalBin))) {
+                sgCmd = globalBin;
+                sgCmdArgs = [];
+                sgAvailable = true;
+                return true;
+            }
+        }
         // 3. npx --no (cache-only, no silent download).
         if (await probeAstGrepCommandAsync("npx", ["--no", "--", "ast-grep"])) {
             sgCmd = "npx";
@@ -378,10 +362,14 @@ export function getSgCommand() {
 // LOCAL-FIRST BINARY RESOLUTION
 // =============================================================================
 /**
- * Find a tool binary preferring local node_modules/.bin over global PATH.
- * Only falls back to npx as a last resort (avoids silent network downloads).
+ * Find a tool binary preferring local node_modules/.bin, then any installed
+ * package manager's global bin dir (npm/pnpm/yarn/bun), then global PATH. Only
+ * falls back to `npx --no` as a last resort — the universal cache-only exec
+ * (npx ships with node and never silently downloads), so this stays
+ * manager-agnostic without risking a surprise `dlx` fetch on pnpm/yarn/bun.
  *
- * Returns: { cmd, args } where args may include ["npx", toolName] preamble.
+ * Returns: { cmd, args } where args may include the `["--no", toolName]` npx
+ * preamble.
  */
 export async function resolveLocalFirstAsync(toolName, cwd, windowsExt = ".cmd") {
     const isWin = process.platform === "win32";
@@ -390,14 +378,21 @@ export async function resolveLocalFirstAsync(toolName, cwd, windowsExt = ".cmd")
     const local = path.join(cwd, "node_modules", ".bin", binName);
     if (fs.existsSync(local))
         return { cmd: local, args: [] };
-    // 2. Global PATH (already installed system-wide)
+    // 2. Global bin dir of ANY installed manager (npm/pnpm/yarn/bun) — direct
+    //    file lookup, so it finds tools installed via `pnpm add -g` / `bun add -g`
+    //    (whose bin dirs are often off PATH) and survives PATH staleness after an
+    //    `install -g`. No spawn.
+    const globalBin = await findGlobalBinary(toolName, windowsExt);
+    if (globalBin)
+        return { cmd: globalBin, args: [] };
+    // 3. Global PATH (already installed system-wide, on PATH)
     const globalCheck = await safeSpawnAsync(toolName, ["--version"], {
         timeout: 3000,
     });
     if (!globalCheck.error && globalCheck.status === 0) {
         return { cmd: toolName, args: [] };
     }
-    // 3. npx fallback — only for already-cached packages (no silent download)
+    // 4. npx --no fallback — universal cache-only exec (no silent download)
     return { cmd: "npx", args: ["--no", toolName] };
 }
 // =============================================================================

package/dist/clients/dispatch/tool-profile.js

@@ -5,7 +5,6 @@ const DEFAULT_TOOL_PROFILE = {
 const TOOL_PROFILE_MAP = {
     "tree-sitter:silent-error": { dedupPriority: 200, lintLike: false },
     lsp: { dedupPriority: 120, lintLike: false },
-    "ts-lsp": { dedupPriority: 120, lintLike: false },
     eslint: { dedupPriority: 110, lintLike: true },
     biome: { dedupPriority: 100, lintLike: true },
     "biome-check-json": { dedupPriority: 100, lintLike: true },

package/dist/clients/dispatch/types.js

@@ -2,7 +2,7 @@
  * Redesigned Dispatch Types for pi-lens
  *
  * Key insight: Different clients have different OUTPUT SEMANTICS:
- * - BLOCKING: Errors that stop the agent (architect, ts-lsp errors)
+ * - BLOCKING: Errors that stop the agent (architect, lsp errors)
  * - WARNING: Non-blocking issues (biome warnings, type-safety)
  * - FIXABLE: Issues with auto-fix available
  * - SILENT: Metrics tracked but not shown (complexity)

package/dist/clients/formatters.js

@@ -11,6 +11,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { logLatency } from "./latency-logger.js";
+import { findGlobalBinary } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { getAutoInstallToolIdForFormatter, getFormatterPolicyForFile, getSmartDefaultFormatterName, hasBiomeConfig, hasBlackConfig, hasClangFormatConfig, hasCljfmtConfig, hasCmakeFormatConfig, hasGoogleJavaFormatConfig, hasKtfmtConfig, hasNearestPackageJsonDependency, hasNearestPackageJsonField, hasOcamlformatConfig, hasOxfmtConfig, hasPhpCsFixerConfig, hasPrettierConfig, hasRubocopConfig, hasRuffConfig, hasSqlfluffConfig, hasStandardrbConfig, hasStyluaConfig, hasVitePlusConfig, } from "./tool-policy.js";
 const _lazyInstallAttempts = new Set();
@@ -251,6 +252,11 @@ export const biomeFormatter = {
         const local = await findInNodeModules("biome", cwd);
         if (local)
             return [local, "format", "--write", ...editorConfigFlag, filePath];
+        // Any package manager's global bin dir (npm/pnpm/yarn/bun) before we
+        // auto-install — catches a `pnpm add -g @biomejs/biome` PATH misses (#375).
+        const global = await findGlobalBinary("biome");
+        if (global)
+            return [global, "format", "--write", ...editorConfigFlag, filePath];
         const toolId = getAutoInstallToolIdForFormatter("biome");
         if (!toolId)
             return null;
@@ -291,6 +297,10 @@ export const prettierFormatter = {
         const local = await findInNodeModules("prettier", cwd);
         if (local)
             return [local, "--write", filePath];
+        // Global bin of any manager (npm/pnpm/yarn/bun) before auto-install (#375).
+        const global = await findGlobalBinary("prettier");
+        if (global)
+            return [global, "--write", filePath];
         return resolveManagedSmartDefaultCommand("prettier", filePath, ["--write"]);
     },
     extensions: [

package/dist/clients/git-guard.js

@@ -27,6 +27,6 @@ export function evaluateGitGuard(runtime, cacheManager, cwd) {
         : "";
     return {
         block: true,
-        reason: `🔴 COMMIT BLOCKED (--lens-guard): unresolved blockers must be fixed before commit/push.${details}\nRun /lens-booboo for full details, then commit again.`,
+        reason: `🔴 COMMIT BLOCKED (--lens-guard): unresolved blockers must be fixed before commit/push.${details}\nRun lens_diagnostics mode=all for full details, then commit again.`,
     };
 }

package/dist/clients/grammar-source.js

@@ -15,6 +15,22 @@ import * as path from "node:path";
 export const TREE_SITTER_WASMS_VERSION = "0.1.13";
 /** unpkg mirror of the tree-sitter-wasms artifacts. */
 export const GRAMMAR_CDN_BASE = `https://unpkg.com/tree-sitter-wasms@${TREE_SITTER_WASMS_VERSION}/out`;
+export const GRAMMAR_SOURCE_OVERRIDES = {
+    "tree-sitter-lua.wasm": {
+        package: "@tree-sitter-grammars/tree-sitter-lua",
+        version: "0.4.1",
+        url: "https://unpkg.com/@tree-sitter-grammars/tree-sitter-lua@0.4.1/tree-sitter-lua.wasm",
+    },
+    "tree-sitter-yaml.wasm": {
+        package: "@tree-sitter-grammars/tree-sitter-yaml",
+        version: "0.7.1",
+        url: "https://unpkg.com/@tree-sitter-grammars/tree-sitter-yaml@0.7.1/tree-sitter-yaml.wasm",
+    },
+};
+/** The URL a grammar wasm is fetched from (override if any, else the aggregator). */
+export function grammarSourceUrl(filename) {
+    return GRAMMAR_SOURCE_OVERRIDES[filename]?.url ?? `${GRAMMAR_CDN_BASE}/${filename}`;
+}
 /** Language id → grammar wasm filename. */
 export const LANGUAGE_TO_GRAMMAR = {
     typescript: "tree-sitter-typescript.wasm",
@@ -48,15 +64,62 @@ export const LANGUAGE_TO_GRAMMAR = {
 export const GRAMMAR_FILES = [
     ...new Set(Object.values(LANGUAGE_TO_GRAMMAR)),
 ];
+/**
+ * Grammars that FATALLY crash the host runtime on specific engines/versions and
+ * therefore must NOT be loaded there. The crash is an uncatchable process abort
+ * (V8 Turboshaft WASM OOM — `Fatal process out of memory: Zone`), so it cannot be
+ * degraded in-process with try/catch; the only safe option is to skip the load
+ * entirely and degrade the feature (no structural symbols for that language).
+ *
+ * Membership is GUARD-DRIVEN, not hand-maintained: the grammar-health nightly
+ * (`scripts/check-grammar-load.mjs`) is what proves a grammar crashes and thus
+ * belongs here, and what proves a future build is safe enough to remove it.
+ *
+ * tree-sitter-swift crashes on Node >= 24 across all OSes under memory pressure
+ * (#423/#432); building from source (an earlier vendoring attempt, #426) does not
+ * reliably dodge it. bun (JavaScriptCore) and Node 20/22 are unaffected, so the
+ * block is gated on V8 + Node major.
+ */
+export const BLOCKED_GRAMMARS = {
+    "tree-sitter-swift.wasm": {
+        blocked: ({ isV8, nodeMajor }) => isV8 && nodeMajor >= 24,
+        reason: "tree-sitter-swift crashes the runtime on Node >= 24 (V8 Turboshaft WASM OOM, #423/#432); skipped so the process degrades gracefully instead of aborting.",
+    },
+};
+/** Runtime signals for the currently-running process. */
+export function currentGrammarRuntime() {
+    const m = /^v?(\d+)/.exec(process.versions?.node ?? "");
+    return {
+        nodeMajor: m ? Number(m[1]) : 0,
+        isV8: !process.versions.bun && Boolean(process.versions.v8),
+        platform: process.platform,
+    };
+}
+/**
+ * The block reason if `filename` must NOT be loaded on `rt` (default: the running
+ * process), else null. Callers skip the load and degrade to "grammar unavailable".
+ */
+export function grammarBlockReason(filename, rt = currentGrammarRuntime()) {
+    // Diagnostic escape hatch (grammar-health probe only): force-load a blocked
+    // grammar to test whether a fresh build / newer runtime survives — the signal
+    // that a block can be LIFTED. Never set in normal operation: it disables the
+    // crash protection and can abort the process.
+    if (process.env.PILENS_UNSAFE_FORCE_GRAMMAR_LOAD === "1")
+        return null;
+    const block = BLOCKED_GRAMMARS[filename];
+    return block?.blocked(rt) ? block.reason : null;
+}
 /**
  * Fetch one grammar wasm into `destDir` (atomic via a temp file). Returns true
  * on success. Never throws — a failed fetch (offline, 4xx) degrades to "grammar
- * unavailable" so callers can decide how to handle it.
+ * unavailable" so callers can decide how to handle it. A grammar that crashes the
+ * runtime is protected at LOAD time (BLOCKED_GRAMMARS / grammarBlockReason), not
+ * by refusing to download it.
  */
 export async function downloadGrammar(destDir, filename) {
     try {
         fs.mkdirSync(destDir, { recursive: true });
-        const res = await fetch(`${GRAMMAR_CDN_BASE}/${filename}`);
+        const res = await fetch(grammarSourceUrl(filename));
         if (!res.ok)
             throw new Error(`HTTP ${res.status}`);
         const data = Buffer.from(await res.arrayBuffer());

package/dist/clients/jscpd-client.js

@@ -12,6 +12,7 @@ import { mkdtempSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { getExcludedDirGlobs, getProjectIgnoreGlobs, getProjectIgnoreMatcher, isExcludedDirName, } from "./file-utils.js";
+import { findNodeToolBinary } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 const EMPTY_RESULT = {
     success: false,
@@ -192,8 +193,13 @@ export class JscpdClient {
         }
         const ignorePattern = baseIgnores.join(",");
         try {
-            const result = await safeSpawnAsync("npx", [
-                "jscpd",
+            // Prefer a local/global-installed jscpd (any manager) over npx (#375).
+            const bin = await findNodeToolBinary("jscpd", cwd);
+            const { cmd, prefix } = bin
+                ? { cmd: bin, prefix: [] }
+                : { cmd: "npx", prefix: ["jscpd"] };
+            const result = await safeSpawnAsync(cmd, [
+                ...prefix,
                 ".",
                 "--min-lines",
                 String(minLines),

package/dist/clients/language-policy.js

@@ -67,7 +67,7 @@ export const LANGUAGE_POLICY = {
 const PRIMARY_DISPATCH_GROUPS = {
     jsts: {
         mode: "fallback",
-        runnerIds: ["lsp", "ts-lsp"],
+        runnerIds: ["lsp"],
         filterKinds: ["jsts"],
     },
     python: {
@@ -212,7 +212,7 @@ export function getPrimaryDispatchGroup(kind, lspEnabled) {
         return undefined;
     const ids = lspEnabled
         ? [...base.runnerIds]
-        : base.runnerIds.filter((id) => id !== "lsp" && id !== "ts-lsp");
+        : base.runnerIds.filter((id) => id !== "lsp");
     if (ids.length === 0)
         return undefined;
     return {

package/dist/clients/latency-logger.js

@@ -2,27 +2,23 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
 const LATENCY_LOG_DIR = getGlobalPiLensDir();
 const LATENCY_LOG_FILE = path.join(LATENCY_LOG_DIR, "latency.log");
-try {
-    if (!fs.existsSync(LATENCY_LOG_DIR)) {
-        fs.mkdirSync(LATENCY_LOG_DIR, { recursive: true });
-    }
-}
-catch { }
+const writer = createNdjsonLogger({ filePath: LATENCY_LOG_FILE });
 export function logLatency(entry) {
     if (isTestMode()) {
         return;
     }
-    const line = `${JSON.stringify({ ts: new Date().toISOString(), ...entry })}\n`;
-    try {
-        fs.appendFileSync(LATENCY_LOG_FILE, line);
-    }
-    catch { }
+    writer.log({ ts: new Date().toISOString(), ...entry });
 }
 export function getLatencyLogPath() {
     return LATENCY_LOG_FILE;
 }
+/** Resolve once all enqueued latency writes are on disk (tests/shutdown). */
+export function flushLatencyLog() {
+    return writer.flush();
+}
 export function readLatencyLog(limit = 100) {
     try {
         const content = fs.readFileSync(LATENCY_LOG_FILE, "utf-8");
@@ -37,8 +33,7 @@ export function readLatencyLog(limit = 100) {
     }
 }
 export function clearLatencyLog() {
-    try {
-        fs.writeFileSync(LATENCY_LOG_FILE, "");
-    }
-    catch { }
+    // Enqueue the truncate in the same serialized queue so a clear cannot race a
+    // pending drain. Await flushLatencyLog() if you need the file empty on disk.
+    writer.truncate();
 }

package/dist/clients/lsp/client.js

@@ -15,7 +15,8 @@ import { withTimeout } from "../deadline-utils.js";
 import { logLatency } from "../latency-logger.js";
 // vscode-jsonrpc v9 ships an `exports` map exposing the Node entry as the
 // `./node` subpath (no `.js`); the old `/node.js` file path no longer resolves.
-import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "../deps/vscode-jsonrpc.js";
+import { CancellationTokenSource, createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "../deps/vscode-jsonrpc.js";
+import { getAmbientAbortSignal } from "../safe-spawn.js";
 import { applyWorkspaceEdit } from "./edits.js";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
 import { ADVERTISED_POSITION_ENCODINGS, convertCharacterOffset, lineTextAt, negotiatePositionEncoding, } from "./position-encoding.js";
@@ -789,14 +790,19 @@ export async function navRequest(state, method, params,
 // When provided, the request is dropped if the document's version advances
 // (an edit landed) between send and response. Omit for non-single-file
 // requests (workspaceSymbol, call-hierarchy follow-ups) that have no version.
-staleCheckPath, timeoutMs = NAV_REQUEST_TIMEOUT_MS) {
+staleCheckPath, timeoutMs = NAV_REQUEST_TIMEOUT_MS, 
+// Cancels the in-flight request (LSP `$/cancelRequest`) when the turn is
+// abandoned. Defaults to the ambient abort signal set around dispatch/tool
+// handling, so callers get cancellation for free without a signature change
+// (#238 Item 1). Pass explicitly in tests.
+signal = getAmbientAbortSignal()) {
     if (!isClientAlive(state))
         return null;
     const normalizedPath = staleCheckPath !== undefined ? normalizeMapKey(staleCheckPath) : undefined;
     const requestVersion = normalizedPath !== undefined
         ? state.documentVersions.get(normalizedPath)
         : undefined;
-    const result = (await withTimeout(safeSendRequest(state.connection, method, params), timeoutMs).catch((err) => {
+    const result = (await withTimeout(safeSendRequest(state.connection, method, params, signal), timeoutMs).catch((err) => {
         if (err instanceof Error && err.message.startsWith("Timeout after")) {
             return undefined;
         }
@@ -1297,17 +1303,74 @@ async function safeSendNotification(connection, method, params) {
     }
 }
 // Helper to safely send requests - catches stream destruction
-async function safeSendRequest(connection, method, params) {
-    try {
-        return (await connection.sendRequest(method, params));
+async function safeSendRequest(connection, method, params, 
+// When provided, aborting the signal cancels the in-flight request via
+// vscode-jsonrpc's CancellationToken → an LSP `$/cancelRequest` notification,
+// so a server stops computing a result the agent has already abandoned (#238
+// Item 1). The rejection that follows is swallowed (treated as `undefined`).
+signal) {
+    // Already abandoned before we even sent — don't bother the server.
+    if (signal?.aborted)
+        return undefined;
+    let tokenSource;
+    let onAbort;
+    if (signal) {
+        tokenSource = new CancellationTokenSource();
+        onAbort = () => tokenSource?.cancel();
+        signal.addEventListener("abort", onAbort, { once: true });
     }
-    catch (err) {
-        if (isStreamError(err)) {
-            // Silently ignore - stream was destroyed
-            return undefined;
+    // Only pass a token when cancellation is wired, so the call shape is unchanged
+    // for the (many) requests without a signal.
+    const send = () => tokenSource
+        ? connection.sendRequest(method, params, tokenSource.token)
+        : connection.sendRequest(method, params);
+    try {
+        // One safe retry on ContentModified (-32801): the document changed under
+        // us, so the server discarded the request. A single retry beats returning
+        // empty — correctness-under-edit is pi-lens's whole hot path (#238 Item 2).
+        const MAX_ATTEMPTS = 2;
+        for (let attempt = 1;; attempt++) {
+            try {
+                return (await send());
+            }
+            catch (err) {
+                if (isStreamError(err) || isCancellationError(err)) {
+                    // Stream destroyed, or we cancelled the request on abort — either
+                    // way there is no result to return.
+                    return undefined;
+                }
+                if (isContentModifiedError(err)) {
+                    // Retry once (unless we've since been aborted); if it's still
+                    // ContentModified after that, return empty rather than throwing a
+                    // code callers don't understand. RequestFailed (-32803) and other
+                    // codes are permanent and fall through to the rethrow below.
+                    if (attempt < MAX_ATTEMPTS && !signal?.aborted)
+                        continue;
+                    return undefined;
+                }
+                throw err;
+            }
         }
-        throw err;
     }
+    finally {
+        if (signal && onAbort)
+            signal.removeEventListener("abort", onAbort);
+        tokenSource?.dispose();
+    }
+}
+// vscode-jsonrpc rejects a token-cancelled request with a `ResponseError` whose
+// code is `RequestCancelled` (-32800) or `ServerCancelled` (-32802). Treat both
+// as "no result" rather than a failure. (isStreamError also matches the
+// "cancelled" message text; this adds the structured error-code path.)
+function isCancellationError(err) {
+    const code = err?.code;
+    return code === -32800 || code === -32802;
+}
+// `ContentModified` (-32801): the document changed while the request was in
+// flight, so the server couldn't answer against a consistent state. Retryable —
+// the only LSP error code worth a second attempt on the edit hot path (#238).
+function isContentModifiedError(err) {
+    return err?.code === -32801;
 }
 // Helper to detect stream destruction / connection disposal errors.
 // vscode-jsonrpc throws these when the LSP server process exits while