@herbertgao/pi-extensions 2026.8.3 → 2026.8.5

package/node_modules/pi-lens/dist/clients/lsp/launch.js

@@ -12,8 +12,11 @@ import os from "node:os";
 import path from "node:path";
 import { isTestMode } from "../env-utils.js";
 import { getGlobalPiLensDir } from "../file-utils.js";
+import { isFullyQualified } from "../path-utils.js";
 import { findGlobalBinary } from "../package-manager.js";
 import { redactSecrets } from "../redact/secrets.js";
+import { classifySpawnFailure, SpawnFailureError, } from "../safe-spawn.js";
+import { getRubyVersionDirNamesAsync } from "./ruby-drive-dirs.js";
 const isWindows = process.platform === "win32";
 /**
  * Whether a resolved command must be spawned through a shell on Windows.
@@ -109,7 +112,7 @@ function getLiveWindowsPath() {
     }
     return _liveWindowsPath;
 }
-function buildAugmentedPath(basePath) {
+async function buildAugmentedPath(basePath) {
     const candidates = [];
     const nodeDir = path.dirname(process.execPath);
     if (nodeDir) {
@@ -125,16 +128,12 @@ function buildAugmentedPath(basePath) {
         candidates.push(PI_LENS_TOOLS_BIN_DIR);
         candidates.push(path.join(driveRoot, "Program Files", "Go", "bin"));
         candidates.push(path.join(driveRoot, "Go", "bin"));
-        // Ruby installer drops versioned dirs (e.g. Ruby34-x64) on the drive root — scan dynamically
-        try {
-            for (const entry of fs.readdirSync(driveRoot)) {
-                if (/^ruby\d/i.test(entry)) {
-                    candidates.push(path.join(driveRoot, entry, "bin"));
-                }
-            }
-        }
-        catch {
-            // drive root not readable — skip
+        // Ruby installer drops versioned dirs (e.g. Ruby34-x64) on the drive root.
+        // Read off the event loop and memoized once per process (#1137): a
+        // synchronous drive-root enumeration on every LSP spawn blocked the loop
+        // for the whole stall on a slow cloud/network-backed drive root.
+        for (const entry of await getRubyVersionDirNamesAsync(driveRoot)) {
+            candidates.push(path.join(driveRoot, entry, "bin"));
         }
     }
     // On Windows, merge the live registry PATH so newly installed tools are visible
@@ -339,10 +338,12 @@ function _attachErrorHandler(proc, context, logContext, rejectOnImmediateError)
                 err.message +
                 (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
         }
-        // If we have a reject function and this is an immediate spawn error, reject
-        if (rejectOnImmediateError &&
-            err.code === "ENOENT") {
-            rejectOnImmediateError(err);
+        // Preserve intent at the boundary instead of leaking a raw errno check.
+        if (rejectOnImmediateError && logContext) {
+            void classifySpawnFailure(err, {
+                command: logContext.command,
+                cwd: logContext.cwd,
+            }).then(rejectOnImmediateError);
         }
     });
     proc.on("close", (code, signal) => {
@@ -402,7 +403,7 @@ function _attachErrorHandler(proc, context, logContext, rejectOnImmediateError)
 export async function launchLSP(command, args = [], options = {}) {
     const cwd = String(options.cwd ?? process.cwd());
     const mergedEnv = { ...process.env, ...options.env };
-    const augmentedPath = buildAugmentedPath(resolvePathValue(mergedEnv));
+    const augmentedPath = await buildAugmentedPath(resolvePathValue(mergedEnv));
     const env = {
         ...mergedEnv,
         PATH: augmentedPath,
@@ -412,10 +413,10 @@ export async function launchLSP(command, args = [], options = {}) {
     // - If already absolute, use as-is
     // - If it's a simple command (no path separators), let system find it via PATH
     // - Otherwise, resolve relative to cwd
-    const isRelativePath = !path.isAbsolute(command) &&
+    const isRelativePath = !isFullyQualified(command) &&
         (command.includes(path.sep) || command.includes("/"));
     const explicitCommand = isRelativePath ? path.resolve(cwd, command) : command;
-    const resolvedCommand = !path.isAbsolute(command) &&
+    const resolvedCommand = !isFullyQualified(command) &&
         !command.includes(path.sep) &&
         !command.includes("/")
         ? (findBinaryOnPath(command, env) ?? explicitCommand)
@@ -428,7 +429,7 @@ export async function launchLSP(command, args = [], options = {}) {
     // If command not found, try npm global as fallback (handles PATH caching after install)
     let spawnCommand = resolvedCommand;
     // First, try to find in npm global if it's a simple command name
-    if (!path.isAbsolute(command) &&
+    if (!isFullyQualified(command) &&
         !command.includes(path.sep) &&
         !command.includes("/")) {
         const globalBinPath = await findGlobalBinary(command);
@@ -444,7 +445,8 @@ export async function launchLSP(command, args = [], options = {}) {
         /\.(cmd|bat)$/i.test(spawnCommand) &&
         !isCmdShimValid(spawnCommand)) {
         logSessionStart(`lsp cmd-shim-invalid: ${spawnCommand} target missing — skipping candidate`);
-        throw new Error(`LSP .cmd shim target not found: ${spawnCommand}. The npm package may not be installed.`);
+        const cause = Object.assign(new Error(`LSP .cmd shim target not found: ${spawnCommand}`), { code: "ENOENT" });
+        throw await classifySpawnFailure(cause, { command, cwd });
     }
     // P0 FIX: Never spawn .ps1 wrappers on Windows — they hang when PowerShell
     // execution policy is Restricted/AllSigned. Prefer .cmd or direct node.
@@ -466,7 +468,7 @@ export async function launchLSP(command, args = [], options = {}) {
     }
     catch (err) {
         // If spawn failed with simple command, try npm global
-        if (!path.isAbsolute(command) &&
+        if (!isFullyQualified(command) &&
             !command.includes(path.sep) &&
             !command.includes("/")) {
             const globalBinPath = await findGlobalBinary(command);
@@ -476,11 +478,11 @@ export async function launchLSP(command, args = [], options = {}) {
                 proc = trySpawn(globalBinPath, args, cwd, env, needsShellGlobal);
             }
             else {
-                throw err;
+                throw await classifySpawnFailure(err, { command, cwd });
             }
         }
         else {
-            throw err;
+            throw await classifySpawnFailure(err, { command, cwd });
         }
     }
     if (!proc.stdin || !proc.stdout || !proc.stderr) {
@@ -512,10 +514,14 @@ export async function launchLSP(command, args = [], options = {}) {
             let settled = false;
             // Attach error handler that can reject for immediate errors
             proc.on("error", (err) => {
-                if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
+                if (!settled) {
                     settled = true;
-                    reject(new Error(`LSP server binary not found: ${command}. ` +
-                        `Install it or check your PATH.${formatStartupStderr(startupStderr)}`));
+                    void classifySpawnFailure(err, { command, cwd }).then((failure) => {
+                        const detail = formatStartupStderr(startupStderr);
+                        reject(detail
+                            ? new SpawnFailureError(failure.kind, `${failure.message}${detail}`, failure.cause)
+                            : failure);
+                    });
                 }
             });
             // Also listen for immediate exit

package/node_modules/pi-lens/dist/clients/lsp/path-utils.js

@@ -2,4 +2,4 @@
  * Re-export from shared path-utils.
  * Kept as a local module for LSP imports that use relative paths.
  */
-export { isUnderDir, normalizeFilePath, normalizeMapKey, pathsEqual, pathToUri, uriToPath, } from "../path-utils.js";
+export { isUnderDir, normalizeFilePath, normalizeEphemeralMapKey, normalizeMapKey, pathsEqual, pathToUri, uriToDiskPath, uriToPath, } from "../path-utils.js";

package/node_modules/pi-lens/dist/clients/lsp/ruby-drive-dirs.js

@@ -0,0 +1,83 @@
+/**
+ * Windows Ruby-installer drive-root version-dir discovery (refs #1137).
+ *
+ * The Ruby installer drops versioned directories (e.g. `Ruby34-x64`) directly
+ * at a drive root, and the drive and version suffix vary — so both the LSP
+ * candidate builder (`rubyBinCandidates`) and the spawn PATH augmenter
+ * (`buildAugmentedPath`) scan the drive root for `ruby<N>...` directories.
+ *
+ * Enumerating a drive root **synchronously on every LSP spawn** was a genuine
+ * #1137 event-loop offender: a stalled cloud/network-backed drive-root
+ * `readdirSync` blocks the Node loop (and pi's TUI) for the entire stall. This
+ * module makes that enumeration:
+ *   1. **O(1) amortized** — the matching directory names are memoized for the
+ *      process (the set is static for a session; the previous inline code
+ *      equally required a restart to notice a new Ruby install on PATH), and
+ *   2. **non-blocking on the hot path** — `buildAugmentedPath` (called on every
+ *      spawn) reads the drive root via `fs.promises.readdir` off the loop.
+ *
+ * Both readers share ONE cache keyed by `driveRoot`, so at most one drive-root
+ * read happens per drive per process regardless of which reader runs first.
+ * Callers derive their own paths from the returned directory NAMES (the two
+ * readers build different suffixes: `bin/<tool>` vs `bin`), so only the raw
+ * `ruby<N>` names are cached.
+ */
+import { BoundedLruCache } from "../bounded-cache.js";
+import { normalizeMapKey } from "../path-utils.js";
+import * as fs from "node:fs";
+/** Matches the Ruby installer's `Ruby34-x64`, `ruby3.3`, … drive-root dirs. */
+const RUBY_VERSION_DIR = /^ruby\d/i;
+/** Process-lifetime memo of matching dir names, keyed by drive root (e.g. `C:\`). */
+const rubyDirNamesCache = new BoundedLruCache(16);
+function rubyDriveKey(driveRoot) {
+    return normalizeMapKey(driveRoot);
+}
+function filterRubyDirNames(entries) {
+    return entries.filter((name) => RUBY_VERSION_DIR.test(name));
+}
+/**
+ * Memoized **synchronous** enumeration for sync callers (`rubyBinCandidates`).
+ * First call reads the drive root once (fail-open to `[]` on an unreadable
+ * root); every later call is a cache hit. If an async caller populated the
+ * cache first, this returns that result with no drive-root read at all.
+ */
+export function getRubyVersionDirNamesSync(driveRoot) {
+    const key = rubyDriveKey(driveRoot);
+    const cached = rubyDirNamesCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    let names;
+    try {
+        names = filterRubyDirNames(fs.readdirSync(driveRoot));
+    }
+    catch {
+        names = [];
+    }
+    rubyDirNamesCache.set(key, names);
+    return names;
+}
+/**
+ * Memoized **async** twin for the hot spawn path (`buildAugmentedPath`) — reads
+ * the drive root via `fs.promises.readdir` so a slow/stalled cloud-backed drive
+ * root never blocks the event loop. Shares the same process cache as the sync
+ * reader (identical content, so a benign sync/async populate race is fine).
+ */
+export async function getRubyVersionDirNamesAsync(driveRoot) {
+    const key = rubyDriveKey(driveRoot);
+    const cached = rubyDirNamesCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    let names;
+    try {
+        names = filterRubyDirNames(await fs.promises.readdir(driveRoot));
+    }
+    catch {
+        names = [];
+    }
+    rubyDirNamesCache.set(key, names);
+    return names;
+}
+/** Test-only: clear the process memo so each case starts cold. */
+export function __resetRubyDriveDirsCacheForTest() {
+    rubyDirNamesCache.clear();
+}

package/node_modules/pi-lens/dist/clients/lsp/server.js

@@ -6,13 +6,14 @@
  * - Auto-installation strategies
  * - Platform-specific handling
  */
-import { existsSync, mkdirSync, readdirSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { access, readFile, readdir, stat, } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { getGlobalPiLensDir } from "../file-utils.js";
+import { getGlobalPiLensDir, getProjectIgnoreGlobs, isPathIgnoredByProject, } from "../file-utils.js";
+import { STAGE_TMP_PATTERN } from "../atomic-write-staging.js";
 import { DOTNET_CSHARP_ROOT_MARKERS, DOTNET_FSHARP_ROOT_MARKERS, KIND_EXTENSIONS, } from "../file-kinds.js";
-import { direntsHaveMarkerGlobMatch, isAtOrAboveHomeDir, } from "../path-utils.js";
+import { direntsHaveMarkerGlobMatch, isAtOrAboveHomeDir, isFullyQualified, } from "../path-utils.js";
 import { ensureTool, getToolEnvironment, getToolPath, } from "../installer/index.js";
 import { resolveOpengrepConfig } from "../opengrep-config.js";
 import { isZizmorAuditTarget, resolveZizmorGitHubToken } from "../zizmor-config.js";
@@ -22,40 +23,198 @@ import { findLocalSgconfig, resolveBaselineSgconfig } from "../sgconfig.js";
 import { findLocalTyposConfig } from "../typos-config.js";
 import { resolvePackagePath } from "../package-root.js";
 import { resolveAstGrepNativeExe } from "./wait-policy/index.js";
-import { isCommandAvailableAsync, safeSpawnAsync } from "../safe-spawn.js";
+import { hasSpawnFailureKind, isCommandAvailableAsync, safeSpawnAsync, } from "../safe-spawn.js";
 import { launchLSP } from "./launch.js";
 import { createLombokJdtlsArgs } from "./lombok.js";
 import { resolveJavaRuntimeEnv } from "./jvm-runtime.js";
 import { normalizeMapKey } from "./path-utils.js";
+import { getRubyVersionDirNamesSync } from "./ruby-drive-dirs.js";
+const FIXTURE_ROOT_SEGMENTS = new Set(["__fixtures__", "testdata"]);
+const FALLBACK_PROJECT_MARKERS = [
+    ".git",
+    "package.json",
+    "go.work",
+    "go.mod",
+    "Cargo.toml",
+    "pyproject.toml",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "mix.exs",
+    "pubspec.yaml",
+    "Package.swift",
+];
+/**
+ * Markers that make a nested root an independently hosted project rather than
+ * a config-only directory that should share an ancestor's LSP client.
+ */
+const PROJECT_BOUNDARY_MARKERS = [
+    "package.json",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "bun.lock",
+    "bun.lockb",
+    "go.work",
+    "go.mod",
+    "Cargo.toml",
+    "Cargo.lock",
+    "pyproject.toml",
+    "uv.lock",
+    "poetry.lock",
+    "Pipfile",
+    "Pipfile.lock",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "settings.gradle",
+    "settings.gradle.kts",
+    "mix.exs",
+    "pubspec.yaml",
+    "Package.swift",
+];
+// This is process-global state, so each candidate pair is logged once per
+// process (not once per session). Keep the root-boundary marker below aligned
+// with FALLBACK_PROJECT_MARKERS, the shared fallback root-policy marker set.
+const loggedRootCeilingClamps = new Set();
+function isSameOrWithin(ancestor, candidate) {
+    const relative = path.relative(path.resolve(ancestor), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+/** Enforce the session cwd as the hard boundary for LSP client root selection. */
+export function enforceLspRootCeiling(root, sessionCwd, filePath) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedCwd = path.resolve(sessionCwd);
+    // Callers may explicitly inspect an out-of-session file (notably isolated
+    // tests and API consumers). The cwd ceiling governs roots for files that are
+    // actually inside the declared session project.
+    if (filePath && !isSameOrWithin(resolvedCwd, path.resolve(filePath))) {
+        return resolvedRoot;
+    }
+    if (isSameOrWithin(resolvedCwd, resolvedRoot))
+        return resolvedRoot;
+    const logKey = `${normalizeMapKey(resolvedCwd)}:${normalizeMapKey(resolvedRoot)}`;
+    if (!loggedRootCeilingClamps.has(logKey)) {
+        loggedRootCeilingClamps.add(logKey);
+        logSessionStart(`lsp root clamped to session cwd: candidate=${resolvedRoot} cwd=${resolvedCwd}`);
+    }
+    return resolvedCwd;
+}
+export async function hasProjectBoundaryMarker(dir) {
+    // A nested Git checkout is an independently hosted project even when it has
+    // no language manifest. Keep this directory boundary aligned with the shared
+    // FALLBACK_PROJECT_MARKERS policy used by nearestNonExcludedFallbackRoot.
+    if (await markerExists(dir, ".git"))
+        return true;
+    for (const marker of PROJECT_BOUNDARY_MARKERS) {
+        if (await markerExists(dir, marker))
+            return true;
+    }
+    return false;
+}
+function pathSegments(dir) {
+    const parsed = path.parse(path.resolve(dir));
+    return path
+        .relative(parsed.root, path.resolve(dir))
+        .split(path.sep)
+        .filter(Boolean)
+        .map((segment) => segment.toLowerCase());
+}
+function hasFixtureConvention(dir) {
+    const segments = pathSegments(dir);
+    // Go treats any directory named testdata as fixture data by convention. The
+    // exclusion is intentionally ancestor-wide so nested fixture projects cannot
+    // become independent LSP roots, but the segment match itself stays exact.
+    if (segments.some((segment) => FIXTURE_ROOT_SEGMENTS.has(segment)))
+        return true;
+    return segments.some((segment, index) => segment === "tests" && segments[index + 1] === "fixtures");
+}
+function hasAtomicStageSegment(dir) {
+    return pathSegments(dir).some((segment) => STAGE_TMP_PATTERN.test(segment));
+}
+async function findGitBoundary(dir) {
+    let current = path.resolve(dir);
+    const fsRoot = path.parse(current).root;
+    while (true) {
+        if (await markerExists(current, ".git"))
+            return current;
+        if (current === fsRoot)
+            return undefined;
+        current = path.dirname(current);
+    }
+}
+async function isExcludedLspRoot(dir) {
+    const candidate = path.resolve(dir);
+    if (hasFixtureConvention(candidate) || hasAtomicStageSegment(candidate))
+        return true;
+    const gitRoot = await findGitBoundary(candidate);
+    if (!gitRoot || gitRoot === candidate)
+        return false;
+    // Avoid constructing the matcher when the project has no positive ignore rules.
+    // The matcher remains authoritative (including anchored rules and directory form).
+    if (getProjectIgnoreGlobs(gitRoot).length === 0)
+        return false;
+    return isPathIgnoredByProject(candidate, gitRoot, true);
+}
+async function nearestNonExcludedFallbackRoot(candidate) {
+    if (!(await isExcludedLspRoot(candidate)))
+        return path.resolve(candidate);
+    let current = path.dirname(path.resolve(candidate));
+    const fsRoot = path.parse(current).root;
+    let nearestAllowed;
+    while (true) {
+        if (!(await isExcludedLspRoot(current))) {
+            nearestAllowed ??= current;
+            for (const marker of FALLBACK_PROJECT_MARKERS) {
+                if (await markerExists(current, marker))
+                    return current;
+            }
+        }
+        if (current === fsRoot)
+            break;
+        current = path.dirname(current);
+    }
+    // No project marker was available. Keep the file attached to a stable,
+    // non-excluded ancestor rather than minting a client inside the fixture/stage.
+    return nearestAllowed ?? fsRoot;
+}
 function isLspInstallDisabled() {
     return process.env.PI_LENS_DISABLE_LSP_INSTALL === "1";
 }
 function canInstall(allowInstall) {
     return allowInstall !== false && !isLspInstallDisabled();
 }
-function isCommandNotFoundError(error) {
-    const msg = String(error);
-    return (msg.includes("not found") ||
-        msg.includes("ENOENT") ||
-        msg.includes("not recognized"));
-}
 const DIRECT_LSP_NEGATIVE_TTL_MS = Math.max(30_000, Number.parseInt(process.env.PI_LENS_DIRECT_LSP_NEGATIVE_TTL_MS ?? "600000", 10) || 600_000);
 const directLspCommandUnavailableUntil = new Map();
 const directLspCommandSkipLoggedUntil = new Map();
+function pruneExpiredDirectLspNegativeEntries(now = Date.now()) {
+    for (const [command, until] of directLspCommandUnavailableUntil) {
+        if (until <= now) {
+            directLspCommandUnavailableUntil.delete(command);
+            directLspCommandSkipLoggedUntil.delete(command);
+        }
+    }
+    for (const [command, until] of directLspCommandSkipLoggedUntil) {
+        if (until <= now)
+            directLspCommandSkipLoggedUntil.delete(command);
+    }
+}
 function isSimpleCommand(command) {
-    return (!path.isAbsolute(command) &&
+    return (!isFullyQualified(command) &&
         !command.includes("/") &&
         !command.includes("\\"));
 }
 export function isDirectLspCommandTemporarilyUnavailable(command) {
+    const now = Date.now();
+    pruneExpiredDirectLspNegativeEntries(now);
     const until = directLspCommandUnavailableUntil.get(command);
-    if (!until || until <= Date.now()) {
+    if (!until || until <= now) {
         directLspCommandUnavailableUntil.delete(command);
         return false;
     }
     const loggedUntil = directLspCommandSkipLoggedUntil.get(command) ?? 0;
-    if (loggedUntil <= Date.now()) {
-        logSessionStart(`lsp direct command ${command}: skipped by negative availability cache (${Math.max(0, until - Date.now())}ms remaining)`);
+    if (loggedUntil <= now) {
+        logSessionStart(`lsp direct command ${command}: skipped by negative availability cache (${Math.max(0, until - now)}ms remaining)`);
         directLspCommandSkipLoggedUntil.set(command, until);
     }
     return true;
@@ -74,7 +233,7 @@ export async function resolveAndLaunch(spec, allowInstall) {
     let lastRuntimeFailure;
     const trackRuntimeFailure = (err) => {
         const message = err instanceof Error ? err.message : String(err);
-        if (!isCommandNotFoundError(message)) {
+        if (!hasSpawnFailureKind(err, "tool-not-found")) {
             lastRuntimeFailure = err instanceof Error ? err : new Error(message);
         }
     };
@@ -145,6 +304,12 @@ export async function resolveAndLaunch(spec, allowInstall) {
         logSessionStart(`lsp launch candidate failed tool=${toolLabel} idx=${failure.index} command=${failure.command} error=${failure.message}`);
         trackRuntimeFailure(failure.err);
     }
+    const hasOnlyRepairableCandidateFailures = candidateFailures.every((failure) => hasSpawnFailureKind(failure.err, "tool-not-found"));
+    if (!hasOnlyRepairableCandidateFailures) {
+        if (lastRuntimeFailure)
+            throw lastRuntimeFailure;
+        return undefined;
+    }
     if (!canInstall(allowInstall)) {
         logSessionStart(`lsp launch install blocked tool=${toolLabel} cwd=${spec.cwd} allowInstall=${allowInstall !== false} globalDisabled=${isLspInstallDisabled()}`);
         logLatency({
@@ -214,7 +379,7 @@ export async function resolveAndLaunch(spec, allowInstall) {
                 // fails to launch (e.g. broken symlink, missing .dll), nuke the
                 // caches and download a managed copy from the registry.
                 const looksPathResolved = !installed.includes("/") && !installed.includes("\\");
-                if (looksPathResolved) {
+                if (looksPathResolved && hasSpawnFailureKind(err, "tool-not-found")) {
                     logSessionStart(`lsp launch managed retry force-reinstall tool=${spec.managedToolId}`);
                     const reinstalled = await ensureTool(spec.managedToolId, {
                         forceReinstall: true,
@@ -415,19 +580,13 @@ function rubyBinCandidates(baseName) {
     candidates.push(path.join(home, ".asdf", "installs", "ruby", "bin", `${baseName}${ext}`));
     if (isWin) {
         // Ruby installer drops versioned dirs on C: by convention, but the drive
-        // and version suffix vary — scan what's actually present instead of hardcoding
+        // and version suffix vary — scan what's actually present instead of
+        // hardcoding. Memoized once per process (#1137): a synchronous drive-root
+        // enumeration per LSP spawn was an event-loop offender.
         const driveRoot = path.parse(home).root; // e.g. "C:\"
-        try {
-            const entries = readdirSync(driveRoot);
-            for (const entry of entries) {
-                if (/^ruby\d/i.test(entry)) {
-                    candidates.push(path.join(driveRoot, entry, "bin", `${baseName}.bat`));
-                    candidates.push(path.join(driveRoot, entry, "bin", baseName));
-                }
-            }
-        }
-        catch {
-            // drive root not readable — skip
+        for (const entry of getRubyVersionDirNamesSync(driveRoot)) {
+            candidates.push(path.join(driveRoot, entry, "bin", `${baseName}.bat`));
+            candidates.push(path.join(driveRoot, entry, "bin", baseName));
         }
     }
     return candidates;
@@ -465,7 +624,7 @@ function createInteractiveServer(spec) {
                 return { process: proc, source: "direct", initialization };
             }
             catch (err) {
-                if (isCommandNotFoundError(err)) {
+                if (hasSpawnFailureKind(err, "tool-not-found")) {
                     markDirectLspCommandUnavailable(command);
                 }
                 return undefined;
@@ -484,7 +643,10 @@ export function PriorityRoot(markerGroups, excludePatterns, stopDir) {
         return undefined;
     };
 }
-export const FileDirRoot = async (file) => path.resolve(path.dirname(file));
+export const FileDirRoot = async (file) => {
+    const candidate = path.resolve(path.dirname(file));
+    return nearestNonExcludedFallbackRoot(candidate);
+};
 export function RootWithFallback(primary, fallback = FileDirRoot) {
     return async (file) => {
         const primaryRoot = await primary(file);
@@ -597,8 +759,10 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
                 // Check include patterns. Exact marker names stay cheap (`stat`), while
                 // glob markers like `*.csproj` match real project filenames (#201).
                 for (const pattern of includePatterns) {
-                    if (await markerExists(currentDir, pattern))
-                        return currentDir;
+                    if ((await markerExists(currentDir, pattern)) &&
+                        !(await isExcludedLspRoot(currentDir))) {
+                        return enforceLspRootCeiling(currentDir, process.cwd(), file);
+                    }
                 }
                 if (currentDir === stop || currentDir === fsRoot) {
                     break;

package/node_modules/pi-lens/dist/clients/lsp/workspace-diagnostics-cache.js

@@ -1,9 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "../file-utils.js";
+import { writeFileAtomic } from "../atomic-write.js";
 import { readJsonCache } from "../json-cache-read.js";
 import { normalizeMapKey } from "../path-utils.js";
 import { loadReverseDependencyIndexFromSnapshot } from "../reverse-deps.js";
+import { createDiskBindingCache, } from "./diagnostic-binding.js";
 /**
  * #671: per-file cache of the last CONFIRMED `runWorkspaceDiagnostics` sweep
  * result, so a repeat `lens_diagnostics mode=full` with no intervening edits
@@ -24,7 +26,12 @@ import { loadReverseDependencyIndexFromSnapshot } from "../reverse-deps.js";
  * `LSPWorkspaceDiagnosticResult.timedOut` in `./index.ts`) into
  * `WorkspaceDiagnosticsCacheEntry`.
  */
-export const WORKSPACE_DIAGNOSTICS_CACHE_VERSION = 1;
+// v2 (#1095): entries may carry an optional `contentHash` fingerprint of the
+// file bytes the cached diagnostics were computed against, so a `lookup` can
+// surface a content `binding` (boundToCurrentDisk) beyond the mtime proxy.
+// Legacy v1 entries are rejected by the version guard and re-scanned — a
+// deliberately clean break so no entry lacking the field is ever served.
+export const WORKSPACE_DIAGNOSTICS_CACHE_VERSION = 2;
 const CACHE_FILE = "lsp-workspace-diagnostics.json";
 function cachePath(cwd) {
     return path.join(getProjectDataDir(cwd), "cache", CACHE_FILE);
@@ -48,7 +55,11 @@ export function loadWorkspaceDiagnosticsCache(cwd) {
 export function saveWorkspaceDiagnosticsCache(cwd, cache) {
     const filePath = cachePath(cwd);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(cache, null, 2));
+    // bestEffort: false — persist()'s catch is the error policy here, and it
+    // must observe the failure so `dirty` stays set and the next sweep retries.
+    writeFileAtomic(filePath, JSON.stringify(cache, null, 2), {
+        bestEffort: false,
+    });
 }
 /**
  * True when `filePath`'s cached entry is still trustworthy enough to reuse
@@ -133,6 +144,8 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
             return undefined;
         return reverseDepsIndex.imports[cacheKeyFor(filePath)] ?? [];
     };
+    // #1095: per-sweep disk-fingerprint memo (per file+mtime) for binding verify.
+    const diskBindingCache = createDiskBindingCache();
     let dirty = false;
     return {
         lookup(filePath, scopeKey) {
@@ -141,15 +154,26 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
                 return undefined;
             if (!isEntryFresh(filePath, entry, getImports))
                 return undefined;
-            return { diagnostics: entry.diagnostics, count: entry.count };
+            return {
+                diagnostics: entry.diagnostics,
+                count: entry.count,
+                binding: {
+                    contentHash: entry.contentHash,
+                    boundToCurrentDisk: diskBindingCache.boundToCurrentDisk(filePath, {
+                        contentHash: entry.contentHash,
+                    }),
+                },
+                scannedAt: entry.scannedAt,
+            };
         },
-        record(filePath, scopeKey, diagnostics, mtimeMs) {
+        record(filePath, scopeKey, diagnostics, mtimeMs, contentHash) {
             entries[cacheKeyFor(filePath)] = {
                 diagnostics,
                 count: diagnostics.length,
                 mtimeMs,
                 scannedAt: Date.now(),
                 scopeKey,
+                ...(contentHash !== undefined && { contentHash }),
             };
             dirty = true;
         },

package/node_modules/pi-lens/dist/clients/lsp-lazy.js

@@ -0,0 +1,8 @@
+/** Shared lazy LSP service seam (#1394). */
+let lspPromise;
+export function warmLspService() {
+    return (lspPromise ??= import("./lsp/index.js"));
+}
+export function loadLspService() {
+    return warmLspService();
+}