pi-lens 4.4.3 → 4.4.4

package/dist/{chunk-EU63SDCG.js → chunk-3DA2JDOL.js}

@@ -1,36 +1,36 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   resolveOpengrepConfig
-} from "./chunk-VWCXW2E7.js";
+} from "./chunk-HWCCCQNX.js";
 import {
   augmentPythonEnvironment,
   detectPythonEnvironment,
   detectPythonVenv,
   pythonEnvironmentToolCandidates
-} from "./chunk-FCSOVF55.js";
+} from "./chunk-CUHSHSB6.js";
 import {
   resolveGitCheckout,
   resolveLinkedWorktreeOwner
-} from "./chunk-PNQDPDRC.js";
+} from "./chunk-UA7ZXYDR.js";
+import {
+  hasCargoWorkspaceTable,
+  readCargoWorkspaceExclude,
+  readCargoWorkspaceMembers,
+  readTextFileOrUndefined
+} from "./chunk-MPNJLASA.js";
 import {
   extensionsForLanguage,
   getUserRuleRoot,
   ruleCorpusFingerprintForCycle
-} from "./chunk-724UL2TJ.js";
+} from "./chunk-GXFV6MYU.js";
 import {
   load,
   resolvePackagePath
-} from "./chunk-QOZXJ4NA.js";
-import {
-  hasCargoWorkspaceTable,
-  readCargoWorkspaceExclude,
-  readCargoWorkspaceMembers,
-  readTextFileOrUndefined
-} from "./chunk-P7266HLM.js";
+} from "./chunk-FM4RDMKT.js";
 import {
   HOOK_WALL_BUDGET_MS,
   bounded
-} from "./chunk-52FUZI6K.js";
+} from "./chunk-RMLC67LF.js";
 import {
   ensureTool,
   findManagedToolBinary,
@@ -40,27 +40,29 @@ import {
   isZizmorAuditTarget,
   logSessionStart,
   resolveZizmorGitHubToken
-} from "./chunk-ACXEQZOU.js";
+} from "./chunk-GAQ7OQG6.js";
 import {
   resolveToolCwd
-} from "./chunk-Q7DUK4LX.js";
+} from "./chunk-DEL2U6CM.js";
 import {
+  commandSearchReachesProject,
   findGlobalBinary,
   isProjectLocalBinPath
-} from "./chunk-AW7R2GWG.js";
+} from "./chunk-5VSF4UUQ.js";
 import {
   classifyProbeFailure,
   createAvailabilityLatch,
   describeInstallAttempt,
   logAvailabilityDecision,
   startHostStallSampler
-} from "./chunk-VRZP76YM.js";
+} from "./chunk-P63GXC37.js";
 import {
   OWNER_TAG_ENV,
   SpawnFailureError,
   classifySpawnFailure,
   createGenerationSource,
   ephemeralStagingRoot,
+  findCommandAsync,
   getGlobalPiLensDir,
   getProjectIgnoreGlobs,
   hasSpawnFailureKind,
@@ -71,13 +73,13 @@ import {
   ownerTagForChildren,
   resolveWindowsCommandForEnvironment,
   safeSpawnAsync
-} from "./chunk-C34ZXZ7O.js";
+} from "./chunk-KUA4OJ5Y.js";
 import {
   DOTNET_CSHARP_ROOT_MARKERS,
   DOTNET_FSHARP_ROOT_MARKERS,
   KIND_EXTENSIONS,
   LEAN_ROOT_MARKERS
-} from "./chunk-PHDMFAKM.js";
+} from "./chunk-DUO2TU77.js";
 import {
   isRepoTier,
   lspSectionOf,
@@ -87,7 +89,7 @@ import {
   reportPiLensConfigRecords,
   resolvePiLensConfig,
   summarizeConfigResolution
-} from "./chunk-2BBLFX75.js";
+} from "./chunk-J6MPGQTS.js";
 import {
   FRESHNESS_CADENCE_MS,
   LSP_NAMESPACE_KEY,
@@ -95,30 +97,30 @@ import {
   dirMtimesStillFreshAsync,
   getPiLensGlobalConfigPath,
   unknownDirMtimeRecords
-} from "./chunk-XVF2VVXP.js";
+} from "./chunk-5HSRT26B.js";
 import {
   getProjectTrustState
-} from "./chunk-ZANLILYD.js";
+} from "./chunk-M2IFVFWU.js";
 import {
   getDegradationLedgerGeneration,
   incrementDegradationCount,
   recordDegradationOnce
-} from "./chunk-JAU72XNY.js";
+} from "./chunk-J64T55EI.js";
 import {
   logExtension
-} from "./chunk-XTMJ7XDT.js";
+} from "./chunk-POMLXPMY.js";
 import {
   claimPhaseOncePerSession,
   currentSessionRecordId,
   logLatency,
   releasePhaseClaim
-} from "./chunk-QQNQ7SJW.js";
+} from "./chunk-QBFBRV2B.js";
 import {
   getGlobalPiLensLogDir,
   getProcessSingleton,
   isTestMode,
   redactSecrets
-} from "./chunk-AOHZU2BM.js";
+} from "./chunk-YNE3RP52.js";
 import {
   STAGE_TMP_PATTERN
 } from "./chunk-LJDODBBZ.js";
@@ -141,7 +143,7 @@ import {
   normalizeMapKey,
   pathsEqual,
   toPosix
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 import {
   __require
 } from "./chunk-NXL4FFQQ.js";
@@ -245,17 +247,45 @@ function canWriteAnalysisRoot(mode) {
   return mode === "session" || mode === "linked-worktree";
 }
 
+// dist/clients/lsp/file-server-match.js
+import path from "node:path";
+function fileMatchKeys(filePath) {
+  return {
+    ext: path.extname(filePath).toLowerCase(),
+    base: path.basename(filePath).toLowerCase()
+  };
+}
+function fileMatchReason(server, filePath, ext, base) {
+  let matched = false;
+  for (const value of server.extensions) {
+    const lower = value.toLowerCase();
+    if (lower === ext || lower === base) {
+      matched = true;
+      break;
+    }
+  }
+  if (!matched)
+    return "extension-mismatch";
+  if (server.pathFilter && !server.pathFilter(filePath))
+    return "path-filter";
+  return "selected";
+}
+function registeredServers(config, catalog) {
+  const builtins = config.registeredServers.length ? config.registeredServers : catalog;
+  return [...builtins, ...config.customServers];
+}
+
 // dist/clients/lsp/server.js
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, statSync as statSync4 } from "node:fs";
-import { access, readFile, readdir, stat } from "node:fs/promises";
+import { access, readFile, readdir, realpath, stat } from "node:fs/promises";
 import os7 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 
 // dist/clients/sgconfig.js
 import { createHash } from "node:crypto";
 import * as fs2 from "node:fs";
 import * as os2 from "node:os";
-import * as path from "node:path";
+import * as path2 from "node:path";
 var SGCONFIG_NAMES = ["sgconfig.yml", "sgconfig.yaml"];
 function findLocalSgconfig(startDir) {
   return findLocalToolConfig(startDir, SGCONFIG_NAMES);
@@ -264,20 +294,20 @@ function canonicalDir(dir) {
   try {
     return fs2.realpathSync.native(dir);
   } catch {
-    return path.resolve(dir);
+    return path2.resolve(dir);
   }
 }
 function getAstGrepRuleSources(projectRoot = process.cwd()) {
-  const root = path.resolve(projectRoot || process.cwd());
+  const root = path2.resolve(projectRoot || process.cwd());
   const packageRoot = resolvePackagePath(import.meta.url);
   const candidates = [];
   if (canonicalDir(root) !== canonicalDir(packageRoot)) {
     candidates.push({
-      dir: path.join(root, "rules", "ast-grep-rules", "rules"),
+      dir: path2.join(root, "rules", "ast-grep-rules", "rules"),
       origin: "project",
       tier: "primary"
     }, {
-      dir: path.join(root, "rules", "ast-grep-rules", "coderabbit", "rules"),
+      dir: path2.join(root, "rules", "ast-grep-rules", "coderabbit", "rules"),
       origin: "project",
       tier: "secondary"
     });
@@ -285,21 +315,21 @@ function getAstGrepRuleSources(projectRoot = process.cwd()) {
   const userRoot = getUserRuleRoot();
   if (canonicalDir(userRoot) !== canonicalDir(root)) {
     candidates.push({
-      dir: path.join(userRoot, "ast-grep-rules", "rules"),
+      dir: path2.join(userRoot, "ast-grep-rules", "rules"),
       origin: "user",
       tier: "primary"
     }, {
-      dir: path.join(userRoot, "ast-grep-rules", "coderabbit", "rules"),
+      dir: path2.join(userRoot, "ast-grep-rules", "coderabbit", "rules"),
       origin: "user",
       tier: "secondary"
     });
   }
   candidates.push({
-    dir: path.join(packageRoot, "rules", "ast-grep-rules", "rules"),
+    dir: path2.join(packageRoot, "rules", "ast-grep-rules", "rules"),
     origin: "bundled",
     tier: "primary"
   }, {
-    dir: path.join(packageRoot, "rules", "ast-grep-rules", "coderabbit", "rules"),
+    dir: path2.join(packageRoot, "rules", "ast-grep-rules", "coderabbit", "rules"),
     origin: "bundled",
     tier: "secondary"
   });
@@ -323,7 +353,7 @@ function findYamlFiles(dir) {
     return files;
   }
   for (const entry of entries) {
-    const full = path.join(dir, entry.name);
+    const full = path2.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...findYamlFiles(full));
     } else if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
@@ -365,7 +395,7 @@ function snapshotRuleSource(source) {
   const hash = createHash("sha256");
   const files = [];
   for (const file of findYamlFiles(source.dir)) {
-    const relativePath = path.relative(source.dir, file);
+    const relativePath = path2.relative(source.dir, file);
     hash.update(relativePath);
     hash.update("\0");
     let content;
@@ -408,7 +438,7 @@ function sourceFingerprint(sources) {
   return hash.digest("hex");
 }
 function getAstGrepRuleFingerprint(projectRoot = process.cwd(), options = {}) {
-  const root = path.resolve(projectRoot || process.cwd());
+  const root = path2.resolve(projectRoot || process.cwd());
   return ruleCorpusFingerprintForCycle("ast-grep", root, (fingerprintRoot) => sourceFingerprint(getAstGrepRuleSources(fingerprintRoot).map(snapshotRuleSource)), options.force);
 }
 function materializeMergedRuleDir(sources, mergedDir) {
@@ -428,7 +458,7 @@ function materializeMergedRuleDir(sources, mergedDir) {
       });
       if (survivingDocuments.length === 0)
         continue;
-      const destination = path.join(mergedDir, `source${sourceIndex}-${String(fileIndex).padStart(5, "0")}.yml`);
+      const destination = path2.join(mergedDir, `source${sourceIndex}-${String(fileIndex).padStart(5, "0")}.yml`);
       if (survivingDocuments.length === file.documents.length) {
         fs2.copyFileSync(file.file, destination);
       } else {
@@ -445,7 +475,7 @@ function rootArtifactKey(root) {
   return createHash("sha256").update(root).digest("hex").slice(0, 12);
 }
 function resolveBaselineSgconfig(projectRoot = process.cwd()) {
-  const root = canonicalDir(path.resolve(projectRoot || process.cwd()));
+  const root = canonicalDir(path2.resolve(projectRoot || process.cwd()));
   const fingerprint = getAstGrepRuleFingerprint(root, { force: true });
   const cached = cachedBaselines.get(root);
   if (cached?.fingerprint === fingerprint && fs2.existsSync(cached.path) && fs2.existsSync(cached.mergedDir)) {
@@ -454,11 +484,11 @@ function resolveBaselineSgconfig(projectRoot = process.cwd()) {
   const sources = getAstGrepRuleSources(root).map(snapshotRuleSource);
   if (sources.length === 0)
     return void 0;
-  const dir = path.join(os2.tmpdir(), "pi-lens-ast-grep");
+  const dir = path2.join(os2.tmpdir(), "pi-lens-ast-grep");
   fs2.mkdirSync(dir, { recursive: true });
   const artifactKey = rootArtifactKey(root);
-  const file = path.join(dir, `baseline-${process.pid}-${artifactKey}.sgconfig.yml`);
-  const mergedDir = path.join(dir, `baseline-${process.pid}-${artifactKey}.rules`);
+  const file = path2.join(dir, `baseline-${process.pid}-${artifactKey}.sgconfig.yml`);
+  const mergedDir = path2.join(dir, `baseline-${process.pid}-${artifactKey}.rules`);
   const protectedArtifacts = /* @__PURE__ */ new Set([file, mergedDir]);
   for (const baseline of cachedBaselines.values()) {
     protectedArtifacts.add(baseline.path);
@@ -466,7 +496,7 @@ function resolveBaselineSgconfig(projectRoot = process.cwd()) {
   }
   cleanupStaleBaselines(dir, protectedArtifacts);
   materializeMergedRuleDir(sources, mergedDir);
-  const ruleDirForYaml = mergedDir.split(path.sep).join("/");
+  const ruleDirForYaml = mergedDir.split(path2.sep).join("/");
   fs2.writeFileSync(file, `ruleDirs:
   - ${JSON.stringify(ruleDirForYaml)}
 `);
@@ -488,7 +518,7 @@ function enforceBaselineEntryCap(dir, keep) {
     const isMergedDir = /^baseline-\d+(?:-[a-f0-9]+)?\.rules$/.test(name);
     if (!isConfig && !isMergedDir)
       continue;
-    const full = path.join(dir, name);
+    const full = path2.join(dir, name);
     if (keep.has(full))
       continue;
     try {
@@ -536,7 +566,7 @@ function cleanupStaleBaselines(dir, keep) {
       const isMergedDir = /^baseline-\d+(?:-[a-f0-9]+)?\.rules$/.test(name);
       if (!isConfig && !isMergedDir)
         continue;
-      const full = path.join(dir, name);
+      const full = path2.join(dir, name);
       if (keep.has(full))
         continue;
       try {
@@ -598,7 +628,7 @@ function serverTraits(declaration) {
 
 // dist/clients/lsp/config.js
 import * as os4 from "node:os";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // dist/clients/dispatch/known-runner-ids.js
 var knownRunnerIds = /* @__PURE__ */ new Set();
@@ -617,7 +647,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { execFileSync, spawn as nodeSpawn } from "node:child_process";
 import fs4 from "node:fs";
 import os3 from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // dist/clients/lsp/ruby-drive-dirs.js
 import * as fs3 from "node:fs";
@@ -667,9 +697,9 @@ function computeNeedsShell(resolvedCommand) {
 var DEFAULT_STARTUP_FAILURE_WINDOW_MS = 50;
 var WINDOWS_NAV_STARTUP_FAILURE_WINDOW_MS = 500;
 var SESSIONSTART_LOG_DIR = getGlobalPiLensLogDir();
-var SESSIONSTART_LOG = path2.join(SESSIONSTART_LOG_DIR, "sessionstart.log");
-var PI_LENS_BIN_DIR = path2.join(getGlobalPiLensDir(), "bin");
-var PI_LENS_TOOLS_BIN_DIR = path2.join(getGlobalPiLensDir(), "tools", "node_modules", ".bin");
+var SESSIONSTART_LOG = path3.join(SESSIONSTART_LOG_DIR, "sessionstart.log");
+var PI_LENS_BIN_DIR = path3.join(getGlobalPiLensDir(), "bin");
+var PI_LENS_TOOLS_BIN_DIR = path3.join(getGlobalPiLensDir(), "tools", "node_modules", ".bin");
 function logSessionStart2(msg) {
   if (isTestMode()) {
     return;
@@ -698,8 +728,8 @@ function splitPathEntries(value, delimiter) {
 }
 function normalizePathEntry(entry, platform) {
   if (platform !== "win32")
-    return path2.posix.normalize(entry);
-  return path2.win32.normalize(entry).toLowerCase();
+    return path3.posix.normalize(entry);
+  return path3.win32.normalize(entry).toLowerCase();
 }
 function combinePathValuesForPlatform(values, platform = process.platform) {
   const unique = [];
@@ -754,27 +784,27 @@ function getLiveWindowsPath() {
 }
 async function buildAugmentedPath(basePath) {
   const candidates = [];
-  const nodeDir = path2.dirname(process.execPath);
+  const nodeDir = path3.dirname(process.execPath);
   if (nodeDir) {
     candidates.push(nodeDir);
   }
   if (isWindows) {
     const home = os3.homedir();
-    const driveRoot = path2.parse(home).root;
-    candidates.push(path2.join(home, ".cargo", "bin"));
-    candidates.push(path2.join(home, "go", "bin"));
-    candidates.push(path2.join(home, ".dotnet", "tools"));
+    const driveRoot = path3.parse(home).root;
+    candidates.push(path3.join(home, ".cargo", "bin"));
+    candidates.push(path3.join(home, "go", "bin"));
+    candidates.push(path3.join(home, ".dotnet", "tools"));
     candidates.push(PI_LENS_BIN_DIR);
     candidates.push(PI_LENS_TOOLS_BIN_DIR);
-    candidates.push(path2.join(driveRoot, "Program Files", "Go", "bin"));
-    candidates.push(path2.join(driveRoot, "Go", "bin"));
+    candidates.push(path3.join(driveRoot, "Program Files", "Go", "bin"));
+    candidates.push(path3.join(driveRoot, "Go", "bin"));
     for (const entry of await getRubyVersionDirNamesAsync(driveRoot)) {
-      candidates.push(path2.join(driveRoot, entry, "bin"));
+      candidates.push(path3.join(driveRoot, entry, "bin"));
     }
   }
   const effectiveBase = isWindows ? combinePathValuesForPlatform([basePath, getLiveWindowsPath()]) : basePath;
   const existing = /* @__PURE__ */ new Set();
-  for (const entry of splitPathEntries(effectiveBase, path2.delimiter)) {
+  for (const entry of splitPathEntries(effectiveBase, path3.delimiter)) {
     if (!entry)
       continue;
     existing.add(normalizePathEntry(entry, process.platform));
@@ -792,8 +822,8 @@ async function buildAugmentedPath(basePath) {
   if (toAppend.length === 0)
     return basePath ?? "";
   if (!basePath)
-    return toAppend.join(path2.delimiter);
-  return `${basePath}${path2.delimiter}${toAppend.join(path2.delimiter)}`;
+    return toAppend.join(path3.delimiter);
+  return `${basePath}${path3.delimiter}${toAppend.join(path3.delimiter)}`;
 }
 function isCmdShimValid(cmdPath) {
   try {
@@ -801,8 +831,8 @@ function isCmdShimValid(cmdPath) {
     const match = content.match(/"%~dp0[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
     if (!match)
       return true;
-    const relPath = match[1].replace(/[/\\]/g, path2.sep);
-    const target = path2.resolve(path2.dirname(cmdPath), "..", relPath);
+    const relPath = match[1].replace(/[/\\]/g, path3.sep);
+    const target = path3.resolve(path3.dirname(cmdPath), "..", relPath);
     return fs4.existsSync(target);
   } catch {
     return true;
@@ -827,8 +857,8 @@ function bypassPs1OnWindows(ps1Path, args) {
     const content = fs4.readFileSync(ps1Path, "utf-8");
     const match = content.match(/"\$basedir[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
     if (match) {
-      const relPath = match[1].replace(/[/\\]/g, path2.sep);
-      const jsPath = path2.resolve(path2.dirname(ps1Path), "..", relPath);
+      const relPath = match[1].replace(/[/\\]/g, path3.sep);
+      const jsPath = path3.resolve(path3.dirname(ps1Path), "..", relPath);
       if (fs4.existsSync(jsPath)) {
         return {
           command: process.execPath,
@@ -872,7 +902,7 @@ function withLspProjectCodePermission(allowed, spawn) {
 var unknownProjectLocalNoticeGeneration = -1;
 function recordUntrustedLspExecution(request, trust) {
   const generation = getDegradationLedgerGeneration();
-  const subject = request.kind === "project-code-server" ? `project-code-server:g${generation}:${request.serverId}:${request.root}` : `project-local-binary:g${generation}:${path2.basename(request.command)}`;
+  const subject = request.kind === "project-code-server" ? `project-code-server:g${generation}:${request.serverId}:${request.root}` : `project-local-binary:g${generation}:${path3.basename(request.command)}`;
   const metadata = request.kind === "project-code-server" ? {
     field: request.kind,
     serverId: request.serverId,
@@ -906,21 +936,43 @@ function refuseUntrustedLspExecution(request) {
     return;
   if (request.kind === "project-code-server")
     recordUntrustedLspExecution(request, trust);
-  throw new SpawnFailureError("spawn-failed", `LSP ${request.kind === "project-code-server" ? "project-code server" : "project-local binary"} refused: project trust is ${trust}`, new Error(`project trust is ${trust}`));
+  throw new SpawnFailureError(request.kind === "project-local-binary" ? "trust-refused" : "spawn-failed", `LSP ${request.kind === "project-code-server" ? "project-code server" : "project-local binary"} refused: project trust is ${trust}`, new Error(`project trust is ${trust}`));
 }
 function admitProjectSuppliedTsserver(tsserverPath, cwd, projectSupplied, projectCodeAllowed = lspProjectCodePermission.getStore() ?? false) {
   const trust = getProjectTrustState();
   if (tsserverPath && (!projectSupplied || projectCodeAllowed && trust === "trusted"))
     return tsserverPath;
+  if (!tsserverPath) {
+    recordUnresolvedTypeScriptCompiler(cwd, trust);
+    return void 0;
+  }
   recordUntrustedLspExecution({
     kind: "project-local-binary",
-    command: tsserverPath ?? "tsserver.js",
-    resolvedCommand: tsserverPath ?? "tsserver.js",
+    command: tsserverPath,
+    resolvedCommand: tsserverPath,
     cwd,
-    reason: tsserverPath ? "LSP execution refused: project compiler requires trusted session ownership" : "LSP execution refused: no admitted absolute TypeScript compiler"
+    reason: "LSP execution refused: project compiler requires trusted session ownership"
   }, trust);
   return void 0;
 }
+function recordUnresolvedTypeScriptCompiler(cwd, trust) {
+  const generation = getDegradationLedgerGeneration();
+  recordDegradationOnce({
+    kind: "lsp-registry-decision",
+    subject: `typescript-compiler:g${generation}:${cwd}`,
+    reason: "LSP not started: no absolute TypeScript compiler (tsserver.js) was resolved",
+    metadata: { field: "typescript-compiler", trust }
+  });
+  if (unknownProjectLocalNoticeGeneration === generation)
+    return;
+  unknownProjectLocalNoticeGeneration = generation;
+  logExtension({
+    subsystem: "lsp-registry",
+    level: "warn",
+    message: "TypeScript language server not started: no absolute TypeScript compiler (tsserver.js) could be resolved; install typescript in the project or let pi-lens install it",
+    metadata: { field: "typescript-compiler" }
+  });
+}
 function isProjectLocalLspBinary(resolvedCommand, cwd) {
   return isProjectLocalBinPath(resolvedCommand, cwd);
 }
@@ -1015,12 +1067,12 @@ async function launchLSP(command, args = [], options = {}) {
     delete env[OWNER_TAG_ENV];
   else
     env[OWNER_TAG_ENV] = ownerTag;
-  const isRelativePath = !isFullyQualified(command) && (command.includes(path2.sep) || command.includes("/"));
-  const explicitCommand = isRelativePath ? path2.resolve(cwd, command) : command;
-  const resolvedCommand = !isFullyQualified(command) && !command.includes(path2.sep) && !command.includes("/") ? findBinaryOnPath(command, env) ?? explicitCommand : explicitCommand;
+  const isRelativePath = !isFullyQualified(command) && (command.includes(path3.sep) || command.includes("/"));
+  const explicitCommand = isRelativePath ? path3.resolve(cwd, command) : command;
+  const resolvedCommand = !isFullyQualified(command) && !command.includes(path3.sep) && !command.includes("/") ? findBinaryOnPath(command, env) ?? explicitCommand : explicitCommand;
   let needsShell = computeNeedsShell(resolvedCommand);
   let spawnCommand = resolvedCommand;
-  if (!isFullyQualified(command) && !command.includes(path2.sep) && !command.includes("/")) {
+  if (!isFullyQualified(command) && !command.includes(path3.sep) && !command.includes("/")) {
     const globalBinPath = await findGlobalBinary(command);
     if (globalBinPath) {
       spawnCommand = globalBinPath;
@@ -1055,7 +1107,7 @@ async function launchLSP(command, args = [], options = {}) {
   try {
     proc = trySpawn(spawnCommand, args, cwd, env, needsShell);
   } catch (err) {
-    if (!isFullyQualified(command) && !command.includes(path2.sep) && !command.includes("/")) {
+    if (!isFullyQualified(command) && !command.includes(path3.sep) && !command.includes("/")) {
       const globalBinPath = await findGlobalBinary(command);
       if (globalBinPath && globalBinPath !== spawnCommand) {
         const needsShellGlobal = computeNeedsShell(globalBinPath);
@@ -1161,7 +1213,7 @@ function asRecord(value) {
 }
 var CONFIG_RESOLVED_PHASE = "config_resolved";
 function configResolutionKey(cwd) {
-  return normalizeFilePath(path3.resolve(normalizeFilePath(cwd)));
+  return normalizeFilePath(path4.resolve(normalizeFilePath(cwd)));
 }
 function publishConfigResolutionPending(cwd) {
   logSessionStart(`session_start config_resolution_pending session=${currentSessionRecordId()} root=${configResolutionKey(cwd)}`);
@@ -1392,7 +1444,7 @@ var EMPTY_CONFIG = {
 };
 var configInFlight = /* @__PURE__ */ new Map();
 function normalizeWorkspacePath(cwd) {
-  return path3.resolve(cwd);
+  return path4.resolve(cwd);
 }
 var unknownTrustNoticeGeneration = -1;
 function sourceFor(provenance, key) {
@@ -1436,24 +1488,8 @@ function registryDecision(id, field, provenance, trust, allowed) {
     }
   }
 }
-function isSameOrChildPath(filePath, candidateRoot) {
-  if (filePath === candidateRoot)
-    return true;
-  return filePath.startsWith(`${candidateRoot}${path3.sep}`);
-}
 function getConfigForFile(filePath) {
-  const resolvedFilePath = path3.resolve(filePath);
-  let bestMatch;
-  for (const [root, config] of sessionRootConfigEntries()) {
-    if (config === void 0)
-      continue;
-    if (!isSameOrChildPath(resolvedFilePath, root))
-      continue;
-    if (!bestMatch || root.length > bestMatch.root.length) {
-      bestMatch = { root, config };
-    }
-  }
-  return bestMatch?.config ?? EMPTY_CONFIG;
+  return sessionRootConfigForFile(filePath) ?? EMPTY_CONFIG;
 }
 function registerLSPConfig(config) {
   return compileLspRegistry(config, config.__provenance);
@@ -1564,40 +1600,22 @@ async function initLSPConfig(cwd) {
     }
   }
 }
-function registeredServers(config) {
-  const builtins = config.registeredServers.length ? config.registeredServers : LSP_SERVERS;
-  return [...builtins, ...config.customServers];
-}
 function selectionReason(server, config, filePath, ext, base) {
   if (config.disabledServerIds.has(server.id))
     return "disabled-by-config";
-  let matched = false;
-  for (const value of server.extensions) {
-    const lower = value.toLowerCase();
-    if (lower === ext || lower === base) {
-      matched = true;
-      break;
-    }
-  }
-  if (!matched)
-    return "extension-mismatch";
-  if (server.pathFilter && !server.pathFilter(filePath))
-    return "path-filter";
-  return "selected";
+  return fileMatchReason(server, filePath, ext, base);
 }
 function explainServersForFile(filePath, config = getConfigForFile(filePath)) {
-  const ext = path3.extname(filePath).toLowerCase();
-  const base = path3.basename(filePath).toLowerCase();
-  return registeredServers(config).map((server) => {
+  const { ext, base } = fileMatchKeys(filePath);
+  return registeredServers(config, LSP_SERVERS).map((server) => {
     const reason = selectionReason(server, config, filePath, ext, base);
     return { server, selected: reason === "selected", reason };
   });
 }
 function getServersForFileWithConfig(filePath) {
   const config = getConfigForFile(filePath);
-  const ext = path3.extname(filePath).toLowerCase();
-  const base = path3.basename(filePath).toLowerCase();
-  return registeredServers(config).filter((server) => selectionReason(server, config, filePath, ext, base) === "selected");
+  const { ext, base } = fileMatchKeys(filePath);
+  return registeredServers(config, LSP_SERVERS).filter((server) => selectionReason(server, config, filePath, ext, base) === "selected");
 }
 function primaryServerEntry(filePath) {
   return getServersForFileWithConfig(filePath).find((s) => !isAuxiliary(s));
@@ -2067,14 +2085,14 @@ function classifyCascadeWaitTier(lspService, filePath, snapshots) {
 // dist/clients/lsp/lombok.js
 import * as fs5 from "node:fs";
 import * as os5 from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 var LOMBOK_ENV_KEYS = ["PI_LENS_LOMBOK_JAR", "LOMBOK_JAR"];
 var LOMBOK_PROJECT_FILES = [
   "lombok.config",
   "pom.xml",
   "build.gradle",
   "build.gradle.kts",
-  path4.join("gradle", "libs.versions.toml")
+  path5.join("gradle", "libs.versions.toml")
 ];
 function fileExists(filePath) {
   if (!filePath)
@@ -2099,13 +2117,13 @@ function containsLombokDependency(text) {
   return /\borg\.projectlombok\b/i.test(text) || /<artifactId>\s*lombok\s*<\/artifactId>/i.test(text) || /\b(annotationProcessor|compileOnly|testCompileOnly|testAnnotationProcessor)\b[^\n]*\blombok\b/i.test(text);
 }
 function hasLombokProject(root) {
-  const lombokConfig = path4.join(root, "lombok.config");
+  const lombokConfig = path5.join(root, "lombok.config");
   if (fileExists(lombokConfig))
     return true;
   for (const name of LOMBOK_PROJECT_FILES) {
     if (name === "lombok.config")
       continue;
-    const text = readTextIfSmall(path4.join(root, name));
+    const text = readTextIfSmall(path5.join(root, name));
     if (text && containsLombokDependency(text))
       return true;
   }
@@ -2115,16 +2133,16 @@ function envJarCandidate(env) {
   for (const key of LOMBOK_ENV_KEYS) {
     const value = env[key]?.trim();
     if (fileExists(value))
-      return path4.resolve(value);
+      return path5.resolve(value);
   }
   return void 0;
 }
 function localJarCandidates(root) {
   return [
-    path4.join(root, "lombok.jar"),
-    path4.join(root, ".lombok", "lombok.jar"),
-    path4.join(root, "lib", "lombok.jar"),
-    path4.join(root, "libs", "lombok.jar")
+    path5.join(root, "lombok.jar"),
+    path5.join(root, ".lombok", "lombok.jar"),
+    path5.join(root, "lib", "lombok.jar"),
+    path5.join(root, "libs", "lombok.jar")
   ];
 }
 function newestExistingJar(candidates) {
@@ -2143,17 +2161,17 @@ function newestExistingJar(candidates) {
   return best?.filePath;
 }
 function mavenLocalLombokJar(home = os5.homedir()) {
-  const base = path4.join(home, ".m2", "repository", "org", "projectlombok", "lombok");
+  const base = path5.join(home, ".m2", "repository", "org", "projectlombok", "lombok");
   let versions = [];
   try {
     versions = fs5.readdirSync(base);
   } catch {
     return void 0;
   }
-  return newestExistingJar(versions.map((version) => path4.join(base, version, `lombok-${version}.jar`)));
+  return newestExistingJar(versions.map((version) => path5.join(base, version, `lombok-${version}.jar`)));
 }
 function gradleCacheLombokJar(home = os5.homedir()) {
-  const base = path4.join(home, ".gradle", "caches", "modules-2", "files-2.1", "org.projectlombok", "lombok");
+  const base = path5.join(home, ".gradle", "caches", "modules-2", "files-2.1", "org.projectlombok", "lombok");
   const candidates = [];
   let versions = [];
   try {
@@ -2162,7 +2180,7 @@ function gradleCacheLombokJar(home = os5.homedir()) {
     return void 0;
   }
   for (const version of versions) {
-    const versionDir = path4.join(base, version);
+    const versionDir = path5.join(base, version);
     let hashes = [];
     try {
       hashes = fs5.readdirSync(versionDir);
@@ -2170,7 +2188,7 @@ function gradleCacheLombokJar(home = os5.homedir()) {
       continue;
     }
     for (const hash of hashes) {
-      candidates.push(path4.join(versionDir, hash, `lombok-${version}.jar`));
+      candidates.push(path5.join(versionDir, hash, `lombok-${version}.jar`));
     }
   }
   return newestExistingJar(candidates);
@@ -2203,15 +2221,15 @@ function createLombokJdtlsArgs(root, baseEnv = process.env) {
 // dist/clients/lsp/jvm-runtime.js
 import { existsSync as existsSync2, readdirSync as readdirSync4 } from "node:fs";
 import os6 from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 var JAVA_EXE = process.platform === "win32" ? "java.exe" : "java";
 var JAVA_PROBE_TIMEOUT_MS = 5e3;
 var MIN_JAVA_MAJOR = 17;
 function jdkHomeFrom(dir) {
-  if (existsSync2(path5.join(dir, "bin", JAVA_EXE)))
+  if (existsSync2(path6.join(dir, "bin", JAVA_EXE)))
     return dir;
-  const macHome = path5.join(dir, "Contents", "Home");
-  if (existsSync2(path5.join(macHome, "bin", JAVA_EXE)))
+  const macHome = path6.join(dir, "Contents", "Home");
+  if (existsSync2(path6.join(macHome, "bin", JAVA_EXE)))
     return macHome;
   return void 0;
 }
@@ -2224,7 +2242,7 @@ function parseMajorVersion(name) {
 }
 function childDirs(base) {
   try {
-    return readdirSync4(base, { withFileTypes: true }).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => path5.join(base, e.name));
+    return readdirSync4(base, { withFileTypes: true }).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => path6.join(base, e.name));
   } catch {
     return [];
   }
@@ -2232,26 +2250,26 @@ function childDirs(base) {
 function candidateRoots() {
   const home = os6.homedir();
   const roots = [];
-  roots.push(path5.join(home, ".jdks"));
-  roots.push(path5.join(getGlobalPiLensDir(), "tools"));
+  roots.push(path6.join(home, ".jdks"));
+  roots.push(path6.join(getGlobalPiLensDir(), "tools"));
   if (process.platform === "win32") {
     const progFiles = [
       process.env.ProgramFiles,
       process.env["ProgramFiles(x86)"],
       process.env.ProgramW6432,
-      path5.join(process.env.LOCALAPPDATA ?? path5.join(home, "AppData", "Local"), "Programs")
+      path6.join(process.env.LOCALAPPDATA ?? path6.join(home, "AppData", "Local"), "Programs")
     ].filter((p) => Boolean(p));
     for (const base of progFiles) {
-      roots.push(path5.join(base, "Eclipse Adoptium"));
-      roots.push(path5.join(base, "Java"));
-      roots.push(path5.join(base, "Microsoft"));
-      roots.push(path5.join(base, "Zulu"));
-      roots.push(path5.join(base, "Amazon Corretto"));
-      roots.push(path5.join(base, "BellSoft"));
+      roots.push(path6.join(base, "Eclipse Adoptium"));
+      roots.push(path6.join(base, "Java"));
+      roots.push(path6.join(base, "Microsoft"));
+      roots.push(path6.join(base, "Zulu"));
+      roots.push(path6.join(base, "Amazon Corretto"));
+      roots.push(path6.join(base, "BellSoft"));
     }
   } else if (process.platform === "darwin") {
     roots.push("/Library/Java/JavaVirtualMachines");
-    roots.push(path5.join(home, "Library", "Java", "JavaVirtualMachines"));
+    roots.push(path6.join(home, "Library", "Java", "JavaVirtualMachines"));
     roots.push("/opt/homebrew/opt");
     roots.push("/usr/local/opt");
   } else {
@@ -2275,7 +2293,7 @@ function discoverJdkHome(roots = candidateRoots(), javaHome = process.env.JAVA_H
         continue;
       found.push({
         home: resolved,
-        major: parseMajorVersion(path5.basename(dir))
+        major: parseMajorVersion(path6.basename(dir))
       });
     }
   }
@@ -2374,12 +2392,12 @@ async function resolveJavaRuntimeEnv() {
   }
   const home = discoverJdkHome();
   if (home) {
-    const binDir = path5.join(home, "bin");
+    const binDir = path6.join(home, "bin");
     const currentPath = process.env.PATH ?? process.env.Path ?? "";
     _cachedEnv = {
       value: {
         JAVA_HOME: home,
-        PATH: binDir + path5.delimiter + currentPath
+        PATH: binDir + path6.delimiter + currentPath
       }
     };
     return _cachedEnv.value;
@@ -2435,7 +2453,7 @@ async function resolveLspServerCwd(server, filePath, sessionCwd, onRootFailure,
     rootFailed = true;
     onRootFailure?.(reason);
   }
-  const isFileDirFallback = serverRoot !== void 0 && rootMarkers?.length && path6.resolve(serverRoot) === path6.resolve(path6.dirname(filePath));
+  const isFileDirFallback = serverRoot !== void 0 && rootMarkers?.length && path7.resolve(serverRoot) === path7.resolve(path7.dirname(filePath));
   if (!serverRoot || isFileDirFallback) {
     const probedMarker = onRootFallback && !rootFailed && rootMarkers?.length ? resolveToolCwd("lsp", server.id, filePath, {
       cwd: sessionCwd,
@@ -2444,7 +2462,7 @@ async function resolveLspServerCwd(server, filePath, sessionCwd, onRootFailure,
     }).marker : void 0;
     const refusedMarker = probedMarker !== void 0 && rootMarkers?.includes(probedMarker) ? probedMarker : void 0;
     const fallbackCwd = rootMarkers?.length ? resolveToolCwd("lsp", server.id, filePath, {
-      cwd: path6.dirname(path6.resolve(filePath)),
+      cwd: path7.dirname(path7.resolve(filePath)),
       rootMarkers
     }) : void 0;
     if (!serverRoot) {
@@ -2498,6 +2516,9 @@ var PROJECT_BOUNDARY_MARKERS = [
   "Cargo.toml",
   "Cargo.lock",
   "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
   "uv.lock",
   "poetry.lock",
   "Pipfile",
@@ -2511,20 +2532,26 @@ var PROJECT_BOUNDARY_MARKERS = [
   "pubspec.yaml",
   "Package.swift"
 ];
+var PYTHON_BOUNDARY_MARKERS = /* @__PURE__ */ new Set([
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt"
+]);
+var PYTHON_EXTENSIONS = new Set(extensionsForLanguage("python"));
 var loggedRootCeilingClamps = /* @__PURE__ */ new Set();
 var posixCaseInsensitiveByPath = /* @__PURE__ */ new Map();
 function posixFilesystemIsCaseInsensitive(root) {
-  const resolved = path6.resolve(root);
+  const resolved = path7.resolve(root);
   const cached = posixCaseInsensitiveByPath.get(resolved);
   if (cached !== void 0)
     return cached;
   if (!existsSync3(resolved)) {
     return false;
   }
-  const name = path6.basename(resolved);
+  const name = path7.basename(resolved);
   const alternate = name.toLowerCase() === name ? name.toUpperCase() : name.toLowerCase();
   let insensitive = false;
-  const alternatePath = path6.join(path6.dirname(resolved), alternate);
+  const alternatePath = path7.join(path7.dirname(resolved), alternate);
   if (alternate !== name && existsSync3(alternatePath)) {
     try {
       const actual = statSync4(resolved);
@@ -2542,7 +2569,7 @@ function resetLSPCaseSensitivityState() {
 }
 function isSameOrWithin(ancestor, candidate, deps = {}) {
   const windowsShaped = isWindowsPath(ancestor) || isWindowsPath(candidate);
-  const pathApi = windowsShaped ? path6.win32 : path6;
+  const pathApi = windowsShaped ? path7.win32 : path7;
   const resolvedAncestor = pathApi.resolve(ancestor);
   const resolvedCandidate = pathApi.resolve(candidate);
   let caseInsensitive = false;
@@ -2562,7 +2589,7 @@ function isSameOrWithin(ancestor, candidate, deps = {}) {
 }
 function enforceLspRootCeiling(root, sessionCwd, filePath) {
   const windowsShaped = isWindowsPath(root) || isWindowsPath(sessionCwd);
-  const pathApi = windowsShaped ? path6.win32 : path6;
+  const pathApi = windowsShaped ? path7.win32 : path7;
   const resolvedRoot = pathApi.resolve(root);
   const resolvedCwd = pathApi.resolve(sessionCwd);
   if (filePath && !isSameOrWithin(resolvedCwd, pathApi.resolve(filePath))) {
@@ -2577,18 +2604,20 @@ function enforceLspRootCeiling(root, sessionCwd, filePath) {
   }
   return resolvedCwd;
 }
-async function hasProjectBoundaryMarker(dir) {
+async function hasProjectBoundaryMarker(dir, server) {
   if (await markerExists(dir, ".git"))
     return true;
   for (const marker of PROJECT_BOUNDARY_MARKERS) {
+    if (PYTHON_BOUNDARY_MARKERS.has(marker) && !server.extensions.some((extension) => PYTHON_EXTENSIONS.has(extension)))
+      continue;
     if (await markerExists(dir, marker))
       return true;
   }
   return false;
 }
 function pathSegments(dir) {
-  const parsed = path6.parse(path6.resolve(dir));
-  return path6.relative(parsed.root, path6.resolve(dir)).split(path6.sep).filter(Boolean).map((segment) => segment.toLowerCase());
+  const parsed = path7.parse(path7.resolve(dir));
+  return path7.relative(parsed.root, path7.resolve(dir)).split(path7.sep).filter(Boolean).map((segment) => segment.toLowerCase());
 }
 function hasFixtureConvention(dir) {
   const segments = pathSegments(dir);
@@ -2600,18 +2629,18 @@ function hasAtomicStageSegment(dir) {
   return pathSegments(dir).some((segment) => STAGE_TMP_PATTERN.test(segment));
 }
 async function findGitBoundary(dir) {
-  let current = path6.resolve(dir);
-  const fsRoot = path6.parse(current).root;
+  let current = path7.resolve(dir);
+  const fsRoot = path7.parse(current).root;
   while (true) {
     if (await markerExists(current, ".git"))
       return current;
     if (current === fsRoot)
       return void 0;
-    current = path6.dirname(current);
+    current = path7.dirname(current);
   }
 }
 async function isExcludedLspRoot(dir) {
-  const candidate = path6.resolve(dir);
+  const candidate = path7.resolve(dir);
   if (hasFixtureConvention(candidate) || hasAtomicStageSegment(candidate))
     return true;
   const gitRoot = await findGitBoundary(candidate);
@@ -2623,9 +2652,9 @@ async function isExcludedLspRoot(dir) {
 }
 async function nearestNonExcludedFallbackRoot(candidate) {
   if (!await isExcludedLspRoot(candidate))
-    return path6.resolve(candidate);
-  let current = path6.dirname(path6.resolve(candidate));
-  const fsRoot = path6.parse(current).root;
+    return path7.resolve(candidate);
+  let current = path7.dirname(path7.resolve(candidate));
+  const fsRoot = path7.parse(current).root;
   let nearestAllowed;
   while (true) {
     if (!await isExcludedLspRoot(current)) {
@@ -2637,7 +2666,7 @@ async function nearestNonExcludedFallbackRoot(candidate) {
     }
     if (current === fsRoot)
       break;
-    current = path6.dirname(current);
+    current = path7.dirname(current);
   }
   return nearestAllowed ?? fsRoot;
 }
@@ -2678,7 +2707,7 @@ async function installEvidenceForLaunch(toolId, installed, attempt) {
   const confirmedManagedPath = await findManagedToolBinary(toolId);
   return {
     ...evidence,
-    binary: path6.basename(installed),
+    binary: path7.basename(installed),
     ...confirmedManagedPath !== void 0 && pathsEqual(confirmedManagedPath, installed) && {
       source: "managed-dir"
     }
@@ -2731,7 +2760,7 @@ function markDirectLspCommandUnavailable(command) {
   directLspCommandUnavailableUntil.set(command, Date.now() + DIRECT_LSP_NEGATIVE_TTL_MS);
   directLspCommandSkipLoggedUntil.delete(command);
 }
-var PI_LENS_BIN_DIR2 = path6.join(getGlobalPiLensDir(), "bin");
+var PI_LENS_BIN_DIR2 = path7.join(getGlobalPiLensDir(), "bin");
 async function resolveAndLaunch(spec, allowInstall) {
   const generation = lspLaunchAvailabilityGeneration.capture();
   const toolLabel = spec.managedToolId ?? spec.candidates[spec.candidates.length - 1] ?? "unknown";
@@ -2796,7 +2825,7 @@ async function resolveAndLaunch(spec, allowInstall) {
           producer: "lsp-launch",
           classifiedBy: "probe",
           evidence: {
-            binary: path6.basename(managedCandidate),
+            binary: path7.basename(managedCandidate),
             source: "managed-dir",
             correctsLatchedRow: false
           }
@@ -2827,7 +2856,7 @@ 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"));
+  const hasOnlyRepairableCandidateFailures = candidateFailures.every((failure) => hasSpawnFailureKind(failure.err, "tool-not-found") || hasSpawnFailureKind(failure.err, "trust-refused"));
   if (!hasOnlyRepairableCandidateFailures) {
     if (lastRuntimeFailure)
       throw lastRuntimeFailure;
@@ -2846,14 +2875,19 @@ async function resolveAndLaunch(spec, allowInstall) {
         globalInstallDisabled: isLspInstallDisabled()
       }
     });
+    if (lastRuntimeFailure)
+      throw lastRuntimeFailure;
     return void 0;
   }
+  const isRefusal = (failure) => hasSpawnFailureKind(failure.err, "trust-refused");
+  const trustRefused = candidateFailures.some(isRefusal);
+  const storeOnly = trustRefused && (candidateFailures.some((failure) => isRefusal(failure) && isSimpleCommand(failure.command)) || commandSearchReachesProject(spec.cwd));
   if (spec.managedToolId) {
     const failedCandidate = candidateFailures.at(-1);
     const classifiedFailure = classifyProbeFailure({
       error: failedCandidate?.err instanceof Error ? failedCandidate.err : void 0,
       spawnFailure: {
-        kind: hasSpawnFailureKind(failedCandidate?.err, "tool-not-found") ? "tool-not-found" : void 0
+        kind: ["tool-not-found", "trust-refused"].find((kind) => hasSpawnFailureKind(failedCandidate?.err, kind))
       }
     }, { command: failedCandidate?.command });
     logAvailabilityDecision({
@@ -2867,10 +2901,18 @@ async function resolveAndLaunch(spec, allowInstall) {
       producer: "lsp-launch",
       evidence: classifiedFailure.evidence
     });
-    logSessionStart(`lsp launch ensure-tool start tool=${spec.managedToolId} cwd=${spec.cwd}`);
+    if (storeOnly) {
+      recordDegradationOnce({
+        kind: "lsp-registry-decision",
+        subject: `store-only-repair:${spec.managedToolId}`,
+        reason: "LSP repair read only the pi-lens tool store: after a trust refusal a bare-name lookup reaches the project, so nothing was probed on PATH or installed",
+        metadata: { field: "store-only-repair", tool: spec.managedToolId }
+      });
+    }
+    logSessionStart(`lsp launch ensure-tool start tool=${spec.managedToolId} cwd=${spec.cwd} storeOnly=${storeOnly}`);
     const installStartedAt = Date.now();
-    const installed = await ensureTool(spec.managedToolId);
-    const installAttempt = captureInstallAttempt(spec.managedToolId);
+    const installed = await (storeOnly ? getToolPath(spec.managedToolId, { storeOnly: true }) : ensureTool(spec.managedToolId));
+    const installAttempt = storeOnly ? void 0 : captureInstallAttempt(spec.managedToolId);
     if (staleLaunch(generation, `${toolLabel}:ensureTool`)) {
       return void 0;
     }
@@ -3000,7 +3042,7 @@ async function resolveAndLaunch(spec, allowInstall) {
       }
     }
   }
-  const runtimeInstall = spec.runtimeInstall;
+  const runtimeInstall = trustRefused ? void 0 : spec.runtimeInstall;
   const runtimeAvailable = runtimeInstall ? await isOnPath(runtimeInstall.runtimeCommand) : false;
   if (staleLaunch(generation, `${toolLabel}:runtimeAvailability`)) {
     return void 0;
@@ -3089,7 +3131,7 @@ async function resolveAndLaunchTreeBinary(spec, allowInstall) {
     return void 0;
   }
   const suffix = process.platform === "win32" ? ".exe" : "";
-  const binPath = path6.join(bundleDir, ...spec.binRelPath.split("/")) + suffix;
+  const binPath = path7.join(bundleDir, ...spec.binRelPath.split("/")) + suffix;
   try {
     const proc = await launchLSP(binPath, spec.args, {
       cwd: spec.cwd,
@@ -3104,7 +3146,7 @@ async function resolveAndLaunchTreeBinary(spec, allowInstall) {
   }
 }
 function nodeBinLocalCandidates(root, baseName) {
-  const localBase = path6.join(root, "node_modules", ".bin", baseName);
+  const localBase = path7.join(root, "node_modules", ".bin", baseName);
   if (process.platform === "win32") {
     return [`${localBase}.cmd`, `${localBase}.exe`];
   }
@@ -3114,7 +3156,7 @@ function nodeBinCandidates(root, baseName) {
   return [...nodeBinLocalCandidates(root, baseName), baseName];
 }
 function piAgentExtensionsRootKey(file) {
-  const dirKey = normalizeEphemeralMapKey(path6.dirname(path6.resolve(file)));
+  const dirKey = normalizeEphemeralMapKey(path7.dirname(path7.resolve(file)));
   const marker = "/.pi/agent/extensions";
   const index = dirKey.indexOf(marker);
   if (index === -1)
@@ -3122,12 +3164,12 @@ function piAgentExtensionsRootKey(file) {
   return dirKey.slice(0, index + marker.length);
 }
 function IgnoreHomeRoot(primary) {
-  const homeKey = normalizeEphemeralMapKey(path6.resolve(os7.homedir()));
+  const homeKey = normalizeEphemeralMapKey(path7.resolve(os7.homedir()));
   return withRootMarkers(async (file) => {
     const root = await primary(file);
     if (!root)
       return void 0;
-    return normalizeEphemeralMapKey(path6.resolve(root)) === homeKey ? void 0 : root;
+    return normalizeEphemeralMapKey(path7.resolve(root)) === homeKey ? void 0 : root;
   }, primary.rootMarkers ?? []);
 }
 function rubyBinCandidates(baseName) {
@@ -3135,13 +3177,13 @@ function rubyBinCandidates(baseName) {
   const home = os7.homedir();
   const isWin = process.platform === "win32";
   const ext = isWin ? ".bat" : "";
-  candidates.push(path6.join(home, ".local", "share", "mise", "installs", "ruby", "bin", `${baseName}${ext}`));
-  candidates.push(path6.join(home, ".asdf", "installs", "ruby", "bin", `${baseName}${ext}`));
+  candidates.push(path7.join(home, ".local", "share", "mise", "installs", "ruby", "bin", `${baseName}${ext}`));
+  candidates.push(path7.join(home, ".asdf", "installs", "ruby", "bin", `${baseName}${ext}`));
   if (isWin) {
-    const driveRoot = path6.parse(home).root;
+    const driveRoot = path7.parse(home).root;
     for (const entry of getRubyVersionDirNamesSync(driveRoot)) {
-      candidates.push(path6.join(driveRoot, entry, "bin", `${baseName}.bat`));
-      candidates.push(path6.join(driveRoot, entry, "bin", baseName));
+      candidates.push(path7.join(driveRoot, entry, "bin", `${baseName}.bat`));
+      candidates.push(path7.join(driveRoot, entry, "bin", baseName));
     }
   }
   return candidates;
@@ -3198,7 +3240,7 @@ function PriorityRoot(markerGroups, excludePatterns, stopDir) {
   }, markerGroups.flat());
 }
 var FileDirRoot = async (file) => {
-  const candidate = path6.resolve(path6.dirname(file));
+  const candidate = path7.resolve(path7.dirname(file));
   return nearestNonExcludedFallbackRoot(candidate);
 };
 function RootWithFallback(primary, fallback = FileDirRoot) {
@@ -3220,16 +3262,16 @@ function markerProbeDir(dir, pattern) {
   const normalized = toPosix(pattern);
   const slash = normalized.lastIndexOf("/");
   const parentPattern = slash >= 0 ? normalized.slice(0, slash) : "";
-  return parentPattern ? path6.join(dir, ...parentPattern.split("/").filter(Boolean)) : dir;
+  return parentPattern ? path7.join(dir, ...parentPattern.split("/").filter(Boolean)) : dir;
 }
 async function markerExists(dir, pattern) {
   if (!pattern.includes("*")) {
     try {
-      await stat(path6.join(dir, pattern));
+      await stat(path7.join(dir, pattern));
       return true;
     } catch (err) {
       if (isPermissionFsError(err)) {
-        logSessionStart(`lsp root marker skipped: permission error stat ${path6.join(dir, pattern)}`);
+        logSessionStart(`lsp root marker skipped: permission error stat ${path7.join(dir, pattern)}`);
       }
       return false;
     }
@@ -3265,7 +3307,7 @@ function NearestRoot(includePatterns, excludePatterns, stopDir) {
       subdirPatterns.push(pattern);
   }
   return withRootMarkers(async (file) => {
-    const startDir = path6.resolve(path6.dirname(file));
+    const startDir = path7.resolve(path7.dirname(file));
     const dirKey = normalizeMapKey(startDir);
     const cached = cache.get(dirKey);
     if (cached !== void 0 && Date.now() - cached.walkedAt < FRESHNESS_CADENCE_MS && await bounded(dirMtimesStillFreshAsync(cached.probedDirs), rootMtimeBound("lsp-root-memo-freshness")) === true)
@@ -3277,10 +3319,10 @@ function NearestRoot(includePatterns, excludePatterns, stopDir) {
     const walkedAt = Date.now();
     const promise = (async () => {
       let currentDir = startDir;
-      const fsRoot = path6.parse(currentDir).root;
-      const stop = stopDir ? path6.resolve(stopDir) : fsRoot;
+      const fsRoot = path7.parse(currentDir).root;
+      const stop = stopDir ? path7.resolve(stopDir) : fsRoot;
       while (true) {
-        if (stop !== fsRoot && currentDir.startsWith(stop + path6.sep) === false && currentDir !== stop) {
+        if (stop !== fsRoot && currentDir.startsWith(stop + path7.sep) === false && currentDir !== stop) {
           break;
         }
         const stepDirs = [
@@ -3298,7 +3340,7 @@ function NearestRoot(includePatterns, excludePatterns, stopDir) {
             }
           }
           if (excluded) {
-            currentDir = path6.dirname(currentDir);
+            currentDir = path7.dirname(currentDir);
             continue;
           }
         }
@@ -3310,7 +3352,7 @@ function NearestRoot(includePatterns, excludePatterns, stopDir) {
         if (currentDir === stop || currentDir === fsRoot) {
           break;
         }
-        currentDir = path6.dirname(currentDir);
+        currentDir = path7.dirname(currentDir);
       }
       return void 0;
     })();
@@ -3352,17 +3394,17 @@ async function findAncestorFile(startDir, ...relativeSegments) {
 }
 async function findAncestorFileAmong(startDir, candidateSegmentLists) {
   const fs6 = await import("node:fs/promises");
-  let currentDir = path6.resolve(startDir);
+  let currentDir = path7.resolve(startDir);
   while (!isAtOrAboveHomeDir(currentDir)) {
     for (const segments of candidateSegmentLists) {
-      const candidate = path6.join(currentDir, ...segments);
+      const candidate = path7.join(currentDir, ...segments);
       try {
         await fs6.access(candidate);
         return candidate;
       } catch {
       }
     }
-    const parent = path6.dirname(currentDir);
+    const parent = path7.dirname(currentDir);
     if (parent === currentDir)
       break;
     currentDir = parent;
@@ -3378,19 +3420,21 @@ function resetClassicTsRepairGuard() {
   classicTsRepairState().attempted = false;
 }
 function typescriptDirsForTsc(tscPath) {
-  const binDir = path6.dirname(tscPath);
+  const binDir = path7.dirname(tscPath);
   return [
-    path6.join(binDir, "..", "typescript"),
-    path6.join(binDir, "..", "..", "typescript")
+    path7.join(binDir, "..", "typescript"),
+    path7.join(binDir, "..", "..", "typescript"),
+    // Windows npm-global: `<prefix>/tsc.cmd` beside `<prefix>/node_modules`.
+    path7.join(binDir, "node_modules", "typescript")
   ];
 }
 async function typescriptVersionForTsc(tscPath) {
-  if (!path6.isAbsolute(tscPath))
+  if (!path7.isAbsolute(tscPath))
     return void 0;
   for (const dir of typescriptDirsForTsc(tscPath)) {
     let manifest;
     try {
-      manifest = await readFile(path6.join(dir, "package.json"), "utf8");
+      manifest = await readFile(path7.join(dir, "package.json"), "utf8");
     } catch {
       continue;
     }
@@ -3412,15 +3456,28 @@ async function typescriptVersionForTsc(tscPath) {
   }
   return void 0;
 }
+async function hasTypescriptPackageDir(tscPath) {
+  for (const dir of typescriptDirsForTsc(tscPath)) {
+    if ((await stat(dir).catch(() => void 0))?.isDirectory())
+      return true;
+  }
+  return false;
+}
+async function absoluteCommandPath(command) {
+  if (!command || path7.isAbsolute(command))
+    return command;
+  const found = await findCommandAsync(command);
+  return found ? realpath(found).catch(() => void 0) : void 0;
+}
 async function findTsserverPath(root, allowInstall, options) {
   const fs6 = await import("node:fs/promises");
-  const projectRoots = await Promise.all([root, options?.sessionRoot ?? process.cwd(), process.cwd()].map((dir) => fs6.realpath(dir).catch(() => path6.resolve(dir))));
+  const projectRoots = await Promise.all([root, options?.sessionRoot ?? process.cwd(), process.cwd()].map((dir) => fs6.realpath(dir).catch(() => path7.resolve(dir))));
   const admitCandidate = async (candidate, projectSupplied) => {
     try {
       const real = await fs6.realpath(candidate);
-      if (path6.basename(real) !== "tsserver.js" || !(await fs6.stat(real)).isFile())
+      if (path7.basename(real) !== "tsserver.js" || !(await fs6.stat(real)).isFile())
         return void 0;
-      const manifest = JSON.parse(await fs6.readFile(path6.join(path6.dirname(real), "..", "package.json"), "utf8"));
+      const manifest = JSON.parse(await fs6.readFile(path7.join(path7.dirname(real), "..", "package.json"), "utf8"));
       if (typeof manifest?.version !== "string" || !manifest.version)
         return void 0;
       return admitProjectSuppliedTsserver(real, options?.sessionRoot ?? process.cwd(), projectSupplied || projectRoots.some((dir) => isUnderDir(real, dir)), options?.projectCodeAllowed);
@@ -3434,7 +3491,7 @@ async function findTsserverPath(root, allowInstall, options) {
     if (admittedAncestor)
       return admittedAncestor;
   }
-  const cwdCandidate = path6.join(process.cwd(), "node_modules", "typescript", "lib", "tsserver.js");
+  const cwdCandidate = path7.join(process.cwd(), "node_modules", "typescript", "lib", "tsserver.js");
   try {
     await fs6.access(cwdCandidate);
     const admittedCwd = await admitCandidate(cwdCandidate, false);
@@ -3443,10 +3500,10 @@ async function findTsserverPath(root, allowInstall, options) {
   } catch {
   }
   const tsserverForTsc = async (tscPath) => {
-    if (!tscPath || !path6.isAbsolute(tscPath))
+    if (!tscPath)
       return void 0;
     for (const dir of typescriptDirsForTsc(tscPath)) {
-      const candidate = path6.join(dir, "lib", "tsserver.js");
+      const candidate = path7.join(dir, "lib", "tsserver.js");
       try {
         const admitted = await admitCandidate(candidate, false);
         if (admitted)
@@ -3457,29 +3514,28 @@ async function findTsserverPath(root, allowInstall, options) {
     return void 0;
   };
   const installAllowed = canInstall(allowInstall);
-  const discoveredTsc = await ensureTool("typescript", {
-    allowInstall: installAllowed
-  });
+  const discoveredTsc = await absoluteCommandPath(await ensureTool("typescript", { allowInstall: installAllowed }));
   const discoveredTsserver = await tsserverForTsc(discoveredTsc);
   if (discoveredTsserver || !discoveredTsc || !installAllowed || classicTsRepairState().attempted) {
     return discoveredTsserver;
   }
   const discoveredVersion = await typescriptVersionForTsc(discoveredTsc);
-  if (!discoveredVersion || discoveredVersion.major < 7)
+  const shim = !await hasTypescriptPackageDir(discoveredTsc);
+  if (!shim && (!discoveredVersion || discoveredVersion.major < 7))
     return void 0;
   classicTsRepairState().attempted = true;
-  logSessionStart(`lsp typescript: managed compiler resolved to TypeScript ${discoveredVersion.version}, which ships no tsserver.js; reinstalling pinned classic fallback`);
-  const repairedTsc = await ensureTool("typescript", {
+  logSessionStart(shim ? `lsp typescript: ${discoveredTsc} has no TypeScript package beside it; installing pinned classic fallback` : `lsp typescript: managed compiler resolved to TypeScript ${discoveredVersion?.version}, which ships no tsserver.js; reinstalling pinned classic fallback`);
+  const repairedTsc = await absoluteCommandPath(await ensureTool("typescript", {
     allowInstall: true,
     forceReinstall: true
-  });
+  }));
   return tsserverForTsc(repairedTsc);
 }
 async function findNativeTypeScriptLsp(root) {
-  let currentDir = path6.resolve(root);
+  let currentDir = path7.resolve(root);
   while (!isAtOrAboveHomeDir(currentDir)) {
-    const typescriptDir = path6.join(currentDir, "node_modules", "typescript");
-    const packageJsonPath = path6.join(typescriptDir, "package.json");
+    const typescriptDir = path7.join(currentDir, "node_modules", "typescript");
+    const packageJsonPath = path7.join(typescriptDir, "package.json");
     let packageJsonText;
     try {
       packageJsonText = await readFile(packageJsonPath, "utf8");
@@ -3493,7 +3549,7 @@ async function findNativeTypeScriptLsp(root) {
           return void 0;
       } catch {
       }
-      const parent = path6.dirname(currentDir);
+      const parent = path7.dirname(currentDir);
       if (parent === currentDir)
         return void 0;
       currentDir = parent;
@@ -3513,7 +3569,7 @@ async function findNativeTypeScriptLsp(root) {
     const major = /^\d+$/.test(majorText) ? Number(majorText) : Number.NaN;
     if (!Number.isFinite(major) || major < 7)
       return void 0;
-    const localTsc = path6.join(currentDir, "node_modules", ".bin", "tsc");
+    const localTsc = path7.join(currentDir, "node_modules", ".bin", "tsc");
     const candidates = process.platform === "win32" ? [`${localTsc}.cmd`, `${localTsc}.exe`, localTsc] : [localTsc];
     for (const command of candidates) {
       try {
@@ -3529,23 +3585,23 @@ async function findNativeTypeScriptLsp(root) {
 function dotnetToolCandidates(tool) {
   const home = os7.homedir();
   return [
-    path6.join(PI_LENS_BIN_DIR2, `${tool}.exe`),
-    path6.join(PI_LENS_BIN_DIR2, tool),
-    path6.join(home, ".dotnet", "tools", `${tool}.exe`),
-    path6.join(home, ".dotnet", "tools", tool),
+    path7.join(PI_LENS_BIN_DIR2, `${tool}.exe`),
+    path7.join(PI_LENS_BIN_DIR2, tool),
+    path7.join(home, ".dotnet", "tools", `${tool}.exe`),
+    path7.join(home, ".dotnet", "tools", tool),
     tool
   ].filter(Boolean);
 }
 function binExeVariants(dir, tool) {
-  return process.platform === "win32" ? [path6.join(dir, `${tool}.exe`), path6.join(dir, tool)] : [path6.join(dir, tool)];
+  return process.platform === "win32" ? [path7.join(dir, `${tool}.exe`), path7.join(dir, tool)] : [path7.join(dir, tool)];
 }
 function goBinCandidates(tool) {
-  const gopath = process.env.GOPATH?.split(path6.delimiter)[0] || path6.join(os7.homedir(), "go");
-  return [tool, ...binExeVariants(path6.join(gopath, "bin"), tool)];
+  const gopath = process.env.GOPATH?.split(path7.delimiter)[0] || path7.join(os7.homedir(), "go");
+  return [tool, ...binExeVariants(path7.join(gopath, "bin"), tool)];
 }
 function cargoBinCandidates(tool) {
-  const cargoHome = process.env.CARGO_HOME || path6.join(os7.homedir(), ".cargo");
-  return [tool, ...binExeVariants(path6.join(cargoHome, "bin"), tool)];
+  const cargoHome = process.env.CARGO_HOME || path7.join(os7.homedir(), ".cargo");
+  return [tool, ...binExeVariants(path7.join(cargoHome, "bin"), tool)];
 }
 async function tryGemInstall(gem) {
   const { join: join4 } = await import("node:path");
@@ -3583,7 +3639,7 @@ var TS_TOOLING_MARKERS = [
 ];
 var TS_FAMILY_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
 function isTsFamilyFile(file) {
-  return TS_FAMILY_EXTENSIONS.has(path6.extname(file).toLowerCase());
+  return TS_FAMILY_EXTENSIONS.has(path7.extname(file).toLowerCase());
 }
 function tsConfigMarkersForFile(file) {
   return isTsFamilyFile(file) ? ["tsconfig.json"] : TS_CONFIG_MARKERS;
@@ -3604,40 +3660,40 @@ async function findTypeScriptProjectRoot(file) {
   return isSameOrWithin(toolingRoot, configRoot) ? configRoot : toolingRoot;
 }
 async function findExtensionBoundedRoot(file, extensionRootKey) {
-  const startDir = path6.resolve(path6.dirname(file));
+  const startDir = path7.resolve(path7.dirname(file));
   let currentDir = startDir;
   const configMarkers = tsConfigMarkersForFile(file);
   while (true) {
     for (const pattern of configMarkers) {
       try {
-        await stat(path6.join(currentDir, pattern));
+        await stat(path7.join(currentDir, pattern));
         return currentDir;
       } catch {
       }
     }
     for (const pattern of TS_TOOLING_MARKERS) {
       try {
-        await stat(path6.join(currentDir, pattern));
+        await stat(path7.join(currentDir, pattern));
         return currentDir;
       } catch {
       }
     }
-    const currentKey = normalizeEphemeralMapKey(path6.resolve(currentDir));
+    const currentKey = normalizeEphemeralMapKey(path7.resolve(currentDir));
     if (currentKey === extensionRootKey)
       return void 0;
-    const parent = path6.dirname(currentDir);
+    const parent = path7.dirname(currentDir);
     if (parent === currentDir)
       return void 0;
     currentDir = parent;
   }
 }
 async function hasAgentLevelProjectMarker(extensionRootKey) {
-  const agentDir = path6.dirname(extensionRootKey);
+  const agentDir = path7.dirname(extensionRootKey);
   if (!agentDir || agentDir === extensionRootKey)
     return false;
   for (const pattern of [...TS_CONFIG_MARKERS, ...TS_TOOLING_MARKERS]) {
     try {
-      await stat(path6.join(agentDir, pattern));
+      await stat(path7.join(agentDir, pattern));
       return true;
     } catch {
     }
@@ -3815,13 +3871,13 @@ var PythonServer = {
     if (!pyrightPath)
       return void 0;
     source = "managed";
-    const binDir = path6.dirname(pyrightPath);
+    const binDir = path7.dirname(pyrightPath);
     const isWindows2 = process.platform === "win32";
     const managedCandidates = isWindows2 ? [
-      path6.join(binDir, "pyright-langserver.cmd"),
-      path6.join(binDir, "pyright-langserver"),
+      path7.join(binDir, "pyright-langserver.cmd"),
+      path7.join(binDir, "pyright-langserver"),
       "pyright-langserver"
-    ] : [path6.join(binDir, "pyright-langserver"), "pyright-langserver"];
+    ] : [path7.join(binDir, "pyright-langserver"), "pyright-langserver"];
     const resolved = await resolveAndLaunch({ candidates: managedCandidates, args: ["--stdio"], cwd: root, env }, false);
     if (!resolved)
       return void 0;
@@ -3890,7 +3946,7 @@ var GoServer = {
   }
 };
 function cargoWorkspaceDeclaresMember(workspaceContent, parentDir, childDir) {
-  const relativePath = path6.relative(parentDir, childDir).split(path6.sep).join("/");
+  const relativePath = path7.relative(parentDir, childDir).split(path7.sep).join("/");
   if (relativePath === "" || relativePath.startsWith(".."))
     return false;
   const matches = (pattern) => matchesWorkspaceMemberPattern(pattern, relativePath, CARGO_WORKSPACE_MEMBER_DIALECT, () => recordDegradationOnce({
@@ -3904,7 +3960,7 @@ function cargoWorkspaceDeclaresMember(workspaceContent, parentDir, childDir) {
   return readCargoWorkspaceMembers(workspaceContent).some(matches);
 }
 function sessionHoistCeiling(sessionCwd, file) {
-  return isSameOrWithin(path6.resolve(sessionCwd), path6.resolve(file)) ? path6.resolve(sessionCwd) : void 0;
+  return isSameOrWithin(path7.resolve(sessionCwd), path7.resolve(file)) ? path7.resolve(sessionCwd) : void 0;
 }
 function RustWorkspaceRoot() {
   const crateRoot = createRootDetector(["Cargo.toml", "Cargo.lock"]);
@@ -3915,14 +3971,14 @@ function RustWorkspaceRoot() {
     const sessionCwd = process.cwd();
     const stop = sessionHoistCeiling(sessionCwd, file);
     let current = root;
-    const fsRoot = path6.parse(current).root;
+    const fsRoot = path7.parse(current).root;
     while (true) {
       if (stop !== void 0 && current === stop)
         break;
-      const parent = path6.dirname(current);
+      const parent = path7.dirname(current);
       if (parent === current || parent === fsRoot)
         break;
-      const parentCargoPath = path6.join(parent, "Cargo.toml");
+      const parentCargoPath = path7.join(parent, "Cargo.toml");
       const parentCargoContent = await readTextFileOrUndefined(parentCargoPath);
       if (parentCargoContent !== void 0 && hasCargoWorkspaceTable(parentCargoContent)) {
         if (cargoWorkspaceDeclaresMember(parentCargoContent, parent, root)) {
@@ -3950,9 +4006,9 @@ async function declaresMavenModule(parentDir, parentPomPath, childDir) {
     const modulesBlock = content.match(/<modules>([\s\S]*?)<\/modules>/);
     if (!modulesBlock)
       return false;
-    const resolvedChild = path6.resolve(childDir);
+    const resolvedChild = path7.resolve(childDir);
     for (const match of modulesBlock[1].matchAll(/<module>\s*([^<]+?)\s*<\/module>/g)) {
-      if (pathsEqual(path6.resolve(parentDir, match[1]), resolvedChild))
+      if (pathsEqual(path7.resolve(parentDir, match[1]), resolvedChild))
         return true;
     }
     return false;
@@ -3976,15 +4032,15 @@ function JavaWorkspaceRoot() {
     const stop = sessionHoistCeiling(sessionCwd, file);
     let current = root;
     let lastHop = root;
-    const fsRoot = path6.parse(current).root;
+    const fsRoot = path7.parse(current).root;
     while (true) {
       if (stop !== void 0 && current === stop)
         break;
-      const parent = path6.dirname(current);
+      const parent = path7.dirname(current);
       if (parent === current || parent === fsRoot)
         break;
       if (await markerExists(parent, "pom.xml")) {
-        const parentPom = path6.join(parent, "pom.xml");
+        const parentPom = path7.join(parent, "pom.xml");
         if (!await declaresMavenModule(parent, parentPom, lastHop))
           break;
         current = parent;
@@ -4090,17 +4146,17 @@ var PHPServer = {
     return {
       ...result,
       initialization: {
-        storagePath: path6.join(getGlobalPiLensDir(), "intelephense")
+        storagePath: path7.join(getGlobalPiLensDir(), "intelephense")
       }
     };
   }
 };
 function buildPsesArgs(bundleDir) {
-  const script = path6.join(bundleDir, "PowerShellEditorServices", "Start-EditorServices.ps1");
-  const sessionDir = path6.join(getGlobalPiLensDir(), "pses", `${process.pid}-${Date.now()}`);
+  const script = path7.join(bundleDir, "PowerShellEditorServices", "Start-EditorServices.ps1");
+  const sessionDir = path7.join(getGlobalPiLensDir(), "pses", `${process.pid}-${Date.now()}`);
   mkdirSync2(sessionDir, { recursive: true });
-  const logPath = path6.join(sessionDir, "pses.log");
-  const sessionDetailsPath = path6.join(sessionDir, "session.json");
+  const logPath = path7.join(sessionDir, "pses.log");
+  const sessionDetailsPath = path7.join(sessionDir, "session.json");
   return [
     "-NoLogo",
     "-NoProfile",
@@ -4758,8 +4814,8 @@ var VueServer = {
   initializeTimeoutMs: 3e4,
   async spawn(root, options) {
     const tsserverPath = await findTsserverPath(root, options?.allowInstall, options);
-    const hasPackageJson = existsSync3(path6.join(root, "package.json"));
-    const hasNodeModules = existsSync3(path6.join(root, "node_modules"));
+    const hasPackageJson = existsSync3(path7.join(root, "package.json"));
+    const hasNodeModules = existsSync3(path7.join(root, "node_modules"));
     if (hasPackageJson && !hasNodeModules) {
       logSessionStart(`lsp vue: node_modules missing in ${root} \u2014 Vue navigation may be limited. Run: npm install (or pnpm/yarn install) in this project.`);
     }
@@ -4774,7 +4830,7 @@ var VueServer = {
     return {
       process: proc.process,
       source: proc.source,
-      initialization: tsserverPath ? { typescript: { tsdk: path6.dirname(tsserverPath) } } : void 0
+      initialization: tsserverPath ? { typescript: { tsdk: path7.dirname(tsserverPath) } } : void 0
     };
   }
 };
@@ -4816,7 +4872,7 @@ var SvelteServer = {
     return {
       process: proc.process,
       source: proc.source,
-      initialization: tsserverPath ? { typescript: { tsdk: path6.dirname(tsserverPath) } } : void 0
+      initialization: tsserverPath ? { typescript: { tsdk: path7.dirname(tsserverPath) } } : void 0
     };
   }
 };
@@ -5111,7 +5167,7 @@ function getServerById(id) {
 }
 
 // dist/clients/lsp/session-roots.js
-import path7 from "node:path";
+import path8 from "node:path";
 var SESSION_ROOT_CAP = 128;
 var sessionRoots = new BoundedFifoMap(SESSION_ROOT_CAP);
 function noteEvictedRoots(evicted) {
@@ -5126,28 +5182,57 @@ function noteEvictedRoots(evicted) {
   return roots;
 }
 function registerSessionRoot(cwd) {
-  const root = path7.resolve(cwd);
+  const root = path8.resolve(cwd);
   if (sessionRoots.has(root))
     return [];
   return noteEvictedRoots(sessionRoots.set(root, void 0));
 }
 function setSessionRootConfig(cwd, config) {
-  return noteEvictedRoots(sessionRoots.set(path7.resolve(cwd), config));
+  return noteEvictedRoots(sessionRoots.set(path8.resolve(cwd), config));
+}
+function isSameOrChildPath(filePath, candidateRoot) {
+  if (filePath === candidateRoot)
+    return true;
+  return filePath.startsWith(`${candidateRoot}${path8.sep}`);
+}
+function sessionRootConfigForFile(filePath) {
+  const resolvedFilePath = path8.resolve(filePath);
+  let bestMatch;
+  for (const [root, config] of sessionRoots) {
+    if (config === void 0)
+      continue;
+    if (!isSameOrChildPath(resolvedFilePath, root))
+      continue;
+    if (!bestMatch || root.length > bestMatch.root.length) {
+      bestMatch = { root, config };
+    }
+  }
+  return bestMatch?.config;
 }
-function sessionRootConfigEntries() {
-  return sessionRoots;
+function disabledPrimaries(filePath) {
+  const config = sessionRootConfigForFile(filePath);
+  if (!config || config.disabledServerIds.size === 0)
+    return { disabledServerIds: [], fallbackServerIds: [] };
+  const { ext, base } = fileMatchKeys(filePath);
+  const off = config.disabledServerIds;
+  const primaries = registeredServers(config, LSP_SERVERS).filter((server) => !isAuxiliary(server) && fileMatchReason(server, filePath, ext, base) === "selected");
+  const ownerOff = (server) => server.fallbackFor === void 0 || off.has(server.fallbackFor);
+  return {
+    disabledServerIds: primaries.filter((server) => off.has(server.id) && ownerOff(server)).map((server) => server.id),
+    fallbackServerIds: primaries.filter((server) => server.fallbackFor !== void 0 && off.has(server.fallbackFor)).map((server) => server.id)
+  };
 }
 function isSessionRootRegistered(cwd) {
-  return sessionRoots.has(path7.resolve(cwd));
+  return sessionRoots.has(path8.resolve(cwd));
 }
 function shouldInitializeSessionRoot(cwd, readyRoots) {
-  const normalized = path7.resolve(cwd);
+  const normalized = path8.resolve(cwd);
   return !readyRoots.has(normalized) || !isSessionRootRegistered(normalized);
 }
 function isOutsideAllSessionRoots(filePath) {
   if (sessionRoots.size === 0)
     return false;
-  const resolved = path7.resolve(filePath);
+  const resolved = path8.resolve(filePath);
   for (const root of sessionRoots.keys()) {
     if (isSameOrWithin(root, resolved))
       return false;
@@ -5162,8 +5247,6 @@ export {
   findLocalTyposConfig,
   getAstGrepRuleSources,
   getAstGrepRuleFingerprint,
-  isAuxiliary,
-  serverTraits,
   registerRunnerId,
   withLspProjectCodePermission,
   refuseUntrustedLspExecution,
@@ -5171,6 +5254,11 @@ export {
   resolveAnalysisRoot,
   canWriteAnalysisRoot,
   BUILTIN_SERVER_RUNNER_COVERS,
+  isAuxiliary,
+  serverTraits,
+  getStrategy,
+  classifyServerWaitTier,
+  classifyCascadeWaitTier,
   describeRootFallback,
   resolveLspServerCwd,
   resetLSPCaseSensitivityState,
@@ -5183,6 +5271,7 @@ export {
   resetClassicTsRepairGuard,
   LSP_SERVERS,
   getServerById,
+  disabledPrimaries,
   shouldInitializeSessionRoot,
   isOutsideAllSessionRoots,
   getSessionRootsForTelemetry,
@@ -5195,8 +5284,5 @@ export {
   getServersForFileWithConfig,
   primaryServerId,
   resolveLspCwdForFile,
-  getServerInitOverride,
-  getStrategy,
-  classifyServerWaitTier,
-  classifyCascadeWaitTier
+  getServerInitOverride
 };