pi-lens 4.4.2 → 4.4.4

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

@@ -1,32 +1,36 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  resolveOpengrepConfig
+} from "./chunk-HWCCCQNX.js";
 import {
   augmentPythonEnvironment,
   detectPythonEnvironment,
   detectPythonVenv,
   pythonEnvironmentToolCandidates
-} from "./chunk-34WSVGEM.js";
+} from "./chunk-CUHSHSB6.js";
 import {
-  resolveOpengrepConfig
-} from "./chunk-VWCXW2E7.js";
+  resolveGitCheckout,
+  resolveLinkedWorktreeOwner
+} 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,
@@ -36,43 +40,46 @@ import {
   isZizmorAuditTarget,
   logSessionStart,
   resolveZizmorGitHubToken
-} from "./chunk-66VMUL7Q.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,
   holdOwnChildPid,
   isCommandAvailableAsync,
   isPathIgnoredByProject,
+  isPiLensInternalPath,
   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,
@@ -82,7 +89,7 @@ import {
   reportPiLensConfigRecords,
   resolvePiLensConfig,
   summarizeConfigResolution
-} from "./chunk-2BBLFX75.js";
+} from "./chunk-J6MPGQTS.js";
 import {
   FRESHNESS_CADENCE_MS,
   LSP_NAMESPACE_KEY,
@@ -90,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";
@@ -128,6 +135,7 @@ import {
   isAtOrAboveHomeDir,
   isFullyQualified,
   isUnderDir,
+  isVendorPath,
   isWindowsPath,
   matchesWorkspaceMemberPattern,
   normalizeEphemeralMapKey,
@@ -135,44 +143,171 @@ import {
   normalizeMapKey,
   pathsEqual,
   toPosix
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 import {
   __require
 } from "./chunk-NXL4FFQQ.js";
 
+// dist/clients/analysis-root.js
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as nodePath from "node:path";
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle",
+  "Gemfile",
+  "mix.exs",
+  "composer.json"
+];
+function hasProjectMarker(dir) {
+  return PROJECT_MARKERS.some((marker) => {
+    try {
+      const stat2 = fs.statSync(nodePath.join(dir, marker));
+      return stat2.isFile() || marker === ".git";
+    } catch {
+      return false;
+    }
+  });
+}
+function nearestProjectRoot(filePath) {
+  let dir = nodePath.dirname(nodePath.resolve(filePath));
+  const filesystemRoot = nodePath.parse(dir).root;
+  while (dir !== filesystemRoot) {
+    if (hasProjectMarker(dir))
+      return dir;
+    dir = nodePath.dirname(dir);
+  }
+  return hasProjectMarker(filesystemRoot) ? filesystemRoot : void 0;
+}
+function realPathOrResolved(filePath) {
+  const resolved = nodePath.resolve(filePath);
+  let current = resolved;
+  const missing = [];
+  while (true) {
+    try {
+      const real = fs.realpathSync.native(current);
+      return nodePath.join(real, ...missing.reverse());
+    } catch {
+      const parent = nodePath.dirname(current);
+      if (parent === current)
+        return resolved;
+      missing.push(nodePath.basename(current));
+      current = parent;
+    }
+  }
+}
+function resolveAnalysisRootPath(filePath, sessionRoot, homeDirOverride) {
+  const resolved = realPathOrResolved(filePath);
+  const session = realPathOrResolved(sessionRoot);
+  const tmp = realPathOrResolved(os.tmpdir());
+  const data = process.env.PI_LENS_HOME ? realPathOrResolved(process.env.PI_LENS_HOME) : void 0;
+  if (isVendorPath(resolved))
+    return void 0;
+  if (resolved === tmp || resolved === session || isUnderDir(session, resolved) || !isUnderDir(resolved, session) && (isPiLensInternalPath(resolved, session) || data !== void 0 && (resolved === data || isUnderDir(resolved, data))))
+    return void 0;
+  if (isUnderDir(resolved, session))
+    return session;
+  const checkout = resolveGitCheckout(session);
+  const linked = checkout && resolveLinkedWorktreeOwner(checkout, resolved);
+  if (linked && !isVendorPath(resolved))
+    return linked.root;
+  const candidate = nearestProjectRoot(resolved);
+  if (!candidate || candidate === nodePath.parse(candidate).root)
+    return void 0;
+  const home = realPathOrResolved(homeDirOverride ?? os.homedir());
+  if (isAtOrAboveHomeDir(candidate, home))
+    return void 0;
+  if (candidate === tmp || isUnderDir(session, candidate))
+    return void 0;
+  if (isVendorPath(candidate))
+    return void 0;
+  return candidate;
+}
+function resolveAnalysisRoot(filePath, sessionRoot, homeDirOverride) {
+  const resolved = realPathOrResolved(filePath);
+  if (isVendorPath(resolved))
+    return "none";
+  const checkout = resolveGitCheckout(sessionRoot);
+  if (checkout && resolveLinkedWorktreeOwner(checkout, resolved)) {
+    return "linked-worktree";
+  }
+  const root = resolveAnalysisRootPath(filePath, sessionRoot, homeDirOverride);
+  if (!root)
+    return "none";
+  if (root === nodePath.resolve(sessionRoot))
+    return "session";
+  return "adopted";
+}
+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 statSync3 } from "node:fs";
-import { access, readFile, readdir, stat } from "node:fs/promises";
-import os6 from "node:os";
-import path6 from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, statSync as statSync4 } from "node:fs";
+import { access, readFile, readdir, realpath, stat } from "node:fs/promises";
+import os7 from "node:os";
+import path7 from "node:path";
 
 // dist/clients/sgconfig.js
 import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
 var SGCONFIG_NAMES = ["sgconfig.yml", "sgconfig.yaml"];
 function findLocalSgconfig(startDir) {
   return findLocalToolConfig(startDir, SGCONFIG_NAMES);
 }
 function canonicalDir(dir) {
   try {
-    return fs.realpathSync.native(dir);
+    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"
     });
@@ -180,27 +315,27 @@ 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"
   });
   const seen = /* @__PURE__ */ new Set();
   return candidates.filter((source) => {
-    if (!fs.existsSync(source.dir))
+    if (!fs2.existsSync(source.dir))
       return false;
     const key = canonicalDir(source.dir);
     if (seen.has(key))
@@ -213,12 +348,12 @@ function findYamlFiles(dir) {
   const files = [];
   let entries;
   try {
-    entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    entries = fs2.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   } catch {
     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)) {
@@ -260,12 +395,12 @@ 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;
     try {
-      content = fs.readFileSync(file, "utf8");
+      content = fs2.readFileSync(file, "utf8");
     } catch {
       hash.update("missing");
       hash.update("\0");
@@ -303,12 +438,12 @@ 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) {
-  fs.rmSync(mergedDir, { recursive: true, force: true });
-  fs.mkdirSync(mergedDir, { recursive: true });
+  fs2.rmSync(mergedDir, { recursive: true, force: true });
+  fs2.mkdirSync(mergedDir, { recursive: true });
   const claimedByEarlierSource = /* @__PURE__ */ new Set();
   for (const [sourceIndex, source] of sources.entries()) {
     const claimedThisSource = /* @__PURE__ */ new Set();
@@ -323,11 +458,11 @@ 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) {
-        fs.copyFileSync(file.file, destination);
+        fs2.copyFileSync(file.file, destination);
       } else {
-        fs.writeFileSync(destination, `${survivingDocuments.map((document) => document.raw.trim()).join("\n---\n")}
+        fs2.writeFileSync(destination, `${survivingDocuments.map((document) => document.raw.trim()).join("\n---\n")}
 `);
       }
     }
@@ -340,20 +475,20 @@ 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 && fs.existsSync(cached.path) && fs.existsSync(cached.mergedDir)) {
+  if (cached?.fingerprint === fingerprint && fs2.existsSync(cached.path) && fs2.existsSync(cached.mergedDir)) {
     return cached.path;
   }
   const sources = getAstGrepRuleSources(root).map(snapshotRuleSource);
   if (sources.length === 0)
     return void 0;
-  const dir = path.join(os.tmpdir(), "pi-lens-ast-grep");
-  fs.mkdirSync(dir, { recursive: true });
+  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);
@@ -361,8 +496,8 @@ function resolveBaselineSgconfig(projectRoot = process.cwd()) {
   }
   cleanupStaleBaselines(dir, protectedArtifacts);
   materializeMergedRuleDir(sources, mergedDir);
-  const ruleDirForYaml = mergedDir.split(path.sep).join("/");
-  fs.writeFileSync(file, `ruleDirs:
+  const ruleDirForYaml = mergedDir.split(path2.sep).join("/");
+  fs2.writeFileSync(file, `ruleDirs:
   - ${JSON.stringify(ruleDirForYaml)}
 `);
   cachedBaselines.set(root, { fingerprint, path: file, mergedDir });
@@ -373,7 +508,7 @@ var SG_BASELINE_RETAINED_ENTRIES = 24;
 function enforceBaselineEntryCap(dir, keep) {
   let names;
   try {
-    names = fs.readdirSync(dir);
+    names = fs2.readdirSync(dir);
   } catch {
     return;
   }
@@ -383,13 +518,13 @@ 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 {
       candidates.push({
         full,
-        mtimeMs: fs.statSync(full).mtimeMs,
+        mtimeMs: fs2.statSync(full).mtimeMs,
         recursive: isMergedDir
       });
     } catch {
@@ -402,7 +537,7 @@ function enforceBaselineEntryCap(dir, keep) {
   let evicted = 0;
   for (const candidate of candidates.slice(0, over)) {
     try {
-      fs.rmSync(candidate.full, {
+      fs2.rmSync(candidate.full, {
         recursive: candidate.recursive,
         force: true
       });
@@ -426,18 +561,18 @@ function enforceBaselineEntryCap(dir, keep) {
 function cleanupStaleBaselines(dir, keep) {
   try {
     const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
-    for (const name of fs.readdirSync(dir)) {
+    for (const name of fs2.readdirSync(dir)) {
       const isConfig = /^baseline(?:-\d+(?:-[a-f0-9]+)?)?\.sgconfig\.yml$/.test(name);
       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 {
-        const stat2 = fs.statSync(full);
+        const stat2 = fs2.statSync(full);
         if (stat2.mtimeMs < cutoff) {
-          fs.rmSync(full, { recursive: stat2.isDirectory(), force: true });
+          fs2.rmSync(full, { recursive: stat2.isDirectory(), force: true });
         }
       } catch {
       }
@@ -492,8 +627,8 @@ function serverTraits(declaration) {
 }
 
 // dist/clients/lsp/config.js
-import * as os3 from "node:os";
-import path3 from "node:path";
+import * as os4 from "node:os";
+import path4 from "node:path";
 
 // dist/clients/dispatch/known-runner-ids.js
 var knownRunnerIds = /* @__PURE__ */ new Set();
@@ -510,12 +645,12 @@ function isKnownRunnerId(id) {
 // dist/clients/lsp/launch.js
 import { AsyncLocalStorage } from "node:async_hooks";
 import { execFileSync, spawn as nodeSpawn } from "node:child_process";
-import fs3 from "node:fs";
-import os2 from "node:os";
-import path2 from "node:path";
+import fs4 from "node:fs";
+import os3 from "node:os";
+import path3 from "node:path";
 
 // dist/clients/lsp/ruby-drive-dirs.js
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 var RUBY_VERSION_DIR = /^ruby\d/i;
 var rubyDirNamesCache = new BoundedLruCache(16);
 function rubyDriveKey(driveRoot) {
@@ -531,7 +666,7 @@ function getRubyVersionDirNamesSync(driveRoot) {
     return cached;
   let names;
   try {
-    names = filterRubyDirNames(fs2.readdirSync(driveRoot));
+    names = filterRubyDirNames(fs3.readdirSync(driveRoot));
   } catch {
     names = [];
   }
@@ -545,7 +680,7 @@ async function getRubyVersionDirNamesAsync(driveRoot) {
     return cached;
   let names;
   try {
-    names = filterRubyDirNames(await fs2.promises.readdir(driveRoot));
+    names = filterRubyDirNames(await fs3.promises.readdir(driveRoot));
   } catch {
     names = [];
   }
@@ -562,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;
@@ -572,8 +707,8 @@ function logSessionStart2(msg) {
   const line = redactSecrets(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
 `);
   try {
-    fs3.mkdirSync(SESSIONSTART_LOG_DIR, { recursive: true });
-    fs3.appendFileSync(SESSIONSTART_LOG, line);
+    fs4.mkdirSync(SESSIONSTART_LOG_DIR, { recursive: true });
+    fs4.appendFileSync(SESSIONSTART_LOG, line);
   } catch {
   }
 }
@@ -593,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 = [];
@@ -649,34 +784,34 @@ 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 = os2.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 home = os3.homedir();
+    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));
   }
   const toAppend = [];
   for (const candidate of candidates) {
-    if (!candidate || !fs3.existsSync(candidate))
+    if (!candidate || !fs4.existsSync(candidate))
       continue;
     const normalized = normalizePathEntry(candidate, process.platform);
     if (existing.has(normalized))
@@ -687,18 +822,18 @@ 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 {
-    const content = fs3.readFileSync(cmdPath, "utf-8");
+    const content = fs4.readFileSync(cmdPath, "utf-8");
     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);
-    return fs3.existsSync(target);
+    const relPath = match[1].replace(/[/\\]/g, path3.sep);
+    const target = path3.resolve(path3.dirname(cmdPath), "..", relPath);
+    return fs4.existsSync(target);
   } catch {
     return true;
   }
@@ -715,16 +850,16 @@ function isMissingWindowsStartupCommand(command, spawnCommand, cwd, env) {
 }
 function bypassPs1OnWindows(ps1Path, args) {
   const cmdPath = `${ps1Path.slice(0, -4)}.cmd`;
-  if (fs3.existsSync(cmdPath)) {
+  if (fs4.existsSync(cmdPath)) {
     return { command: cmdPath, args, needsShell: true };
   }
   try {
-    const content = fs3.readFileSync(ps1Path, "utf-8");
+    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);
-      if (fs3.existsSync(jsPath)) {
+      const relPath = match[1].replace(/[/\\]/g, path3.sep);
+      const jsPath = path3.resolve(path3.dirname(ps1Path), "..", relPath);
+      if (fs4.existsSync(jsPath)) {
         return {
           command: process.execPath,
           args: [jsPath, ...args],
@@ -752,7 +887,7 @@ function findBinaryOnPath(command, env) {
       timeout: 5e3
     }).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     for (const candidate of result) {
-      if (fs3.existsSync(candidate)) {
+      if (fs4.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -767,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,
@@ -801,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);
 }
@@ -910,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;
@@ -950,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);
@@ -988,7 +1145,7 @@ async function launchLSP(command, args = [], options = {}) {
   };
   proc.stderr?.on("data", onStartupStderr);
   try {
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       let settled = false;
       proc.on("error", (err) => {
         if (!settled) {
@@ -1025,7 +1182,7 @@ async function launchLSP(command, args = [], options = {}) {
       setTimeout(() => {
         if (!settled) {
           settled = true;
-          resolve3();
+          resolve4();
         }
       }, startupFailureWindowMs);
     });
@@ -1056,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)}`);
@@ -1086,7 +1243,7 @@ function recordConfigResolved(cwd, resolution, lspConfig, homeDir, resolveMs) {
   });
   logSessionStart(`config resolved documents=${summary.documents.length} legacy=${legacyDocuments} records=${summary.recordCount} deniedServers=${deniedServers} resolveMs=${resolveMs} session=${sessionId} root=${root}`);
 }
-async function loadLSPConfig(cwd, homeDir = os3.homedir(), options = {}) {
+async function loadLSPConfig(cwd, homeDir = os4.homedir(), options = {}) {
   const reporting = options.report !== false;
   publishConfigResolutionPending(cwd);
   const resolveStartedAt = Date.now();
@@ -1287,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) {
@@ -1331,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);
@@ -1447,7 +1588,7 @@ async function initLSPConfig(cwd) {
   if (existing)
     return existing;
   const promise = (async () => {
-    const config = registerLSPConfig(await loadLSPConfig(cwd, os3.homedir()));
+    const config = registerLSPConfig(await loadLSPConfig(cwd, os4.homedir()));
     forgetConfigResolvedClaims(setSessionRootConfig(normalizedCwd, config));
   })();
   configInFlight.set(normalizedCwd, promise);
@@ -1459,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));
@@ -1960,32 +2083,32 @@ function classifyCascadeWaitTier(lspService, filePath, snapshots) {
 }
 
 // dist/clients/lsp/lombok.js
-import * as fs4 from "node:fs";
-import * as os4 from "node:os";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs";
+import * as os5 from "node:os";
+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)
     return false;
   try {
-    return fs4.statSync(filePath).isFile();
+    return fs5.statSync(filePath).isFile();
   } catch {
     return false;
   }
 }
 function readTextIfSmall(filePath, maxBytes = 512 * 1024) {
   try {
-    const stat2 = fs4.statSync(filePath);
+    const stat2 = fs5.statSync(filePath);
     if (!stat2.isFile() || stat2.size > maxBytes)
       return "";
-    return fs4.readFileSync(filePath, "utf-8");
+    return fs5.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -1994,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;
   }
@@ -2010,23 +2133,23 @@ 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) {
   let best;
   for (const candidate of candidates) {
     try {
-      const stat2 = fs4.statSync(candidate);
+      const stat2 = fs5.statSync(candidate);
       if (!stat2.isFile())
         continue;
       if (!best || stat2.mtimeMs > best.mtimeMs) {
@@ -2037,35 +2160,35 @@ function newestExistingJar(candidates) {
   }
   return best?.filePath;
 }
-function mavenLocalLombokJar(home = os4.homedir()) {
-  const base = path4.join(home, ".m2", "repository", "org", "projectlombok", "lombok");
+function mavenLocalLombokJar(home = os5.homedir()) {
+  const base = path5.join(home, ".m2", "repository", "org", "projectlombok", "lombok");
   let versions = [];
   try {
-    versions = fs4.readdirSync(base);
+    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 = os4.homedir()) {
-  const base = path4.join(home, ".gradle", "caches", "modules-2", "files-2.1", "org.projectlombok", "lombok");
+function gradleCacheLombokJar(home = os5.homedir()) {
+  const base = path5.join(home, ".gradle", "caches", "modules-2", "files-2.1", "org.projectlombok", "lombok");
   const candidates = [];
   let versions = [];
   try {
-    versions = fs4.readdirSync(base);
+    versions = fs5.readdirSync(base);
   } catch {
     return void 0;
   }
   for (const version of versions) {
-    const versionDir = path4.join(base, version);
+    const versionDir = path5.join(base, version);
     let hashes = [];
     try {
-      hashes = fs4.readdirSync(versionDir);
+      hashes = fs5.readdirSync(versionDir);
     } catch {
       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);
@@ -2097,16 +2220,16 @@ function createLombokJdtlsArgs(root, baseEnv = process.env) {
 
 // dist/clients/lsp/jvm-runtime.js
 import { existsSync as existsSync2, readdirSync as readdirSync4 } from "node:fs";
-import os5 from "node:os";
-import path5 from "node:path";
+import os6 from "node:os";
+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;
 }
@@ -2119,34 +2242,34 @@ 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 [];
   }
 }
 function candidateRoots() {
-  const home = os5.homedir();
+  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 {
@@ -2170,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))
       });
     }
   }
@@ -2269,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;
@@ -2330,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,
@@ -2339,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) {
@@ -2393,6 +2516,9 @@ var PROJECT_BOUNDARY_MARKERS = [
   "Cargo.toml",
   "Cargo.lock",
   "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
   "uv.lock",
   "poetry.lock",
   "Pipfile",
@@ -2406,24 +2532,30 @@ 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 = statSync3(resolved);
-      const alternateStat = statSync3(alternatePath);
+      const actual = statSync4(resolved);
+      const alternateStat = statSync4(alternatePath);
       insensitive = actual.dev === alternateStat.dev && actual.ino === alternateStat.ino;
     } catch {
       insensitive = false;
@@ -2437,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;
@@ -2457,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))) {
@@ -2472,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);
@@ -2495,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);
@@ -2518,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)) {
@@ -2532,7 +2666,7 @@ async function nearestNonExcludedFallbackRoot(candidate) {
     }
     if (current === fsRoot)
       break;
-    current = path6.dirname(current);
+    current = path7.dirname(current);
   }
   return nearestAllowed ?? fsRoot;
 }
@@ -2573,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"
     }
@@ -2626,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";
@@ -2691,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
           }
@@ -2722,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;
@@ -2741,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({
@@ -2762,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;
     }
@@ -2895,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;
@@ -2984,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,
@@ -2999,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`];
   }
@@ -3009,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)
@@ -3017,26 +3164,26 @@ function piAgentExtensionsRootKey(file) {
   return dirKey.slice(0, index + marker.length);
 }
 function IgnoreHomeRoot(primary) {
-  const homeKey = normalizeEphemeralMapKey(path6.resolve(os6.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) {
   const candidates = [];
-  const home = os6.homedir();
+  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;
@@ -3084,8 +3231,8 @@ function createInteractiveServer(spec) {
 function PriorityRoot(markerGroups, excludePatterns, stopDir) {
   const resolvers = markerGroups.map((markers) => NearestRoot(markers, excludePatterns, stopDir));
   return withRootMarkers(async (file) => {
-    for (const resolve3 of resolvers) {
-      const root = await resolve3(file);
+    for (const resolve4 of resolvers) {
+      const root = await resolve4(file);
       if (root)
         return root;
     }
@@ -3093,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) {
@@ -3115,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;
     }
@@ -3160,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)
@@ -3172,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 = [
@@ -3193,19 +3340,19 @@ function NearestRoot(includePatterns, excludePatterns, stopDir) {
             }
           }
           if (excluded) {
-            currentDir = path6.dirname(currentDir);
+            currentDir = path7.dirname(currentDir);
             continue;
           }
         }
         for (const pattern of includePatterns) {
-          if (await markerExists(currentDir, pattern) && (pattern !== ".git" || currentDir !== os6.tmpdir()) && !await isExcludedLspRoot(currentDir)) {
+          if (await markerExists(currentDir, pattern) && (pattern !== ".git" || currentDir !== os7.tmpdir()) && !await isExcludedLspRoot(currentDir)) {
             return enforceLspRootCeiling(currentDir, process.cwd(), file);
           }
         }
         if (currentDir === stop || currentDir === fsRoot) {
           break;
         }
-        currentDir = path6.dirname(currentDir);
+        currentDir = path7.dirname(currentDir);
       }
       return void 0;
     })();
@@ -3246,18 +3393,18 @@ async function findAncestorFile(startDir, ...relativeSegments) {
   return findAncestorFileAmong(startDir, [relativeSegments]);
 }
 async function findAncestorFileAmong(startDir, candidateSegmentLists) {
-  const fs5 = await import("node:fs/promises");
-  let currentDir = path6.resolve(startDir);
+  const fs6 = await import("node:fs/promises");
+  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 fs5.access(candidate);
+        await fs6.access(candidate);
         return candidate;
       } catch {
       }
     }
-    const parent = path6.dirname(currentDir);
+    const parent = path7.dirname(currentDir);
     if (parent === currentDir)
       break;
     currentDir = parent;
@@ -3273,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;
     }
@@ -3307,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 fs5 = await import("node:fs/promises");
-  const projectRoots = await Promise.all([root, options?.sessionRoot ?? process.cwd(), process.cwd()].map((dir) => fs5.realpath(dir).catch(() => path6.resolve(dir))));
+  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(() => path7.resolve(dir))));
   const admitCandidate = async (candidate, projectSupplied) => {
     try {
-      const real = await fs5.realpath(candidate);
-      if (path6.basename(real) !== "tsserver.js" || !(await fs5.stat(real)).isFile())
+      const real = await fs6.realpath(candidate);
+      if (path7.basename(real) !== "tsserver.js" || !(await fs6.stat(real)).isFile())
         return void 0;
-      const manifest = JSON.parse(await fs5.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);
@@ -3329,19 +3491,19 @@ 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 fs5.access(cwdCandidate);
+    await fs6.access(cwdCandidate);
     const admittedCwd = await admitCandidate(cwdCandidate, false);
     if (admittedCwd)
       return admittedCwd;
   } 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)
@@ -3352,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");
@@ -3388,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;
@@ -3408,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 {
@@ -3422,29 +3583,29 @@ async function findNativeTypeScriptLsp(root) {
   return void 0;
 }
 function dotnetToolCandidates(tool) {
-  const home = os6.homedir();
+  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(os6.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(os6.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: join3 } = await import("node:path");
-  const binDir = join3(getGlobalPiLensDir(), "bin");
+  const { join: join4 } = await import("node:path");
+  const binDir = join4(getGlobalPiLensDir(), "bin");
   const { mkdir } = await import("node:fs/promises");
   await mkdir(binDir, { recursive: true });
   const result = await safeSpawnAsync("gem", ["install", gem, "--bindir", binDir, "--no-document"], { timeout: 18e4, ignoreAmbientSignal: true });
@@ -3478,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;
@@ -3499,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 {
     }
@@ -3710,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;
@@ -3785,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({
@@ -3799,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"]);
@@ -3810,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)) {
@@ -3845,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;
@@ -3871,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;
@@ -3985,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",
@@ -4653,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.`);
     }
@@ -4669,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
     };
   }
 };
@@ -4711,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
     };
   }
 };
@@ -5006,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) {
@@ -5021,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 sessionRootConfigEntries() {
-  return sessionRoots;
+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 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;
@@ -5057,12 +5247,18 @@ export {
   findLocalTyposConfig,
   getAstGrepRuleSources,
   getAstGrepRuleFingerprint,
-  isAuxiliary,
-  serverTraits,
   registerRunnerId,
   withLspProjectCodePermission,
   refuseUntrustedLspExecution,
+  resolveAnalysisRootPath,
+  resolveAnalysisRoot,
+  canWriteAnalysisRoot,
   BUILTIN_SERVER_RUNNER_COVERS,
+  isAuxiliary,
+  serverTraits,
+  getStrategy,
+  classifyServerWaitTier,
+  classifyCascadeWaitTier,
   describeRootFallback,
   resolveLspServerCwd,
   resetLSPCaseSensitivityState,
@@ -5075,6 +5271,7 @@ export {
   resetClassicTsRepairGuard,
   LSP_SERVERS,
   getServerById,
+  disabledPrimaries,
   shouldInitializeSessionRoot,
   isOutsideAllSessionRoots,
   getSessionRootsForTelemetry,
@@ -5087,8 +5284,5 @@ export {
   getServersForFileWithConfig,
   primaryServerId,
   resolveLspCwdForFile,
-  getServerInitOverride,
-  getStrategy,
-  classifyServerWaitTier,
-  classifyCascadeWaitTier
+  getServerInitOverride
 };