@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/dist/clients/lsp/server.js

@@ -0,0 +1,2422 @@
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { access, readFile, readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { getGlobalDmLensDir, getProjectIgnoreGlobs, isPathIgnoredByProject } from "../file-utils.js";
+import { augmentPythonEnvironment, detectPythonEnvironment, detectPythonVenv, pythonEnvironmentToolCandidates } from "../python-environment.js";
+
+export { detectPythonVenv };
+import { STAGE_TMP_PATTERN } from "../atomic-write-staging.js";
+import { DOTNET_CSHARP_ROOT_MARKERS, DOTNET_FSHARP_ROOT_MARKERS, KIND_EXTENSIONS } from "../file-kinds.js";
+import { extensionsForLanguage } from "../language-registry.js";
+import { CARGO_WORKSPACE_MEMBER_DIALECT, direntsHaveMarkerGlobMatch, isAtOrAboveHomeDir, isFullyQualified, isWindowsPath, matchesWorkspaceMemberPattern, normalizeEphemeralMapKey, pathsEqual, toPosix } from "../path-utils.js";
+import { ensureTool, findManagedToolBinary, getToolEnvironment, getToolPath } from "../installer/index.js";
+import * as installer from "../installer/index.js";
+import { classifyProbeFailure, describeInstallAttempt, logAvailabilityDecision } from "../dispatch/runners/utils/availability-policy.js";
+import { resolveOpengrepConfig } from "../opengrep-config.js";
+import { isZizmorAuditTarget, resolveZizmorGitHubToken } from "../zizmor-config.js";
+import { logLatency } from "../latency-logger.js";
+import { logSessionStart } from "../sessionstart-logger.js";
+import { findLocalSgconfig, resolveBaselineSgconfig } from "../sgconfig.js";
+import { findLocalTyposConfig } from "../typos-config.js";
+import { resolvePackagePath } from "../package-root.js";
+import { resolveToolCwd } from "../tool-cwd.js";
+import { dirMtimeRecordsAsync, dirMtimesStillFreshAsync, unknownDirMtimeRecords } from "../workspace-topology.js";
+import { bounded } from "../deadline-utils.js";
+import { FRESHNESS_CADENCE_MS } from "../freshness-cadence.js";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
+import { recordDegradationOnce } from "../degradation-ledger.js";
+import { hasCargoWorkspaceTable, readCargoWorkspaceExclude, readCargoWorkspaceMembers, readTextFileOrUndefined } from "../cargo-manifest.js";
+import { resolveAstGrepNativeExe } from "./wait-policy/index.js";
+import { hasSpawnFailureKind, isCommandAvailableAsync, safeSpawnAsync } from "../safe-spawn.js";
+import { launchLSP } from "./launch.js";
+import { createLombokJdtlsArgs } from "./lombok.js";
+import { resolveJavaRuntimeEnv } from "./jvm-runtime.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { getRubyVersionDirNamesSync } from "./ruby-drive-dirs.js";
+import { getProcessSingleton } from "../process-singletons.js";
+import { createGenerationSource } from "../generation-guard.js";
+function withRootMarkers(root, markers) {
+  root.rootMarkers = markers;
+  return root;
+}
+export async function resolveLspServerCwd(server, filePath, sessionCwd, onRootFailure) {
+  const rootMarkers = server.rootMarkers ?? server.root.rootMarkers;
+  let serverRoot;
+  let rootFailed = false;
+  try {
+    serverRoot = await server.root(filePath);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    rootFailed = true;
+    onRootFailure?.(reason);
+  }
+  const isFileDirFallback = serverRoot !== undefined && rootMarkers?.length && path.resolve(serverRoot) === path.resolve(path.dirname(filePath));
+  if (!serverRoot || isFileDirFallback) {
+    if (!serverRoot) {
+      recordDegradationOnce({
+        kind: "tool-cwd-resolution",
+        subject: server.id,
+        reason: `lsp:server-root-${rootFailed ? "failed" : "fallback"}:${filePath}`
+      });
+    }
+    if (!rootMarkers?.length)
+      return;
+    return resolveToolCwd("lsp", server.id, filePath, {
+      cwd: path.dirname(path.resolve(filePath)),
+      rootMarkers
+    }).cwd;
+  }
+  const boundedServerRoot = enforceLspRootCeiling(serverRoot, sessionCwd, filePath);
+  return resolveToolCwd("lsp", server.id, filePath, {
+    cwd: sessionCwd,
+    rootMarkers,
+    serverRoot: boundedServerRoot
+  }).cwd;
+}
+const FIXTURE_ROOT_SEGMENTS = new Set(["__fixtures__", "testdata"]);
+const FALLBACK_PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "go.work",
+  "go.mod",
+  "Cargo.toml",
+  "pyproject.toml",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "mix.exs",
+  "pubspec.yaml",
+  "Package.swift"
+];
+const PROJECT_BOUNDARY_MARKERS = [
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  "go.work",
+  "go.mod",
+  "Cargo.toml",
+  "Cargo.lock",
+  "pyproject.toml",
+  "uv.lock",
+  "poetry.lock",
+  "Pipfile",
+  "Pipfile.lock",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts",
+  "mix.exs",
+  "pubspec.yaml",
+  "Package.swift"
+];
+const loggedRootCeilingClamps = new Set;
+const posixCaseInsensitiveByPath = new Map;
+function posixFilesystemIsCaseInsensitive(root) {
+  const resolved = path.resolve(root);
+  const cached = posixCaseInsensitiveByPath.get(resolved);
+  if (cached !== undefined)
+    return cached;
+  if (!existsSync(resolved)) {
+    return false;
+  }
+  const name = path.basename(resolved);
+  const alternate = name.toLowerCase() === name ? name.toUpperCase() : name.toLowerCase();
+  let insensitive = false;
+  const alternatePath = path.join(path.dirname(resolved), alternate);
+  if (alternate !== name && existsSync(alternatePath)) {
+    try {
+      const actual = statSync(resolved);
+      const alternateStat = statSync(alternatePath);
+      insensitive = actual.dev === alternateStat.dev && actual.ino === alternateStat.ino;
+    } catch {
+      insensitive = false;
+    }
+  }
+  posixCaseInsensitiveByPath.set(resolved, insensitive);
+  return insensitive;
+}
+export function resetLSPCaseSensitivityState() {
+  posixCaseInsensitiveByPath.clear();
+}
+export function _getPosixCaseSensitivityCacheSizeForTests() {
+  return posixCaseInsensitiveByPath.size;
+}
+export function isSameOrWithin(ancestor, candidate, deps = {}) {
+  const windowsShaped = isWindowsPath(ancestor) || isWindowsPath(candidate);
+  const pathApi = windowsShaped ? path.win32 : path;
+  const resolvedAncestor = pathApi.resolve(ancestor);
+  const resolvedCandidate = pathApi.resolve(candidate);
+  let caseInsensitive = false;
+  if (!windowsShaped) {
+    if (deps.caseInsensitiveProbe) {
+      const cached = posixCaseInsensitiveByPath.get(resolvedAncestor);
+      caseInsensitive = cached ?? deps.caseInsensitiveProbe(resolvedAncestor);
+      if (cached === undefined) {
+        posixCaseInsensitiveByPath.set(resolvedAncestor, caseInsensitive);
+      }
+    } else {
+      caseInsensitive = posixFilesystemIsCaseInsensitive(resolvedAncestor);
+    }
+  }
+  const relative = pathApi.relative(caseInsensitive ? resolvedAncestor.toLowerCase() : resolvedAncestor, caseInsensitive ? resolvedCandidate.toLowerCase() : resolvedCandidate);
+  return relative === "" || !relative.startsWith("..") && !pathApi.isAbsolute(relative);
+}
+export function enforceLspRootCeiling(root, sessionCwd, filePath) {
+  const windowsShaped = isWindowsPath(root) || isWindowsPath(sessionCwd);
+  const pathApi = windowsShaped ? path.win32 : path;
+  const resolvedRoot = pathApi.resolve(root);
+  const resolvedCwd = pathApi.resolve(sessionCwd);
+  if (filePath && !isSameOrWithin(resolvedCwd, pathApi.resolve(filePath))) {
+    return resolvedRoot;
+  }
+  if (isSameOrWithin(resolvedCwd, resolvedRoot))
+    return resolvedRoot;
+  const logKey = `${normalizeMapKey(resolvedCwd)}:${normalizeMapKey(resolvedRoot)}`;
+  if (!loggedRootCeilingClamps.has(logKey)) {
+    loggedRootCeilingClamps.add(logKey);
+    logSessionStart(`lsp root clamped to session cwd: candidate=${resolvedRoot} cwd=${resolvedCwd}`);
+  }
+  return resolvedCwd;
+}
+export async function hasProjectBoundaryMarker(dir) {
+  if (await markerExists(dir, ".git"))
+    return true;
+  for (const marker of PROJECT_BOUNDARY_MARKERS) {
+    if (await markerExists(dir, marker))
+      return true;
+  }
+  return false;
+}
+function pathSegments(dir) {
+  const parsed = path.parse(path.resolve(dir));
+  return path.relative(parsed.root, path.resolve(dir)).split(path.sep).filter(Boolean).map((segment) => segment.toLowerCase());
+}
+function hasFixtureConvention(dir) {
+  const segments = pathSegments(dir);
+  if (segments.some((segment) => FIXTURE_ROOT_SEGMENTS.has(segment)))
+    return true;
+  return segments.some((segment, index) => segment === "tests" && segments[index + 1] === "fixtures");
+}
+function hasAtomicStageSegment(dir) {
+  return pathSegments(dir).some((segment) => STAGE_TMP_PATTERN.test(segment));
+}
+async function findGitBoundary(dir) {
+  let current = path.resolve(dir);
+  const fsRoot = path.parse(current).root;
+  while (true) {
+    if (await markerExists(current, ".git"))
+      return current;
+    if (current === fsRoot)
+      return;
+    current = path.dirname(current);
+  }
+}
+async function isExcludedLspRoot(dir) {
+  const candidate = path.resolve(dir);
+  if (hasFixtureConvention(candidate) || hasAtomicStageSegment(candidate))
+    return true;
+  const gitRoot = await findGitBoundary(candidate);
+  if (!gitRoot || gitRoot === candidate)
+    return false;
+  if (getProjectIgnoreGlobs(gitRoot).length === 0)
+    return false;
+  return isPathIgnoredByProject(candidate, gitRoot, true);
+}
+async function nearestNonExcludedFallbackRoot(candidate) {
+  if (!await isExcludedLspRoot(candidate))
+    return path.resolve(candidate);
+  let current = path.dirname(path.resolve(candidate));
+  const fsRoot = path.parse(current).root;
+  let nearestAllowed;
+  while (true) {
+    if (!await isExcludedLspRoot(current)) {
+      nearestAllowed ??= current;
+      for (const marker of FALLBACK_PROJECT_MARKERS) {
+        if (await markerExists(current, marker))
+          return current;
+      }
+    }
+    if (current === fsRoot)
+      break;
+    current = path.dirname(current);
+  }
+  return nearestAllowed ?? fsRoot;
+}
+function isLspInstallDisabled() {
+  return process.env.DM_LENS_DISABLE_LSP_INSTALL === "1";
+}
+function canInstall(allowInstall) {
+  return allowInstall !== false && !isLspInstallDisabled();
+}
+const DIRECT_LSP_NEGATIVE_TTL_MS = Math.max(30000, Number.parseInt(process.env.DM_LENS_DIRECT_LSP_NEGATIVE_TTL_MS ?? "600000", 10) || 600000);
+const directLspCommandUnavailableUntil = new Map;
+const directLspCommandSkipLoggedUntil = new Map;
+const lspLaunchAvailabilityGeneration = createGenerationSource("lsp-launch-availability");
+export function resetLspLaunchAvailabilityGeneration() {
+  lspLaunchAvailabilityGeneration.bump();
+}
+function staleLaunch(generation, subject, proc) {
+  if (generation.isCurrent())
+    return false;
+  try {
+    proc?.process?.kill();
+  } catch {}
+  generation.guardedWrite(subject, () => {
+    return;
+  });
+  return true;
+}
+async function installEvidenceForLaunch(toolId, installed, attempt) {
+  const evidence = describeInstallAttempt(attempt);
+  const confirmedManagedPath = await findManagedToolBinary(toolId);
+  return {
+    ...evidence,
+    binary: path.basename(installed),
+    ...confirmedManagedPath !== undefined && pathsEqual(confirmedManagedPath, installed) && {
+      source: "managed-dir"
+    }
+  };
+}
+function captureInstallAttempt(toolId) {
+  try {
+    return installer.getInstallAttempt?.(toolId);
+  } catch {}
+  return;
+}
+export function resetDirectLspCommandAvailability() {
+  directLspCommandUnavailableUntil.clear();
+  directLspCommandSkipLoggedUntil.clear();
+}
+export function _markDirectLspCommandUnavailableForTests(command) {
+  markDirectLspCommandUnavailable(command);
+}
+function pruneExpiredDirectLspNegativeEntries(now = Date.now()) {
+  for (const [command, until] of directLspCommandUnavailableUntil) {
+    if (until <= now) {
+      directLspCommandUnavailableUntil.delete(command);
+      directLspCommandSkipLoggedUntil.delete(command);
+    }
+  }
+  for (const [command, until] of directLspCommandSkipLoggedUntil) {
+    if (until <= now)
+      directLspCommandSkipLoggedUntil.delete(command);
+  }
+}
+function isSimpleCommand(command) {
+  return !isFullyQualified(command) && !command.includes("/") && !command.includes("\\");
+}
+export function isDirectLspCommandTemporarilyUnavailable(command) {
+  const now = Date.now();
+  pruneExpiredDirectLspNegativeEntries(now);
+  const until = directLspCommandUnavailableUntil.get(command);
+  if (!until || until <= now) {
+    directLspCommandUnavailableUntil.delete(command);
+    return false;
+  }
+  const loggedUntil = directLspCommandSkipLoggedUntil.get(command) ?? 0;
+  if (loggedUntil <= now) {
+    logSessionStart(`lsp direct command ${command}: skipped by negative availability cache (${Math.max(0, until - now)}ms remaining)`);
+    directLspCommandSkipLoggedUntil.set(command, until);
+  }
+  return true;
+}
+function markDirectLspCommandUnavailable(command) {
+  if (!isSimpleCommand(command))
+    return;
+  directLspCommandUnavailableUntil.set(command, Date.now() + DIRECT_LSP_NEGATIVE_TTL_MS);
+  directLspCommandSkipLoggedUntil.delete(command);
+}
+const DM_LENS_BIN_DIR = path.join(getGlobalDmLensDir(), "bin");
+export async function resolveAndLaunch(spec, allowInstall) {
+  const generation = lspLaunchAvailabilityGeneration.capture();
+  const toolLabel = spec.managedToolId ?? spec.candidates[spec.candidates.length - 1] ?? "unknown";
+  let lastRuntimeFailure;
+  const trackRuntimeFailure = (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    if (!hasSpawnFailureKind(err, "tool-not-found")) {
+      lastRuntimeFailure = err instanceof Error ? err : new Error(message);
+    }
+  };
+  const managedProbeStartedAt = Date.now();
+  const managedCandidate = spec.managedToolId ? await findManagedToolBinary(spec.managedToolId) : undefined;
+  if (staleLaunch(generation, `${toolLabel}:findManagedToolBinary`)) {
+    return;
+  }
+  const candidates = managedCandidate && !spec.candidates.includes(managedCandidate) ? [managedCandidate, ...spec.candidates] : spec.candidates;
+  const candidateFailures = [];
+  for (const [index, command] of candidates.entries()) {
+    logLatency({
+      type: "phase",
+      phase: "lsp_launch_candidate_attempt",
+      filePath: spec.cwd,
+      durationMs: 0,
+      metadata: {
+        tool: toolLabel,
+        command,
+        index,
+        totalCandidates: candidates.length,
+        allowInstall: canInstall(allowInstall)
+      }
+    });
+    logSessionStart(`lsp launch candidate attempt tool=${toolLabel} idx=${index}/${candidates.length - 1} command=${command} cwd=${spec.cwd}`);
+    try {
+      const proc = await launchLSP(command, spec.args, {
+        cwd: spec.cwd,
+        env: spec.env
+      });
+      if (staleLaunch(generation, `${toolLabel}:launchLSP:${command}`, proc)) {
+        return;
+      }
+      logLatency({
+        type: "phase",
+        phase: "lsp_launch_candidate_success",
+        filePath: spec.cwd,
+        durationMs: 0,
+        metadata: {
+          tool: toolLabel,
+          command,
+          index,
+          source: "direct"
+        }
+      });
+      logSessionStart(`lsp launch candidate success tool=${toolLabel} idx=${index} command=${command} source=direct`);
+      if (managedCandidate !== undefined && command === managedCandidate) {
+        logAvailabilityDecision({
+          tool: toolLabel,
+          verdict: "available",
+          outcome: "success",
+          cause: "ok",
+          elapsedMs: Date.now() - managedProbeStartedAt,
+          latched: false,
+          producer: "lsp-launch",
+          classifiedBy: "probe",
+          evidence: {
+            binary: path.basename(managedCandidate),
+            source: "managed-dir",
+            correctsLatchedRow: false
+          }
+        });
+      }
+      return { process: proc, source: "direct" };
+    } catch (err) {
+      if (staleLaunch(generation, `${toolLabel}:launchLSP:${command}`)) {
+        return;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      candidateFailures.push({ index, command, message, err });
+    }
+  }
+  for (const failure of candidateFailures) {
+    logLatency({
+      type: "phase",
+      phase: "lsp_launch_candidate_failed",
+      filePath: spec.cwd,
+      durationMs: 0,
+      metadata: {
+        tool: toolLabel,
+        command: failure.command,
+        index: failure.index,
+        error: failure.message
+      }
+    });
+    logSessionStart(`lsp launch candidate failed tool=${toolLabel} idx=${failure.index} command=${failure.command} error=${failure.message}`);
+    trackRuntimeFailure(failure.err);
+  }
+  const hasOnlyRepairableCandidateFailures = candidateFailures.every((failure) => hasSpawnFailureKind(failure.err, "tool-not-found"));
+  if (!hasOnlyRepairableCandidateFailures) {
+    if (lastRuntimeFailure)
+      throw lastRuntimeFailure;
+    return;
+  }
+  if (!canInstall(allowInstall)) {
+    logSessionStart(`lsp launch install blocked tool=${toolLabel} cwd=${spec.cwd} allowInstall=${allowInstall !== false} globalDisabled=${isLspInstallDisabled()}`);
+    logLatency({
+      type: "phase",
+      phase: "lsp_launch_install_blocked",
+      filePath: spec.cwd,
+      durationMs: 0,
+      metadata: {
+        tool: toolLabel,
+        allowInstall,
+        globalInstallDisabled: isLspInstallDisabled()
+      }
+    });
+    return;
+  }
+  if (spec.managedToolId) {
+    const failedCandidate = candidateFailures.at(-1);
+    const classifiedFailure = classifyProbeFailure({
+      error: failedCandidate?.err instanceof Error ? failedCandidate.err : undefined,
+      spawnFailure: {
+        kind: hasSpawnFailureKind(failedCandidate?.err, "tool-not-found") ? "tool-not-found" : undefined
+      }
+    }, { command: failedCandidate?.command });
+    logAvailabilityDecision({
+      tool: spec.managedToolId,
+      verdict: "unavailable",
+      outcome: classifiedFailure.outcome,
+      cause: classifiedFailure.cause,
+      elapsedMs: Date.now() - managedProbeStartedAt,
+      latched: false,
+      classifiedBy: "probe",
+      producer: "lsp-launch",
+      evidence: classifiedFailure.evidence
+    });
+    logSessionStart(`lsp launch ensure-tool start tool=${spec.managedToolId} cwd=${spec.cwd}`);
+    const installStartedAt = Date.now();
+    const installed = await ensureTool(spec.managedToolId);
+    const installAttempt = captureInstallAttempt(spec.managedToolId);
+    if (staleLaunch(generation, `${toolLabel}:ensureTool`)) {
+      return;
+    }
+    logSessionStart(`lsp launch ensure-tool result tool=${spec.managedToolId} installed=${installed ? "yes" : "no"} path=${installed ?? ""}`);
+    logLatency({
+      type: "phase",
+      phase: "lsp_launch_ensure_tool_result",
+      filePath: spec.cwd,
+      durationMs: 0,
+      metadata: {
+        tool: spec.managedToolId,
+        installed: Boolean(installed),
+        path: installed
+      }
+    });
+    if (installed) {
+      try {
+        const proc = await launchLSP(installed, spec.args, {
+          cwd: spec.cwd,
+          env: spec.env
+        });
+        if (staleLaunch(generation, `${toolLabel}:launchLSP:managed`, proc)) {
+          return;
+        }
+        logSessionStart(`lsp launch managed success tool=${spec.managedToolId} command=${installed} source=managed`);
+        logLatency({
+          type: "phase",
+          phase: "lsp_launch_managed_success",
+          filePath: spec.cwd,
+          durationMs: 0,
+          metadata: {
+            tool: spec.managedToolId,
+            command: installed
+          }
+        });
+        const evidence = await installEvidenceForLaunch(spec.managedToolId, installed, installAttempt);
+        if (staleLaunch(generation, `${toolLabel}:managed-evidence`, proc)) {
+          return;
+        }
+        logAvailabilityDecision({
+          tool: spec.managedToolId,
+          verdict: "available",
+          outcome: "success",
+          cause: "ok",
+          elapsedMs: Date.now() - installStartedAt,
+          latched: false,
+          classifiedBy: "caller",
+          producer: "lsp-launch",
+          evidence: {
+            ...evidence,
+            correctsLatchedRow: false
+          }
+        });
+        return { process: proc, source: "managed" };
+      } catch (err) {
+        if (staleLaunch(generation, `${toolLabel}:launchLSP:managed-rejection`)) {
+          return;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        logSessionStart(`lsp launch managed failed tool=${spec.managedToolId} command=${installed} error=${message}`);
+        logLatency({
+          type: "phase",
+          phase: "lsp_launch_managed_failed",
+          filePath: spec.cwd,
+          durationMs: 0,
+          metadata: {
+            tool: spec.managedToolId,
+            command: installed,
+            error: message
+          }
+        });
+        trackRuntimeFailure(err);
+        const looksPathResolved = !installed.includes("/") && !installed.includes("\\");
+        if (looksPathResolved && hasSpawnFailureKind(err, "tool-not-found")) {
+          logSessionStart(`lsp launch managed retry force-reinstall tool=${spec.managedToolId}`);
+          const reinstalled = await ensureTool(spec.managedToolId, {
+            forceReinstall: true
+          });
+          const reinstallAttempt = captureInstallAttempt(spec.managedToolId);
+          if (staleLaunch(generation, `${toolLabel}:forceReinstall`)) {
+            return;
+          }
+          if (reinstalled) {
+            try {
+              const proc = await launchLSP(reinstalled, spec.args, {
+                cwd: spec.cwd,
+                env: spec.env
+              });
+              if (staleLaunch(generation, `${toolLabel}:launchLSP:forceReinstall`, proc)) {
+                return;
+              }
+              logSessionStart(`lsp launch managed force-reinstall success tool=${spec.managedToolId} command=${reinstalled}`);
+              logLatency({
+                type: "phase",
+                phase: "lsp_launch_managed_force_reinstall_success",
+                filePath: spec.cwd,
+                durationMs: 0,
+                metadata: {
+                  tool: spec.managedToolId,
+                  command: reinstalled
+                }
+              });
+              const evidence = await installEvidenceForLaunch(spec.managedToolId, reinstalled, reinstallAttempt);
+              if (staleLaunch(generation, `${toolLabel}:forceReinstall-evidence`, proc)) {
+                return;
+              }
+              logAvailabilityDecision({
+                tool: spec.managedToolId,
+                verdict: "available",
+                outcome: "success",
+                cause: "ok",
+                elapsedMs: Date.now() - installStartedAt,
+                latched: false,
+                classifiedBy: "caller",
+                producer: "lsp-launch",
+                evidence: {
+                  ...evidence,
+                  correctsLatchedRow: false
+                }
+              });
+              return { process: proc, source: "managed" };
+            } catch (retryErr) {
+              logSessionStart(`lsp launch managed force-reinstall failed tool=${spec.managedToolId} error=${retryErr instanceof Error ? retryErr.message : String(retryErr)}`);
+            }
+          }
+        }
+      }
+    }
+  }
+  const runtimeInstall = spec.runtimeInstall;
+  const runtimeAvailable = runtimeInstall ? await isOnPath(runtimeInstall.runtimeCommand) : false;
+  if (staleLaunch(generation, `${toolLabel}:runtimeAvailability`)) {
+    return;
+  }
+  if (runtimeInstall && runtimeAvailable) {
+    const ok = await runtimeInstall.install();
+    if (staleLaunch(generation, `${toolLabel}:runtimeInstall`)) {
+      return;
+    }
+    if (ok) {
+      const retry = runtimeInstall.retryCandidates ?? spec.candidates;
+      for (const command of retry) {
+        try {
+          const proc = await launchLSP(command, spec.args, {
+            cwd: spec.cwd,
+            env: spec.env
+          });
+          if (staleLaunch(generation, `${toolLabel}:launchLSP:runtime`, proc)) {
+            return;
+          }
+          return { process: proc, source: "managed" };
+        } catch (err) {
+          if (staleLaunch(generation, `${toolLabel}:launchLSP:runtime`)) {
+            return;
+          }
+          trackRuntimeFailure(err);
+        }
+      }
+    }
+  }
+  if (lastRuntimeFailure) {
+    throw lastRuntimeFailure;
+  }
+  return;
+}
+async function resolveAndLaunchBundle(spec, allowInstall) {
+  let runtime;
+  for (const candidate of spec.runtimeCandidates) {
+    if (await isOnPath(candidate)) {
+      runtime = candidate;
+      break;
+    }
+  }
+  if (!runtime) {
+    logSessionStart(`lsp launch bundle skip tool=${spec.bundleToolId}: no runtime on PATH (tried ${spec.runtimeCandidates.join(", ")})`);
+    return;
+  }
+  let bundleDir = await getToolPath(spec.bundleToolId);
+  if (!bundleDir && canInstall(allowInstall)) {
+    bundleDir = await ensureTool(spec.bundleToolId);
+  }
+  if (!bundleDir) {
+    logSessionStart(`lsp launch bundle skip tool=${spec.bundleToolId}: bundle not installed (allowInstall=${allowInstall !== false})`);
+    return;
+  }
+  try {
+    const proc = await launchLSP(runtime, spec.args(bundleDir), {
+      cwd: spec.cwd,
+      env: spec.env
+    });
+    logSessionStart(`lsp launch bundle success tool=${spec.bundleToolId} runtime=${runtime} bundle=${bundleDir}`);
+    return { process: proc, source: "managed" };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logSessionStart(`lsp launch bundle failed tool=${spec.bundleToolId} runtime=${runtime} error=${message}`);
+    return;
+  }
+}
+async function resolveAndLaunchTreeBinary(spec, allowInstall) {
+  for (const command of spec.candidates) {
+    try {
+      const proc = await launchLSP(command, spec.args, {
+        cwd: spec.cwd,
+        env: spec.env
+      });
+      return { process: proc, source: "direct" };
+    } catch {}
+  }
+  let bundleDir = await getToolPath(spec.bundleToolId);
+  if (!bundleDir && canInstall(allowInstall)) {
+    bundleDir = await ensureTool(spec.bundleToolId);
+  }
+  if (!bundleDir) {
+    logSessionStart(`lsp launch tree-bin skip tool=${spec.bundleToolId}: not on PATH and bundle not installed (allowInstall=${allowInstall !== false})`);
+    return;
+  }
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  const binPath = path.join(bundleDir, ...spec.binRelPath.split("/")) + suffix;
+  try {
+    const proc = await launchLSP(binPath, spec.args, {
+      cwd: spec.cwd,
+      env: spec.env
+    });
+    logSessionStart(`lsp launch tree-bin success tool=${spec.bundleToolId} bin=${binPath}`);
+    return { process: proc, source: "managed" };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logSessionStart(`lsp launch tree-bin failed tool=${spec.bundleToolId} bin=${binPath} error=${message}`);
+    return;
+  }
+}
+function nodeBinLocalCandidates(root, baseName) {
+  const localBase = path.join(root, "node_modules", ".bin", baseName);
+  if (process.platform === "win32") {
+    return [`${localBase}.cmd`, `${localBase}.exe`];
+  }
+  return [localBase];
+}
+function nodeBinCandidates(root, baseName) {
+  return [...nodeBinLocalCandidates(root, baseName), baseName];
+}
+function piAgentExtensionsRootKey(file) {
+  const dirKey = normalizeEphemeralMapKey(path.dirname(path.resolve(file)));
+  const marker = "/.pi/agent/extensions";
+  const index = dirKey.indexOf(marker);
+  if (index === -1)
+    return;
+  return dirKey.slice(0, index + marker.length);
+}
+function IgnoreHomeRoot(primary) {
+  const homeKey = normalizeEphemeralMapKey(path.resolve(os.homedir()));
+  return withRootMarkers(async (file) => {
+    const root = await primary(file);
+    if (!root)
+      return;
+    return normalizeEphemeralMapKey(path.resolve(root)) === homeKey ? undefined : root;
+  }, primary.rootMarkers ?? []);
+}
+function rubyBinCandidates(baseName) {
+  const candidates = [];
+  const home = os.homedir();
+  const isWin = process.platform === "win32";
+  const ext = isWin ? ".bat" : "";
+  candidates.push(path.join(home, ".local", "share", "mise", "installs", "ruby", "bin", `${baseName}${ext}`));
+  candidates.push(path.join(home, ".asdf", "installs", "ruby", "bin", `${baseName}${ext}`));
+  if (isWin) {
+    const driveRoot = path.parse(home).root;
+    for (const entry of getRubyVersionDirNamesSync(driveRoot)) {
+      candidates.push(path.join(driveRoot, entry, "bin", `${baseName}.bat`));
+      candidates.push(path.join(driveRoot, entry, "bin", baseName));
+    }
+  }
+  return candidates;
+}
+function createInteractiveServer(spec) {
+  return {
+    id: spec.id,
+    name: spec.name,
+    extensions: spec.extensions,
+    root: spec.root,
+    rootMarkers: spec.root.rootMarkers,
+    fallbackFor: spec.fallbackFor,
+    availabilityKey: typeof spec.command === "string" && isSimpleCommand(spec.command) ? spec.command : undefined,
+    async spawn(root) {
+      const command = typeof spec.command === "function" ? spec.command(root) : spec.command;
+      const args = typeof spec.args === "function" ? spec.args(root) : spec.args || [];
+      if (isSimpleCommand(command) && isDirectLspCommandTemporarilyUnavailable(command)) {
+        return;
+      }
+      const runtimeEnv = spec.runtime === "java" ? await resolveJavaRuntimeEnv() : undefined;
+      try {
+        const proc = await launchLSP(command, args, {
+          cwd: root,
+          ...runtimeEnv ? { env: runtimeEnv } : {}
+        });
+        const initialization = typeof spec.initialization === "function" ? spec.initialization(root) : spec.initialization;
+        return { process: proc, source: "direct", initialization };
+      } catch (err) {
+        if (hasSpawnFailureKind(err, "tool-not-found")) {
+          markDirectLspCommandUnavailable(command);
+        }
+        return;
+      }
+    }
+  };
+}
+export function PriorityRoot(markerGroups, excludePatterns, stopDir) {
+  const resolvers = markerGroups.map((markers) => NearestRoot(markers, excludePatterns, stopDir));
+  return withRootMarkers(async (file) => {
+    for (const resolve of resolvers) {
+      const root = await resolve(file);
+      if (root)
+        return root;
+    }
+    return;
+  }, markerGroups.flat());
+}
+export const FileDirRoot = async (file) => {
+  const candidate = path.resolve(path.dirname(file));
+  return nearestNonExcludedFallbackRoot(candidate);
+};
+export function RootWithFallback(primary, fallback = FileDirRoot) {
+  return withRootMarkers(async (file) => {
+    const primaryRoot = await primary(file);
+    if (primaryRoot)
+      return primaryRoot;
+    return fallback(file);
+  }, primary.rootMarkers ?? []);
+}
+export function WorkspacePriorityRoot(markerGroups, excludePatterns) {
+  return withRootMarkers(async (file) => PriorityRoot(markerGroups, excludePatterns, process.cwd())(file), markerGroups.flat());
+}
+function isPermissionFsError(err) {
+  const code = err?.code;
+  return code === "EACCES" || code === "EPERM";
+}
+function markerProbeDir(dir, pattern) {
+  const normalized = toPosix(pattern);
+  const slash = normalized.lastIndexOf("/");
+  const parentPattern = slash >= 0 ? normalized.slice(0, slash) : "";
+  return parentPattern ? path.join(dir, ...parentPattern.split("/").filter(Boolean)) : dir;
+}
+async function markerExists(dir, pattern) {
+  if (!pattern.includes("*")) {
+    try {
+      await stat(path.join(dir, pattern));
+      return true;
+    } catch (err) {
+      if (isPermissionFsError(err)) {
+        logSessionStart(`lsp root marker skipped: permission error stat ${path.join(dir, pattern)}`);
+      }
+      return false;
+    }
+  }
+  const normalized = pattern.replace(/\\/g, "/");
+  const slash = normalized.lastIndexOf("/");
+  const basenamePattern = slash >= 0 ? normalized.slice(slash + 1) : normalized;
+  if (!basenamePattern)
+    return false;
+  const targetDir = markerProbeDir(dir, normalized);
+  try {
+    const entries = await readdir(targetDir, { withFileTypes: true });
+    return direntsHaveMarkerGlobMatch(entries, basenamePattern);
+  } catch (err) {
+    if (isPermissionFsError(err)) {
+      logSessionStart(`lsp root marker skipped: permission error read ${targetDir}`);
+    }
+    return false;
+  }
+}
+const rootMtimeBound = (label) => ({
+  ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+  signal: undefined,
+  hook: "tool_result_edit",
+  label
+});
+export function NearestRoot(includePatterns, excludePatterns, stopDir) {
+  const cache = new Map;
+  const inFlight = new Map;
+  const subdirPatterns = [];
+  for (const pattern of [...includePatterns, ...excludePatterns ?? []]) {
+    if (markerProbeDir("", pattern))
+      subdirPatterns.push(pattern);
+  }
+  return withRootMarkers(async (file) => {
+    const startDir = path.resolve(path.dirname(file));
+    const dirKey = normalizeMapKey(startDir);
+    const cached = cache.get(dirKey);
+    if (cached !== undefined && Date.now() - cached.walkedAt < FRESHNESS_CADENCE_MS && await bounded(dirMtimesStillFreshAsync(cached.probedDirs), rootMtimeBound("lsp-root-memo-freshness")) === true)
+      return cached.root;
+    const flying = inFlight.get(dirKey);
+    if (flying)
+      return flying;
+    const probedDirs = [];
+    const walkedAt = Date.now();
+    const promise = (async () => {
+      let currentDir = startDir;
+      const fsRoot = path.parse(currentDir).root;
+      const stop = stopDir ? path.resolve(stopDir) : fsRoot;
+      while (true) {
+        if (stop !== fsRoot && currentDir.startsWith(stop + path.sep) === false && currentDir !== stop) {
+          break;
+        }
+        const stepDirs = [
+          currentDir,
+          ...subdirPatterns.map((pattern) => markerProbeDir(currentDir, pattern))
+        ];
+        const stepRecords = await bounded(dirMtimeRecordsAsync(stepDirs), rootMtimeBound("lsp-root-walk-dir-mtimes"));
+        probedDirs.push(...stepRecords ?? unknownDirMtimeRecords(stepDirs));
+        if (excludePatterns) {
+          let excluded = false;
+          for (const pattern of excludePatterns) {
+            if (await markerExists(currentDir, pattern)) {
+              excluded = true;
+              break;
+            }
+          }
+          if (excluded) {
+            currentDir = path.dirname(currentDir);
+            continue;
+          }
+        }
+        for (const pattern of includePatterns) {
+          if (await markerExists(currentDir, pattern) && (pattern !== ".git" || currentDir !== os.tmpdir()) && !await isExcludedLspRoot(currentDir)) {
+            return enforceLspRootCeiling(currentDir, process.cwd(), file);
+          }
+        }
+        if (currentDir === stop || currentDir === fsRoot) {
+          break;
+        }
+        currentDir = path.dirname(currentDir);
+      }
+      return;
+    })();
+    inFlight.set(dirKey, promise);
+    try {
+      const result = await promise;
+      if (result !== undefined)
+        cache.set(dirKey, { root: result, probedDirs, walkedAt });
+      return result;
+    } finally {
+      inFlight.delete(dirKey);
+    }
+  }, includePatterns);
+}
+export const createRootDetector = NearestRoot;
+function isOnPath(command) {
+  return isCommandAvailableAsync(command);
+}
+export async function tryGoInstallGopls() {
+  const isWindows = process.platform === "win32";
+  const result = await safeSpawnAsync(isWindows ? "go.exe" : "go", ["install", "golang.org/x/tools/gopls@latest"], { timeout: 180000, ignoreAmbientSignal: true });
+  return !result.error && result.status === 0;
+}
+export async function tryDotnetToolInstall(tool) {
+  mkdirSync(DM_LENS_BIN_DIR, { recursive: true });
+  const result = await safeSpawnAsync("dotnet", ["tool", "install", "--tool-path", DM_LENS_BIN_DIR, tool], { timeout: 180000, ignoreAmbientSignal: true });
+  if (!result.error && result.status === 0)
+    return true;
+  const stderr = result.stderr ?? "";
+  if (stderr.includes("No NuGet sources are defined or enabled")) {
+    logSessionStart(`lsp dotnet-install: NuGet sources missing — cannot install ${tool}. ` + `Run: dotnet nuget add source https://api.nuget.org/v3/index.json -n nuget.org`);
+    return false;
+  }
+  const updateResult = await safeSpawnAsync("dotnet", ["tool", "update", "--tool-path", DM_LENS_BIN_DIR, tool], { timeout: 180000, ignoreAmbientSignal: true });
+  return !updateResult.error && updateResult.status === 0;
+}
+async function findAncestorFile(startDir, ...relativeSegments) {
+  return findAncestorFileAmong(startDir, [relativeSegments]);
+}
+async function findAncestorFileAmong(startDir, candidateSegmentLists) {
+  const fs = await import("node:fs/promises");
+  let currentDir = path.resolve(startDir);
+  while (!isAtOrAboveHomeDir(currentDir)) {
+    for (const segments of candidateSegmentLists) {
+      const candidate = path.join(currentDir, ...segments);
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {}
+    }
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir)
+      break;
+    currentDir = parent;
+  }
+  return;
+}
+const CLASSIC_TS_REPAIR_FAMILY = "lsp.classic-ts-repair-guard";
+const CLASSIC_TS_REPAIR_VERSION = 1;
+function classicTsRepairState() {
+  return getProcessSingleton(CLASSIC_TS_REPAIR_FAMILY, CLASSIC_TS_REPAIR_VERSION, () => ({ attempted: false }));
+}
+export function resetClassicTsRepairGuard() {
+  classicTsRepairState().attempted = false;
+}
+export function _resetClassicTsRepairForTests() {
+  resetClassicTsRepairGuard();
+}
+function typescriptDirsForTsc(tscPath) {
+  const binDir = path.dirname(tscPath);
+  return [
+    path.join(binDir, "..", "typescript"),
+    path.join(binDir, "..", "..", "typescript")
+  ];
+}
+async function typescriptVersionForTsc(tscPath) {
+  if (!path.isAbsolute(tscPath))
+    return;
+  for (const dir of typescriptDirsForTsc(tscPath)) {
+    let manifest;
+    try {
+      manifest = await readFile(path.join(dir, "package.json"), "utf8");
+    } catch {
+      continue;
+    }
+    let version;
+    try {
+      const parsed = JSON.parse(manifest);
+      if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || typeof parsed.version !== "string") {
+        return;
+      }
+      version = parsed.version;
+    } catch {
+      return;
+    }
+    const majorText = version.split(".", 1)[0] ?? "";
+    const major = /^\d+$/.test(majorText) ? Number(majorText) : Number.NaN;
+    if (!Number.isFinite(major))
+      return;
+    return { version, major };
+  }
+  return;
+}
+async function findTsserverPath(root, allowInstall) {
+  const fs = await import("node:fs/promises");
+  const ancestorHit = await findAncestorFile(root, "node_modules", "typescript", "lib", "tsserver.js");
+  if (ancestorHit)
+    return ancestorHit;
+  const cwdCandidate = path.join(process.cwd(), "node_modules", "typescript", "lib", "tsserver.js");
+  try {
+    await fs.access(cwdCandidate);
+    return cwdCandidate;
+  } catch {}
+  const tsserverForTsc = async (tscPath) => {
+    if (!tscPath)
+      return;
+    for (const dir of typescriptDirsForTsc(tscPath)) {
+      const candidate = path.join(dir, "lib", "tsserver.js");
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {}
+    }
+    return;
+  };
+  const installAllowed = canInstall(allowInstall);
+  const discoveredTsc = 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)
+    return;
+  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", {
+    allowInstall: true,
+    forceReinstall: true
+  });
+  return tsserverForTsc(repairedTsc);
+}
+async function findNativeTypeScriptLsp(root) {
+  let currentDir = path.resolve(root);
+  while (!isAtOrAboveHomeDir(currentDir)) {
+    const typescriptDir = path.join(currentDir, "node_modules", "typescript");
+    const packageJsonPath = path.join(typescriptDir, "package.json");
+    let packageJsonText;
+    try {
+      packageJsonText = await readFile(packageJsonPath, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        return;
+      }
+      try {
+        const dirStat = await stat(typescriptDir);
+        if (dirStat.isDirectory())
+          return;
+      } catch {}
+      const parent = path.dirname(currentDir);
+      if (parent === currentDir)
+        return;
+      currentDir = parent;
+      continue;
+    }
+    let version;
+    try {
+      const parsed = JSON.parse(packageJsonText);
+      if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || typeof parsed.version !== "string") {
+        return;
+      }
+      version = parsed.version;
+    } catch {
+      return;
+    }
+    const majorText = version.split(".", 1)[0] ?? "";
+    const major = /^\d+$/.test(majorText) ? Number(majorText) : Number.NaN;
+    if (!Number.isFinite(major) || major < 7)
+      return;
+    const localTsc = path.join(currentDir, "node_modules", ".bin", "tsc");
+    const candidates = process.platform === "win32" ? [`${localTsc}.cmd`, `${localTsc}.exe`, localTsc] : [localTsc];
+    for (const command of candidates) {
+      try {
+        await access(command);
+        return { command, version };
+      } catch {}
+    }
+    return;
+  }
+  return;
+}
+function dotnetToolCandidates(tool) {
+  const home = os.homedir();
+  return [
+    path.join(DM_LENS_BIN_DIR, `${tool}.exe`),
+    path.join(DM_LENS_BIN_DIR, tool),
+    path.join(home, ".dotnet", "tools", `${tool}.exe`),
+    path.join(home, ".dotnet", "tools", tool),
+    tool
+  ].filter(Boolean);
+}
+function binExeVariants(dir, tool) {
+  return process.platform === "win32" ? [path.join(dir, `${tool}.exe`), path.join(dir, tool)] : [path.join(dir, tool)];
+}
+export function goBinCandidates(tool) {
+  const gopath = process.env.GOPATH?.split(path.delimiter)[0] || path.join(os.homedir(), "go");
+  return [tool, ...binExeVariants(path.join(gopath, "bin"), tool)];
+}
+export function cargoBinCandidates(tool) {
+  const cargoHome = process.env.CARGO_HOME || path.join(os.homedir(), ".cargo");
+  return [tool, ...binExeVariants(path.join(cargoHome, "bin"), tool)];
+}
+export async function tryGemInstall(gem) {
+  const { join } = await import("node:path");
+  const binDir = join(getGlobalDmLensDir(), "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: 180000, ignoreAmbientSignal: true });
+  const ok = !result.error && result.status === 0;
+  if (ok) {
+    const sep = process.platform === "win32" ? ";" : ":";
+    if (!process.env.PATH?.includes(binDir)) {
+      process.env.PATH = `${binDir}${sep}${process.env.PATH ?? ""}`;
+    }
+  }
+  return ok;
+}
+export function DenoExcludeRoot(primary) {
+  const denoDetector = createRootDetector(["deno.json", "deno.jsonc"]);
+  return async (file) => {
+    const denoRoot = await denoDetector(file);
+    if (denoRoot)
+      return;
+    return primary(file);
+  };
+}
+const JS_TS_LSP_EXTENSIONS = KIND_EXTENSIONS["jsts"].filter((ext) => ext !== ".svelte" && ext !== ".vue");
+const TS_CONFIG_MARKERS = ["tsconfig.json", "jsconfig.json"];
+const TS_TOOLING_MARKERS = [
+  "package-lock.json",
+  "bun.lockb",
+  "bun.lock",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "package.json"
+];
+const TS_FAMILY_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts"]);
+function isTsFamilyFile(file) {
+  return TS_FAMILY_EXTENSIONS.has(path.extname(file).toLowerCase());
+}
+function tsConfigMarkersForFile(file) {
+  return isTsFamilyFile(file) ? ["tsconfig.json"] : TS_CONFIG_MARKERS;
+}
+const TypeScriptConfigRootTsOnly = IgnoreHomeRoot(createRootDetector(["tsconfig.json"]));
+const TypeScriptConfigRootEither = IgnoreHomeRoot(createRootDetector([...TS_CONFIG_MARKERS]));
+const TypeScriptToolingRoot = IgnoreHomeRoot(createRootDetector([...TS_TOOLING_MARKERS]));
+async function findTypeScriptProjectRoot(file) {
+  const configDetector = isTsFamilyFile(file) ? TypeScriptConfigRootTsOnly : TypeScriptConfigRootEither;
+  const [configRoot, toolingRoot] = await Promise.all([
+    configDetector(file),
+    TypeScriptToolingRoot(file)
+  ]);
+  if (!configRoot)
+    return toolingRoot;
+  if (!toolingRoot)
+    return configRoot;
+  return isSameOrWithin(toolingRoot, configRoot) ? configRoot : toolingRoot;
+}
+async function findExtensionBoundedRoot(file, extensionRootKey) {
+  const startDir = path.resolve(path.dirname(file));
+  let currentDir = startDir;
+  const configMarkers = tsConfigMarkersForFile(file);
+  while (true) {
+    for (const pattern of configMarkers) {
+      try {
+        await stat(path.join(currentDir, pattern));
+        return currentDir;
+      } catch {}
+    }
+    for (const pattern of TS_TOOLING_MARKERS) {
+      try {
+        await stat(path.join(currentDir, pattern));
+        return currentDir;
+      } catch {}
+    }
+    const currentKey = normalizeEphemeralMapKey(path.resolve(currentDir));
+    if (currentKey === extensionRootKey)
+      return;
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir)
+      return;
+    currentDir = parent;
+  }
+}
+async function hasAgentLevelProjectMarker(extensionRootKey) {
+  const agentDir = path.dirname(extensionRootKey);
+  if (!agentDir || agentDir === extensionRootKey)
+    return false;
+  for (const pattern of [...TS_CONFIG_MARKERS, ...TS_TOOLING_MARKERS]) {
+    try {
+      await stat(path.join(agentDir, pattern));
+      return true;
+    } catch {}
+  }
+  return false;
+}
+const TypeScriptRoot = withRootMarkers(DenoExcludeRoot(async (file) => {
+  const extensionRootKey = piAgentExtensionsRootKey(file);
+  if (extensionRootKey) {
+    const bounded = await findExtensionBoundedRoot(file, extensionRootKey);
+    if (bounded)
+      return bounded;
+    if (await hasAgentLevelProjectMarker(extensionRootKey)) {
+      return FileDirRoot(file);
+    }
+    return;
+  }
+  const projectRoot = await findTypeScriptProjectRoot(file);
+  if (projectRoot)
+    return projectRoot;
+  return FileDirRoot(file);
+}), [...TS_CONFIG_MARKERS, ...TS_TOOLING_MARKERS]);
+export const TypeScriptServer = {
+  id: "typescript",
+  name: "TypeScript Language Server",
+  extensions: JS_TS_LSP_EXTENSIONS,
+  autoPropagateDiagnostics: true,
+  root: TypeScriptRoot,
+  rootMarkers: TypeScriptRoot.rootMarkers,
+  async spawn(root, options) {
+    const fs = await import("node:fs/promises");
+    const nativeLsp = await findNativeTypeScriptLsp(root);
+    if (nativeLsp) {
+      const env = await getToolEnvironment();
+      logSessionStart(`lsp typescript-native: version=${nativeLsp.version} command=${nativeLsp.command}`);
+      const proc = await launchLSP(nativeLsp.command, ["--lsp", "--stdio"], {
+        cwd: root,
+        env
+      });
+      return { process: proc, source: "direct", launchVariant: "native-ts7" };
+    }
+    let source = "direct";
+    let lspPath = await findAncestorFileAmong(root, [
+      ["node_modules", ".bin", "typescript-language-server.cmd"],
+      ["node_modules", ".bin", "typescript-language-server"]
+    ]);
+    if (!lspPath) {
+      lspPath = await ensureTool("typescript-language-server", {
+        allowInstall: canInstall(options?.allowInstall)
+      });
+      if (lspPath)
+        source = "managed";
+      if (!lspPath) {
+        return;
+      }
+    }
+    let tsserverPath = await findTsserverPath(root, options?.allowInstall);
+    if (!tsserverPath) {
+      const localCandidate = path.join(path.dirname(lspPath), "..", "typescript", "lib", "tsserver.js");
+      try {
+        await fs.access(localCandidate);
+        tsserverPath = localCandidate;
+      } catch {}
+    }
+    if (tsserverPath)
+      source = "managed";
+    const env = await getToolEnvironment();
+    const proc = await launchLSP(lspPath, ["--stdio"], {
+      cwd: root,
+      env: {
+        ...env,
+        TSSERVER_PATH: tsserverPath
+      }
+    });
+    return {
+      process: proc,
+      source,
+      initialization: tsserverPath ? { tsserver: { path: tsserverPath } } : undefined,
+      launchVariant: "classic"
+    };
+  }
+};
+export const DenoServer = {
+  id: "deno",
+  name: "Deno Language Server",
+  fallbackFor: "typescript",
+  extensions: JS_TS_LSP_EXTENSIONS,
+  autoPropagateDiagnostics: true,
+  root: createRootDetector(["deno.json", "deno.jsonc"]),
+  async spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["deno"],
+      args: ["lsp"],
+      cwd: root,
+      managedToolId: "deno"
+    }, options?.allowInstall);
+  }
+};
+export const PythonServer = {
+  id: "python",
+  name: "Pyright Language Server",
+  extensions: KIND_EXTENSIONS["python"],
+  root: RootWithFallback(createRootDetector([
+    ".git",
+    "pyproject.toml",
+    "setup.py",
+    "setup.cfg",
+    "requirements.txt",
+    "Pipfile",
+    "poetry.lock"
+  ])),
+  async spawn(root, options) {
+    const pythonEnvironment = await detectPythonEnvironment(root);
+    const env = augmentPythonEnvironment(await getToolEnvironment(), pythonEnvironment);
+    let source = "direct";
+    const pyrightInit = (pythonPath) => ({
+      ...pythonPath ? { pythonPath } : {},
+      openFilesOnly: true
+    });
+    const projectPyright = await resolveAndLaunch({
+      candidates: [
+        ...pythonEnvironmentToolCandidates(pythonEnvironment, "pyright-langserver"),
+        ...nodeBinLocalCandidates(root, "pyright-langserver"),
+        ...pythonEnvironmentToolCandidates(pythonEnvironment, "basedpyright-langserver"),
+        ...nodeBinLocalCandidates(root, "basedpyright-langserver")
+      ],
+      args: ["--stdio"],
+      cwd: root,
+      env
+    }, false);
+    if (projectPyright) {
+      return {
+        process: projectPyright.process,
+        source: projectPyright.source,
+        initialization: pyrightInit(pythonEnvironment?.pythonPath)
+      };
+    }
+    const projectTy = await resolveAndLaunch({
+      candidates: pythonEnvironmentToolCandidates(pythonEnvironment, "ty"),
+      args: ["server"],
+      cwd: root,
+      env
+    }, false);
+    if (projectTy) {
+      return { process: projectTy.process, source: projectTy.source };
+    }
+    const pathPyright = await resolveAndLaunch({
+      candidates: ["pyright-langserver", "basedpyright-langserver"],
+      args: ["--stdio"],
+      cwd: root,
+      env
+    }, false);
+    if (pathPyright) {
+      return {
+        process: pathPyright.process,
+        source: pathPyright.source,
+        initialization: pyrightInit(pythonEnvironment?.pythonPath)
+      };
+    }
+    const pathTy = await resolveAndLaunch({
+      candidates: ["ty"],
+      args: ["server"],
+      cwd: root,
+      env
+    }, false);
+    if (pathTy) {
+      return { process: pathTy.process, source: pathTy.source };
+    }
+    const pyrightPath = await ensureTool("pyright", {
+      allowInstall: canInstall(options?.allowInstall)
+    });
+    if (!pyrightPath)
+      return;
+    source = "managed";
+    const binDir = path.dirname(pyrightPath);
+    const isWindows = process.platform === "win32";
+    const managedCandidates = isWindows ? [
+      path.join(binDir, "pyright-langserver.cmd"),
+      path.join(binDir, "pyright-langserver"),
+      "pyright-langserver"
+    ] : [path.join(binDir, "pyright-langserver"), "pyright-langserver"];
+    const resolved = await resolveAndLaunch({ candidates: managedCandidates, args: ["--stdio"], cwd: root, env }, false);
+    if (!resolved)
+      return;
+    return {
+      process: resolved.process,
+      source,
+      initialization: pyrightInit(pythonEnvironment?.pythonPath)
+    };
+  }
+};
+export const PythonJediServer = {
+  id: "python-jedi",
+  name: "Jedi Language Server",
+  fallbackFor: "python",
+  extensions: KIND_EXTENSIONS["python"],
+  root: RootWithFallback(createRootDetector([
+    ".git",
+    "pyproject.toml",
+    "setup.py",
+    "setup.cfg",
+    "requirements.txt",
+    "Pipfile",
+    "poetry.lock"
+  ])),
+  async spawn(root, options) {
+    const launched = await resolveAndLaunch({
+      candidates: ["jedi-language-server"],
+      args: [],
+      cwd: root,
+      managedToolId: "jedi-language-server"
+    }, options?.allowInstall);
+    if (!launched)
+      return;
+    const pythonPath = await detectPythonVenv(root);
+    return {
+      ...launched,
+      initialization: pythonPath ? { workspace: { environmentPath: pythonPath } } : {}
+    };
+  }
+};
+export const GoServer = {
+  id: "go",
+  name: "gopls",
+  extensions: KIND_EXTENSIONS["go"],
+  root: RootWithFallback(WorkspacePriorityRoot([["go.work"], ["go.mod", "go.sum"], [".git"]])),
+  async spawn(root, options) {
+    const result = await resolveAndLaunch({
+      candidates: goBinCandidates("gopls"),
+      args: [],
+      cwd: root,
+      runtimeInstall: {
+        runtimeCommand: "go",
+        install: tryGoInstallGopls
+      }
+    }, options?.allowInstall);
+    if (!result)
+      return;
+    return { ...result, initialization: { ui: { semanticTokens: true } } };
+  }
+};
+function cargoWorkspaceDeclaresMember(workspaceContent, parentDir, childDir) {
+  const relativePath = path.relative(parentDir, childDir).split(path.sep).join("/");
+  if (relativePath === "" || relativePath.startsWith(".."))
+    return false;
+  const matches = (pattern) => matchesWorkspaceMemberPattern(pattern, relativePath, CARGO_WORKSPACE_MEMBER_DIALECT);
+  const excluded = readCargoWorkspaceExclude(workspaceContent);
+  if (excluded.some(matches))
+    return false;
+  return readCargoWorkspaceMembers(workspaceContent).some(matches);
+}
+function sessionHoistCeiling(sessionCwd, file) {
+  return isSameOrWithin(path.resolve(sessionCwd), path.resolve(file)) ? path.resolve(sessionCwd) : undefined;
+}
+function RustWorkspaceRoot() {
+  const crateRoot = createRootDetector(["Cargo.toml", "Cargo.lock"]);
+  return withRootMarkers(async (file) => {
+    const root = await crateRoot(file);
+    if (!root)
+      return;
+    const sessionCwd = process.cwd();
+    const stop = sessionHoistCeiling(sessionCwd, file);
+    let current = root;
+    const fsRoot = path.parse(current).root;
+    while (true) {
+      if (stop !== undefined && current === stop)
+        break;
+      const parent = path.dirname(current);
+      if (parent === current || parent === fsRoot)
+        break;
+      const parentCargoPath = path.join(parent, "Cargo.toml");
+      const parentCargoContent = await readTextFileOrUndefined(parentCargoPath);
+      if (parentCargoContent !== undefined && hasCargoWorkspaceTable(parentCargoContent)) {
+        if (cargoWorkspaceDeclaresMember(parentCargoContent, parent, root)) {
+          return enforceLspRootCeiling(parent, sessionCwd, file);
+        }
+        break;
+      }
+      current = parent;
+    }
+    return root;
+  }, crateRoot.rootMarkers ?? []);
+}
+function stripXmlComments(content) {
+  let result = content;
+  let previous;
+  do {
+    previous = result;
+    result = result.replace(/<!--[\s\S]*?-->/g, "");
+  } while (result !== previous);
+  return result;
+}
+async function declaresMavenModule(parentDir, parentPomPath, childDir) {
+  try {
+    const content = stripXmlComments(await readFile(parentPomPath, "utf-8"));
+    const modulesBlock = content.match(/<modules>([\s\S]*?)<\/modules>/);
+    if (!modulesBlock)
+      return false;
+    const resolvedChild = path.resolve(childDir);
+    for (const match of modulesBlock[1].matchAll(/<module>\s*([^<]+?)\s*<\/module>/g)) {
+      if (pathsEqual(path.resolve(parentDir, match[1]), resolvedChild))
+        return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function JavaWorkspaceRoot() {
+  const moduleRoot = createRootDetector([
+    "pom.xml",
+    "build.gradle",
+    ".classpath"
+  ]);
+  return withRootMarkers(async (file) => {
+    const root = await moduleRoot(file);
+    if (!root)
+      return;
+    if (!await markerExists(root, "pom.xml"))
+      return root;
+    const sessionCwd = process.cwd();
+    const stop = sessionHoistCeiling(sessionCwd, file);
+    let current = root;
+    let lastHop = root;
+    const fsRoot = path.parse(current).root;
+    while (true) {
+      if (stop !== undefined && current === stop)
+        break;
+      const parent = path.dirname(current);
+      if (parent === current || parent === fsRoot)
+        break;
+      if (await markerExists(parent, "pom.xml")) {
+        const parentPom = path.join(parent, "pom.xml");
+        if (!await declaresMavenModule(parent, parentPom, lastHop))
+          break;
+        current = parent;
+        lastHop = parent;
+        continue;
+      }
+      current = parent;
+    }
+    return enforceLspRootCeiling(lastHop, sessionCwd, file);
+  }, moduleRoot.rootMarkers ?? []);
+}
+export const RustServer = {
+  id: "rust",
+  name: "rust-analyzer",
+  extensions: KIND_EXTENSIONS["rust"],
+  root: RustWorkspaceRoot(),
+  async spawn(root, options) {
+    const result = await resolveAndLaunch({
+      candidates: cargoBinCandidates("rust-analyzer"),
+      args: [],
+      cwd: root,
+      managedToolId: "rust-analyzer"
+    }, options?.allowInstall);
+    if (!result)
+      return;
+    return {
+      ...result,
+      initialization: {
+        cargo: { buildScripts: { enable: true } },
+        procMacro: { enable: true },
+        diagnostics: { enable: true }
+      }
+    };
+  }
+};
+export const RubyServer = {
+  id: "ruby",
+  name: "Ruby LSP",
+  extensions: KIND_EXTENSIONS["ruby"],
+  root: RootWithFallback(PriorityRoot([["Gemfile", ".ruby-version"], [".git"]])),
+  initializeTimeoutMs: 30000,
+  clientWaitTimeoutMs: 30000,
+  async spawn(root, options) {
+    const rubylsp = await resolveAndLaunch({
+      candidates: ["ruby-lsp", ...rubyBinCandidates("ruby-lsp")],
+      args: [],
+      cwd: root,
+      runtimeInstall: {
+        runtimeCommand: "gem",
+        install: () => tryGemInstall("ruby-lsp"),
+        retryCandidates: ["ruby-lsp", ...rubyBinCandidates("ruby-lsp")]
+      }
+    }, options?.allowInstall);
+    if (rubylsp)
+      return rubylsp;
+    const solargraph = await resolveAndLaunch({
+      candidates: ["solargraph", ...rubyBinCandidates("solargraph")],
+      args: ["stdio"],
+      cwd: root
+    }, false);
+    if (solargraph)
+      return solargraph;
+    return resolveAndLaunch({
+      candidates: ["rubocop", ...rubyBinCandidates("rubocop")],
+      args: ["--lsp"],
+      cwd: root
+    }, false);
+  }
+};
+export const PHPServer = {
+  id: "php",
+  name: "Intelephense",
+  extensions: KIND_EXTENSIONS["php"],
+  root: RootWithFallback(createRootDetector(["composer.json", "composer.lock"])),
+  async spawn(root, options) {
+    const result = await resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "intelephense"),
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "intelephense"
+    }, options?.allowInstall);
+    if (!result)
+      return;
+    return {
+      ...result,
+      initialization: {
+        storagePath: path.join(getGlobalDmLensDir(), "intelephense")
+      }
+    };
+  }
+};
+function buildPsesArgs(bundleDir) {
+  const script = path.join(bundleDir, "PowerShellEditorServices", "Start-EditorServices.ps1");
+  const sessionDir = path.join(getGlobalDmLensDir(), "pses", `${process.pid}-${Date.now()}`);
+  mkdirSync(sessionDir, { recursive: true });
+  const logPath = path.join(sessionDir, "pses.log");
+  const sessionDetailsPath = path.join(sessionDir, "session.json");
+  return [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    script,
+    "-HostName",
+    "dm-lens",
+    "-HostProfileId",
+    "dm-lens",
+    "-HostVersion",
+    "1.0.0",
+    "-BundledModulesPath",
+    bundleDir,
+    "-LogPath",
+    logPath,
+    "-LogLevel",
+    "Warning",
+    "-SessionDetailsPath",
+    sessionDetailsPath,
+    "-Stdio",
+    "-LanguageServiceOnly"
+  ];
+}
+export const PowerShellServer = {
+  id: "powershell",
+  name: "PowerShell Editor Services",
+  extensions: KIND_EXTENSIONS["powershell"],
+  root: RootWithFallback(createRootDetector([".git"])),
+  spawn(root, options) {
+    return resolveAndLaunchBundle({
+      runtimeCandidates: ["pwsh", "powershell"],
+      bundleToolId: "powershell-editor-services",
+      cwd: root,
+      args: buildPsesArgs
+    }, options?.allowInstall);
+  }
+};
+export const CSharpServer = {
+  id: "csharp",
+  name: "csharp-ls",
+  extensions: KIND_EXTENSIONS["csharp"],
+  root: createRootDetector([...DOTNET_CSHARP_ROOT_MARKERS]),
+  async spawn(root, options) {
+    const candidates = dotnetToolCandidates("csharp-ls");
+    return resolveAndLaunch({
+      candidates,
+      args: [],
+      cwd: root,
+      runtimeInstall: {
+        runtimeCommand: "dotnet",
+        install: () => tryDotnetToolInstall("csharp-ls"),
+        retryCandidates: candidates
+      }
+    }, options?.allowInstall);
+  }
+};
+export const OmniSharpServer = createInteractiveServer({
+  id: "omnisharp",
+  name: "OmniSharp",
+  fallbackFor: "csharp",
+  extensions: KIND_EXTENSIONS["csharp"],
+  root: createRootDetector([...DOTNET_CSHARP_ROOT_MARKERS]),
+  language: "csharp",
+  command: "OmniSharp",
+  args: ["--languageserver"]
+});
+export const FSharpServer = {
+  id: "fsharp",
+  name: "FSAutocomplete",
+  extensions: KIND_EXTENSIONS["fsharp"],
+  root: createRootDetector([...DOTNET_FSHARP_ROOT_MARKERS]),
+  async spawn(root, options) {
+    const candidates = dotnetToolCandidates("fsautocomplete");
+    return resolveAndLaunch({
+      candidates,
+      args: [],
+      cwd: root,
+      runtimeInstall: {
+        runtimeCommand: "dotnet",
+        install: () => tryDotnetToolInstall("fsautocomplete"),
+        retryCandidates: candidates
+      }
+    }, options?.allowInstall);
+  }
+};
+export const JavaServer = createInteractiveServer({
+  id: "java",
+  name: "JDT Language Server",
+  extensions: KIND_EXTENSIONS["java"],
+  root: RootWithFallback(JavaWorkspaceRoot()),
+  language: "java",
+  command: () => process.env.JDTLS_PATH || "jdtls",
+  args: (root) => createLombokJdtlsArgs(root),
+  runtime: "java"
+});
+export const KotlinServer = {
+  id: "kotlin",
+  name: "Kotlin Language Server",
+  extensions: KIND_EXTENSIONS["kotlin"],
+  root: RootWithFallback(createRootDetector(["build.gradle.kts", "build.gradle", "pom.xml"])),
+  async spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["kotlin-lsp", "kotlin-language-server"],
+      args: [],
+      cwd: root
+    }, options?.allowInstall);
+  }
+};
+export const SwiftServer = createInteractiveServer({
+  id: "swift",
+  name: "SourceKit-LSP",
+  extensions: KIND_EXTENSIONS["swift"],
+  root: createRootDetector(["Package.swift"]),
+  language: "swift",
+  command: "sourcekit-lsp"
+});
+export const DartServer = createInteractiveServer({
+  id: "dart",
+  name: "Dart Analysis Server",
+  extensions: KIND_EXTENSIONS["dart"],
+  root: RootWithFallback(createRootDetector(["pubspec.yaml"])),
+  language: "dart",
+  command: "dart",
+  args: ["language-server", "--protocol=lsp"]
+});
+function createTreeBinaryServer(spec) {
+  return {
+    id: spec.id,
+    name: spec.name,
+    extensions: spec.extensions,
+    root: spec.root,
+    spawn(root, options) {
+      return resolveAndLaunchTreeBinary({
+        candidates: [spec.binaryName],
+        bundleToolId: spec.binaryName,
+        binRelPath: spec.binRelPath,
+        cwd: root,
+        args: spec.args ?? []
+      }, options?.allowInstall);
+    }
+  };
+}
+export const LuaServer = createTreeBinaryServer({
+  id: "lua",
+  name: "Lua Language Server",
+  extensions: KIND_EXTENSIONS["lua"],
+  root: createRootDetector([".luarc.json", ".luacheckrc"]),
+  binaryName: "lua-language-server",
+  binRelPath: "bin/lua-language-server"
+});
+export const CppServer = createTreeBinaryServer({
+  id: "cpp",
+  name: "clangd",
+  extensions: KIND_EXTENSIONS["cxx"],
+  root: RootWithFallback(createRootDetector([
+    "compile_commands.json",
+    ".clangd",
+    "CMakeLists.txt",
+    "Makefile"
+  ])),
+  binaryName: "clangd",
+  binRelPath: "bin/clangd",
+  args: ["--background-index"]
+});
+export const ZigServer = {
+  id: "zig",
+  name: "ZLS",
+  extensions: KIND_EXTENSIONS["zig"],
+  root: RootWithFallback(createRootDetector(["build.zig"])),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["zls"],
+      args: [],
+      cwd: root,
+      managedToolId: "zls"
+    }, options?.allowInstall);
+  }
+};
+export const HaskellServer = createInteractiveServer({
+  id: "haskell",
+  name: "Haskell Language Server",
+  extensions: KIND_EXTENSIONS["haskell"],
+  root: createRootDetector(["stack.yaml", "cabal.project", "*.cabal"]),
+  language: "haskell",
+  command: "haskell-language-server-wrapper",
+  args: ["--lsp"]
+});
+export const ElixirServer = createInteractiveServer({
+  id: "elixir",
+  name: "ElixirLS",
+  extensions: KIND_EXTENSIONS["elixir"],
+  root: RootWithFallback(createRootDetector(["mix.exs"])),
+  language: "elixir",
+  command: "elixir-ls"
+});
+export const ElixirExpertServer = {
+  id: "expert",
+  name: "Expert",
+  fallbackFor: "elixir",
+  extensions: KIND_EXTENSIONS["elixir"],
+  root: RootWithFallback(createRootDetector(["mix.exs"])),
+  availabilityKey: "expert",
+  async spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["expert"],
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "expert"
+    }, options?.allowInstall);
+  },
+  autoInstall: async () => Boolean(await ensureTool("expert"))
+};
+export const GleamServer = {
+  id: "gleam",
+  name: "Gleam LSP",
+  extensions: KIND_EXTENSIONS["gleam"],
+  root: RootWithFallback(createRootDetector(["gleam.toml"])),
+  async spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["gleam"],
+      args: ["lsp"],
+      cwd: root,
+      managedToolId: "gleam"
+    }, options?.allowInstall);
+  }
+};
+export const TinymistServer = {
+  id: "tinymist",
+  name: "Tinymist",
+  extensions: extensionsForLanguage("typst"),
+  root: RootWithFallback(createRootDetector(["typst.toml", ".git"])),
+  availabilityKey: "tinymist",
+  async spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["tinymist"],
+      args: ["lsp"],
+      cwd: root,
+      managedToolId: "tinymist"
+    }, options?.allowInstall);
+  }
+};
+export const MarksmanServer = {
+  id: "marksman",
+  name: "Marksman",
+  extensions: KIND_EXTENSIONS["markdown"],
+  root: RootWithFallback(createRootDetector([".marksman.toml", ".git"])),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["marksman"],
+      args: ["server"],
+      cwd: root,
+      managedToolId: "marksman"
+    }, options?.allowInstall);
+  }
+};
+export const OCamlServer = createInteractiveServer({
+  id: "ocaml",
+  name: "ocamllsp",
+  extensions: KIND_EXTENSIONS["ocaml"],
+  root: createRootDetector(["dune-project", "opam"]),
+  language: "ocaml",
+  command: "ocamllsp"
+});
+export const ClojureServer = {
+  id: "clojure",
+  name: "Clojure LSP",
+  extensions: KIND_EXTENSIONS["clojure"],
+  root: createRootDetector(["deps.edn", "project.clj"]),
+  async spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["clojure-lsp"],
+      args: [],
+      cwd: root,
+      managedToolId: "clojure-lsp"
+    }, options?.allowInstall);
+  }
+};
+export const CueServer = {
+  id: "cue",
+  name: "CUE Language Server",
+  extensions: KIND_EXTENSIONS["cue"],
+  root: RootWithFallback(createRootDetector(["cue.mod", ".git"])),
+  async spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["cue"],
+      args: ["lsp", "serve"],
+      cwd: root,
+      managedToolId: "cue"
+    }, options?.allowInstall);
+  }
+};
+export const TerraformServer = {
+  id: "terraform",
+  name: "Terraform LSP",
+  extensions: KIND_EXTENSIONS["terraform"],
+  root: RootWithFallback(createRootDetector([".terraform.lock.hcl", ".terraform"])),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["terraform-ls"],
+      args: ["serve"],
+      cwd: root,
+      managedToolId: "terraform-ls"
+    }, options?.allowInstall);
+  }
+};
+export const NixServer = createInteractiveServer({
+  id: "nix",
+  name: "nixd",
+  extensions: KIND_EXTENSIONS["nix"],
+  root: createRootDetector(["flake.nix"]),
+  language: "nix",
+  command: "nixd"
+});
+export const BashServer = {
+  id: "bash",
+  name: "Bash Language Server",
+  extensions: [".bash", ".sh", ".zsh"],
+  root: FileDirRoot,
+  clientWaitTimeoutMs: 20000,
+  initializeTimeoutMs: 20000,
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "bash-language-server"),
+      args: ["start"],
+      cwd: root,
+      managedToolId: "bash-language-server"
+    }, options?.allowInstall);
+  }
+};
+export const FishServer = {
+  id: "fish",
+  name: "Fish Language Server",
+  extensions: KIND_EXTENSIONS["fish"],
+  root: RootWithFallback(createRootDetector([".git"])),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "fish-lsp"),
+      args: ["start", "--stdio"],
+      cwd: root,
+      managedToolId: "fish-lsp"
+    }, options?.allowInstall);
+  }
+};
+export const CMakeServer = {
+  id: "cmake",
+  name: "CMake Language Server",
+  extensions: [...KIND_EXTENSIONS["cmake"], "CMakeLists.txt"],
+  root: RootWithFallback(createRootDetector(["CMakeLists.txt", ".git"])),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["cmake-language-server"],
+      args: [],
+      cwd: root,
+      managedToolId: "cmake-language-server"
+    }, options?.allowInstall);
+  }
+};
+export const DockerServer = {
+  id: "docker",
+  name: "Dockerfile Language Server",
+  extensions: [".dockerfile", "Dockerfile"],
+  root: RootWithFallback(PriorityRoot([
+    [
+      "docker-compose.yml",
+      "docker-compose.yaml",
+      "compose.yml",
+      "compose.yaml"
+    ],
+    [".git"]
+  ])),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "docker-langserver"),
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "dockerfile-language-server-nodejs"
+    }, options?.allowInstall);
+  }
+};
+export const YamlServer = {
+  id: "yaml",
+  name: "YAML Language Server",
+  extensions: KIND_EXTENSIONS["yaml"],
+  root: RootWithFallback(PriorityRoot([
+    [".yamllint", "yamllint.yml", "yamllint.yaml", "pyproject.toml"],
+    [".git"]
+  ])),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "yaml-language-server"),
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "yaml-language-server"
+    }, options?.allowInstall);
+  }
+};
+export const JsonServer = {
+  id: "json",
+  name: "VSCode JSON Language Server",
+  extensions: KIND_EXTENSIONS["json"],
+  root: RootWithFallback(WorkspacePriorityRoot([
+    ["package.json", "tsconfig.json", "jsconfig.json"],
+    [".git"]
+  ])),
+  clientWaitTimeoutMs: 20000,
+  initializeTimeoutMs: 20000,
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["vscode-json-language-server"],
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "vscode-json-language-server"
+    }, options?.allowInstall);
+  }
+};
+export const HtmlServer = {
+  id: "html",
+  name: "VSCode HTML Language Server",
+  extensions: KIND_EXTENSIONS["html"],
+  root: RootWithFallback(IgnoreHomeRoot(PriorityRoot([["package.json", "index.html", "vite.config.ts"]]))),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "vscode-html-language-server"),
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "vscode-html-languageserver-bin"
+    }, options?.allowInstall);
+  }
+};
+export const TomlServer = {
+  id: "toml",
+  name: "Taplo",
+  extensions: KIND_EXTENSIONS["toml"],
+  root: RootWithFallback(PriorityRoot([["pyproject.toml", "Cargo.toml", "taplo.toml"], [".git"]])),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["taplo"],
+      args: ["lsp", "stdio"],
+      cwd: root,
+      managedToolId: "taplo"
+    }, options?.allowInstall);
+  }
+};
+export const PrismaServer = {
+  id: "prisma",
+  name: "Prisma Language Server",
+  extensions: KIND_EXTENSIONS["prisma"],
+  root: RootWithFallback(createRootDetector(["prisma/schema.prisma", "schema.prisma"])),
+  clientWaitTimeoutMs: 40000,
+  initializeTimeoutMs: 40000,
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "prisma-language-server"),
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "@prisma/language-server"
+    }, options?.allowInstall);
+  }
+};
+export const VueServer = {
+  id: "vue",
+  name: "Vue Language Server",
+  extensions: [".vue"],
+  root: RootWithFallback(IgnoreHomeRoot(createRootDetector([
+    "package.json",
+    "package-lock.json",
+    "bun.lockb",
+    "bun.lock",
+    "pnpm-lock.yaml",
+    "yarn.lock"
+  ]))),
+  clientWaitTimeoutMs: 30000,
+  initializeTimeoutMs: 30000,
+  async spawn(root, options) {
+    const tsserverPath = await findTsserverPath(root, options?.allowInstall);
+    const hasPackageJson = existsSync(path.join(root, "package.json"));
+    const hasNodeModules = existsSync(path.join(root, "node_modules"));
+    if (hasPackageJson && !hasNodeModules) {
+      logSessionStart(`lsp vue: node_modules missing in ${root} — Vue navigation may be limited. ` + `Run: npm install (or pnpm/yarn install) in this project.`);
+    }
+    const proc = await resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "vue-language-server"),
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "@vue/language-server"
+    }, options?.allowInstall);
+    if (!proc)
+      return;
+    return {
+      process: proc.process,
+      source: proc.source,
+      initialization: tsserverPath ? { typescript: { tsdk: path.dirname(tsserverPath) } } : undefined
+    };
+  }
+};
+export const SvelteServer = {
+  id: "svelte",
+  name: "Svelte Language Server",
+  extensions: [".svelte"],
+  root: RootWithFallback(IgnoreHomeRoot(createRootDetector([
+    "package.json",
+    "package-lock.json",
+    "bun.lockb",
+    "bun.lock",
+    "pnpm-lock.yaml",
+    "yarn.lock"
+  ]))),
+  clientWaitTimeoutMs: 20000,
+  initializeTimeoutMs: 20000,
+  async spawn(root, options) {
+    const tsserverPath = await findTsserverPath(root, options?.allowInstall);
+    const proc = await resolveAndLaunch({
+      candidates: [
+        ...nodeBinCandidates(root, "svelteserver"),
+        ...nodeBinCandidates(root, "svelte-language-server")
+      ],
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "svelte-language-server"
+    }, options?.allowInstall);
+    if (!proc)
+      return;
+    return {
+      process: proc.process,
+      source: proc.source,
+      initialization: tsserverPath ? { typescript: { tsdk: path.dirname(tsserverPath) } } : undefined
+    };
+  }
+};
+export const CssServer = {
+  id: "css",
+  name: "CSS Language Server",
+  extensions: KIND_EXTENSIONS["css"],
+  root: RootWithFallback(IgnoreHomeRoot(PriorityRoot([
+    [
+      "package.json",
+      "postcss.config.js",
+      "tailwind.config.js",
+      "vite.config.ts"
+    ]
+  ]))),
+  spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: nodeBinCandidates(root, "vscode-css-language-server"),
+      args: ["--stdio"],
+      cwd: root,
+      managedToolId: "vscode-css-languageserver"
+    }, options?.allowInstall);
+  }
+};
+const OPENGREP_KINDS = [
+  "csharp",
+  "css",
+  "cxx",
+  "dart",
+  "docker",
+  "go",
+  "html",
+  "java",
+  "json",
+  "jsts",
+  "kotlin",
+  "lua",
+  "php",
+  "python",
+  "ruby",
+  "rust",
+  "shell",
+  "swift",
+  "terraform",
+  "yaml"
+];
+const OPENGREP_EXTENSIONS = Array.from(new Set(OPENGREP_KINDS.flatMap((k) => KIND_EXTENSIONS[k] ?? [])));
+function opengrepInitialization(root) {
+  const resolved = resolveOpengrepConfig(root, { enabled: true });
+  return {
+    scan: {
+      configuration: [resolved.configArg ?? "auto"],
+      onlyGitDirty: false,
+      jobs: 16
+    },
+    metrics: { enabled: false },
+    doHover: false
+  };
+}
+export const OpengrepServer = {
+  id: "opengrep",
+  name: "Opengrep Security Scanner",
+  role: "auxiliary",
+  extensions: OPENGREP_EXTENSIONS,
+  root: RootWithFallback(NearestRoot([".git"]), async () => process.cwd()),
+  availabilityKey: "opengrep",
+  initializeTimeoutMs: 15000,
+  async spawn(root, options) {
+    const launched = await resolveAndLaunch({
+      candidates: ["opengrep"],
+      args: ["lsp", "--experimental"],
+      cwd: root,
+      managedToolId: "opengrep"
+    }, options?.allowInstall);
+    if (!launched)
+      return;
+    return { ...launched, initialization: opengrepInitialization(root) };
+  },
+  autoInstall: async () => Boolean(await ensureTool("opengrep"))
+};
+const AST_GREP_KINDS = [
+  "csharp",
+  "cxx",
+  "css",
+  "elixir",
+  "go",
+  "haskell",
+  "html",
+  "java",
+  "json",
+  "jsts",
+  "kotlin",
+  "lua",
+  "nix",
+  "php",
+  "python",
+  "ruby",
+  "rust",
+  "scala",
+  "shell",
+  "swift",
+  "yaml"
+];
+const AST_GREP_EXTENSIONS = Array.from(new Set(AST_GREP_KINDS.flatMap((k) => KIND_EXTENSIONS[k] ?? [])));
+export const AstGrepServer = {
+  id: "ast-grep",
+  name: "ast-grep structural linter",
+  role: "auxiliary",
+  extensions: AST_GREP_EXTENSIONS,
+  root: RootWithFallback(createRootDetector(["sgconfig.yml", "sgconfig.yaml"]), RootWithFallback(NearestRoot([".git"]), async () => process.cwd())),
+  availabilityKey: "ast-grep",
+  notifyInflightLimit: 4,
+  initializeTimeoutMs: 15000,
+  async spawn(root, options) {
+    const projectSgconfig = findLocalSgconfig(root);
+    let args = ["lsp"];
+    if (!projectSgconfig) {
+      const baseline = resolveBaselineSgconfig(root);
+      if (baseline)
+        args = ["lsp", "--config", baseline];
+    }
+    const nativeExe = resolveAstGrepNativeExe();
+    const candidates = nativeExe ? [nativeExe, "ast-grep"] : ["ast-grep"];
+    return resolveAndLaunch({
+      candidates,
+      args,
+      cwd: root,
+      managedToolId: "ast-grep"
+    }, options?.allowInstall);
+  },
+  autoInstall: async () => Boolean(await ensureTool("ast-grep"))
+};
+const ZIZMOR_EXTENSIONS = KIND_EXTENSIONS["yaml"];
+export const ZizmorServer = {
+  id: "zizmor",
+  name: "zizmor Actions Security Scanner",
+  role: "auxiliary",
+  extensions: ZIZMOR_EXTENSIONS,
+  pathFilter: isZizmorAuditTarget,
+  root: RootWithFallback(NearestRoot([".git"]), async () => process.cwd()),
+  availabilityKey: "zizmor",
+  async spawn(root, options) {
+    const ghToken = await resolveZizmorGitHubToken();
+    return resolveAndLaunch({
+      candidates: ["zizmor"],
+      args: ["--lsp"],
+      cwd: root,
+      managedToolId: "zizmor",
+      ...ghToken ? { env: { GH_TOKEN: ghToken } } : {}
+    }, options?.allowInstall);
+  },
+  autoInstall: async () => Boolean(await ensureTool("zizmor"))
+};
+const TYPOS_EXTENSIONS = Array.from(new Set([...OPENGREP_EXTENSIONS, ...KIND_EXTENSIONS["markdown"]]));
+function typosInitialization(root) {
+  const localConfig = findLocalTyposConfig(root);
+  if (localConfig) {
+    logLatency({
+      type: "phase",
+      phase: "typos_config_resolved",
+      filePath: root,
+      durationMs: 0,
+      metadata: { mode: "project_config", configPath: localConfig }
+    });
+    logSessionStart(`typos config resolved mode=project_config configPath=${localConfig}`);
+    return;
+  }
+  const configPath = resolvePackagePath(import.meta.url, "rules", "typos", "_typos.toml");
+  logLatency({
+    type: "phase",
+    phase: "typos_config_resolved",
+    filePath: root,
+    durationMs: 0,
+    metadata: { mode: "injected_default", configPath }
+  });
+  logSessionStart(`typos config resolved mode=injected_default configPath=${configPath}`);
+  return { config: configPath };
+}
+export const TyposServer = {
+  id: "typos",
+  name: "typos Spell Checker",
+  role: "auxiliary",
+  extensions: TYPOS_EXTENSIONS,
+  root: RootWithFallback(NearestRoot([".git"]), async () => process.cwd()),
+  availabilityKey: "typos-lsp",
+  async spawn(root, options) {
+    const launched = await resolveAndLaunch({
+      candidates: ["typos-lsp"],
+      args: [],
+      cwd: root,
+      managedToolId: "typos-lsp"
+    }, options?.allowInstall);
+    if (!launched)
+      return;
+    const initialization = typosInitialization(root);
+    return initialization ? { ...launched, initialization } : launched;
+  },
+  autoInstall: async () => Boolean(await ensureTool("typos-lsp"))
+};
+export const LSP_SERVERS = [
+  TypeScriptServer,
+  DenoServer,
+  PythonServer,
+  PythonJediServer,
+  GoServer,
+  RustServer,
+  RubyServer,
+  PHPServer,
+  PowerShellServer,
+  CSharpServer,
+  OmniSharpServer,
+  FSharpServer,
+  JavaServer,
+  KotlinServer,
+  SwiftServer,
+  DartServer,
+  LuaServer,
+  CppServer,
+  ZigServer,
+  HaskellServer,
+  ElixirServer,
+  ElixirExpertServer,
+  GleamServer,
+  TinymistServer,
+  MarksmanServer,
+  OCamlServer,
+  ClojureServer,
+  CueServer,
+  TerraformServer,
+  NixServer,
+  BashServer,
+  FishServer,
+  CMakeServer,
+  DockerServer,
+  YamlServer,
+  JsonServer,
+  HtmlServer,
+  TomlServer,
+  PrismaServer,
+  VueServer,
+  SvelteServer,
+  CssServer,
+  OpengrepServer,
+  AstGrepServer,
+  ZizmorServer,
+  TyposServer
+];
+export function getServerForExtension(ext) {
+  return LSP_SERVERS.find((server) => server.extensions.includes(ext));
+}
+export function getServerById(id) {
+  return LSP_SERVERS.find((server) => server.id === id);
+}
+export function getServersForFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return LSP_SERVERS.filter((server) => server.extensions.includes(ext));
+}