@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,2422 +0,0 @@
-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));
-}