@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,4639 @@
+import { CASCADE_DIAGNOSTICS_TTL_MS } from "../cascade-types.js";
+import * as nodeFs from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL, URL } from "node:url";
+import { BoundedFifoMap } from "../bounded-cache.js";
+import { getProjectIgnoreMatcher, isExcludedDirName } from "../file-utils.js";
+import { recordLsp } from "../widget-state.js";
+import { applyAuxiliarySuppressions } from "../dispatch/auxiliary-lsp.js";
+import { detectFileRole } from "../file-role.js";
+import { emitBounded } from "../bounded-telemetry.js";
+import { logLatency, phaseFinished, phaseStarted } from "../latency-logger.js";
+import { logSessionStart } from "../sessionstart-logger.js";
+import { incrementDegradationCount, recordDegradation, recordDegradationOnce } from "../degradation-ledger.js";
+import { assertInstallAllowed } from "../project-trust.js";
+import { isLspSpawnAllowedByTrust, projectTrustDenialReason } from "../project-trust.js";
+import { shouldPreferPullOnlyDiagnostics } from "../lsp-budget.js";
+import { sampleProcessTreeCpuPercent } from "../resource-sampler.js";
+import { bounded, withDeadline, withTimeout } from "../deadline-utils.js";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
+import { getAmbientAbortSignal } from "../safe-spawn.js";
+import { abortDeferredLspWork } from "../deferred-lsp-work.js";
+import { acquireWorkspaceSweepHold, clearWorkspaceSweepHoldForSessionStart } from "./workspace-sweep-hold.js";
+import { DocumentDriftTracker, fingerprintDocumentContent } from "./document-drift.js";
+import { captureAuxPublicationBacklog, markPendingAuxiliaryCoverage, napiFallbackCoveredSince } from "./pending-aux-coverage.js";
+import { isAtOrAboveHomeDir, isWindowsPath, normalizeMapKey, uriToPath } from "../path-utils.js";
+import { recordLspMutation } from "../lsp-mutation.js";
+import { createLSPClient } from "./client.js";
+import { auxiliaryCoverageGap, auxiliaryPublicationEvidence, bindingStateLabel, composeBoundToCurrentDisk, createDiskBindingCache, hashDiagnosticContent, resolveTouchVerdict, touchCoverageGap } from "./diagnostic-binding.js";
+import { getServersForFileWithConfig, getServerInitOverride } from "./config.js";
+import { getSessionRootsForTelemetry, isOutsideAllSessionRoots } from "./session-roots.js";
+import { findLocalBinUpwards, isProjectLocalBinPath } from "../package-manager.js";
+import { resolveAnalysisRoot, resolveAnalysisRootPath } from "../analysis-root.js";
+import { configureLspServiceLifecycle, getOwnedLspService, peekOwnedLspService, resetOwnedLspService } from "./service-singleton.js";
+import { groupFilesByPrimaryServer, runPerServerGroups } from "./grouping.js";
+export { groupFilesByPrimaryServer, runPerServerGroups } from "./grouping.js";
+import { isEphemeralCheckoutRoot } from "../ephemeral-root.js";
+import { getLanguageId } from "./language.js";
+import { getReverseDepsFromIndex, loadReverseDependencyIndexFromSnapshot } from "../reverse-deps.js";
+import { isSameOrWithin } from "./server.js";
+import { refuseUntrustedLspExecution, withLspProjectCodePermission } from "./launch.js";
+import { enforceLspRootCeiling, getServerById, hasProjectBoundaryMarker, isDirectLspCommandTemporarilyUnavailable, resetClassicTsRepairGuard, resetLspLaunchAvailabilityGeneration, resolveLspServerCwd } from "./server.js";
+import { isAuxiliary, serverTraits } from "./server-traits.js";
+import { auxWaitBudgetMs, readEnvAuxGraceMs, DEFAULT_AUX_GRACE_CEILING_MS } from "./auxiliary-lifecycle.js";
+import { classifyCascadeWaitTier, classifyServerWaitTier, getStrategy } from "./wait-policy/index.js";
+function textDocumentSaveOf(client) {
+  if (typeof client.getSaveOptions !== "function")
+    return;
+  const save = client.getSaveOptions();
+  if (!save)
+    return "none";
+  return save.includeText ? "save+text" : "save";
+}
+const WORKSPACE_ATTRIBUTION_CLIENT_CAP = 16;
+const AUX_WAIT_DEMOTION_THRESHOLD = 5;
+const AUX_WAIT_DEMOTION_RATIO = 0.9;
+const AUX_WAIT_REPROMOTION_THRESHOLD = 5;
+const AUX_WAIT_REPROMOTION_RATIO = 0.5;
+const ADOPTED_ROOT_CAP = 2;
+const ADOPTED_ROOT_IDLE_EVICT_MS = 60000;
+import { raceToCompletion } from "./aggregation.js";
+import { applyWorkspaceEdit, mergeWorkspaceTextEditsByPriority, summarizeWorkspaceEdit, validateWorkspaceEdit } from "./edits.js";
+import { buildScopeKey, createWorkspaceDiagnosticsCacheContext } from "./workspace-diagnostics-cache.js";
+import { attemptTsserverSyncDiagnostics } from "./tsserver-sync.js";
+import { isWarmAttached, tryWarmAttachedDiagnostics } from "../warm-attach.js";
+import { getSuccessfulLspSpawnDurationMs, recordSuccessfulLspSpawn } from "./spawn-history.js";
+function destinationUriPreservingSpelling(oldUri, oldFilePath, newFilePath) {
+  const canonical = pathToFileURL(newFilePath);
+  try {
+    const original = new URL(oldUri);
+    const authority = /^file:\/\/([^/]*)/i.exec(oldUri)?.[1] ?? "";
+    if (original.protocol !== "file:" || original.host !== "" && original.hostname !== "localhost") {
+      return canonical.href;
+    }
+    const canonicalDestination = () => `${original.protocol}//${authority}${canonical.pathname}`;
+    const oldParent = path.resolve(path.dirname(oldFilePath));
+    const newParent = path.resolve(path.dirname(newFilePath));
+    if (normalizeMapKey(oldParent) !== normalizeMapKey(newParent)) {
+      return canonicalDestination();
+    }
+    const slash = original.pathname.lastIndexOf("/");
+    if (slash < 0)
+      return canonicalDestination();
+    let rawName = canonical.pathname.slice(canonical.pathname.lastIndexOf("/") + 1);
+    const oldRawName = original.pathname.slice(slash + 1);
+    const oldName = decodeURIComponent(oldRawName);
+    const expectedOldName = path.basename(oldFilePath);
+    if (oldName.toLowerCase() !== expectedOldName.toLowerCase()) {
+      return canonicalDestination();
+    }
+    for (const match of oldRawName.matchAll(/%([0-9a-f]{2})/gi)) {
+      const encoded = match[0];
+      const decoded = String.fromCharCode(Number.parseInt(match[1], 16));
+      rawName = rawName.split(decoded).join(encoded);
+    }
+    return `${original.protocol}//${authority}${original.pathname.slice(0, slash + 1)}${rawName}`;
+  } catch {
+    return canonical.href;
+  }
+}
+function deepMergeObjects(base, override) {
+  const result = { ...base };
+  for (const [key, val] of Object.entries(override)) {
+    if (val !== null && typeof val === "object" && !Array.isArray(val) && result[key] !== null && typeof result[key] === "object" && !Array.isArray(result[key])) {
+      result[key] = deepMergeObjects(result[key], val);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+export function mergeInitializationOptions(base, override) {
+  if (!override)
+    return base;
+  if (!base)
+    return override;
+  return deepMergeObjects(base, override);
+}
+const BROKEN_BASE_COOLDOWN_MS = 15000;
+const BROKEN_MAX_COOLDOWN_MS = 5 * 60000;
+const BROKEN_PERMANENT_AFTER = 5;
+const RUNTIME_EXIT_UPTIME_THRESHOLD_MS = 60000;
+const RUNTIME_EXIT_WINDOW_MS = 15 * 60000;
+const RUNTIME_EXIT_WINDOW_TRIP_COUNT = BROKEN_PERMANENT_AFTER;
+const RUNTIME_EXIT_WINDOW_UPTIME_CEILING_MS = 10 * 60000;
+const NOTIFY_BACKPRESSURE_BROKEN_AFTER = 3;
+const OPTIONAL_LSP_RETRY_COOLDOWN_MS = 5 * 60000;
+const OPTIONAL_LSP_SERVER_IDS = new Set;
+const NAV_CLIENT_WAIT_TIMEOUT_MS = Math.max(0, Number.parseInt(process.env.DM_LENS_LSP_NAV_CLIENT_WAIT_MS ?? "1500", 10) || 1500);
+const TOUCH_DEBOUNCE_MS = Math.max(0, Number.parseInt(process.env.DM_LENS_LSP_TOUCH_DEBOUNCE_MS ?? "1500", 10) || 1500);
+const SCOPED_DEPENDENCY_TOUCH_MAX = 32;
+const RENAME_NOTIFY_TIMEOUT_MS = Math.max(50, Number.parseInt(process.env.DM_LENS_LSP_RENAME_NOTIFY_TIMEOUT_MS ?? "1500", 10) || 1500);
+async function runRenameNotify(send, timeoutMs) {
+  try {
+    await withTimeout(send(), timeoutMs);
+    return { ok: true };
+  } catch (err) {
+    const timedOut = err instanceof Error && err.message.startsWith("Timeout after");
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      disposition: timedOut ? "timedOut" : "rejected"
+    };
+  }
+}
+const DEFAULT_LSP_CLIENT_CEILING = 24;
+const DEFAULT_IDLE_EVICT_MS = 20 * 60000;
+const DEFAULT_EPHEMERAL_IDLE_EVICT_MS = 60000;
+export function getLspIdleEvictMs() {
+  for (const name of [
+    "DM_LENS_LSP_IDLE_EVICT_MS",
+    "DM_LENS_TS_IDLE_EVICT_MS"
+  ]) {
+    const parsed = Number.parseInt(process.env[name] ?? "", 10);
+    if (Number.isSafeInteger(parsed) && parsed > 0)
+      return parsed;
+  }
+  return DEFAULT_IDLE_EVICT_MS;
+}
+function getEphemeralLspIdleEvictMs() {
+  const parsed = Number.parseInt(process.env.DM_LENS_EPHEMERAL_LSP_IDLE_EVICT_MS ?? "", 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_EPHEMERAL_IDLE_EVICT_MS;
+}
+export function getLspIdleEvictMsForRoot(root) {
+  return isEphemeralCheckoutRoot(root) ? getEphemeralLspIdleEvictMs() : getLspIdleEvictMs();
+}
+export function getLspClientCeiling() {
+  const parsed = Number.parseInt(process.env.DM_LENS_LSP_CLIENT_CEILING ?? "", 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_LSP_CLIENT_CEILING;
+}
+function documentIsOpenOn(client, filePath) {
+  const probe = client.isDocumentOpen;
+  if (typeof probe !== "function")
+    return false;
+  try {
+    return probe.call(client, filePath) === true;
+  } catch {
+    return false;
+  }
+}
+function tsserverSyncChannel(client) {
+  return {
+    getAdvertisedCommands: async () => client.getAdvertisedCommands(),
+    executeCommand: (_filePath, command, args) => client.executeCommand(command, args)
+  };
+}
+function warmupTimeoutMs() {
+  const raw = Number.parseInt(process.env.DM_LENS_LSP_WARMUP_TIMEOUT_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 20000;
+}
+function warmupRetryBackoffMs() {
+  const raw = Number.parseInt(process.env.DM_LENS_LSP_WARMUP_RETRY_BACKOFF_MS ?? "", 10);
+  return Number.isFinite(raw) && raw >= 0 ? raw : 500;
+}
+function readEnvDiagnosticsWaitMs() {
+  const raw = process.env.DM_LENS_LSP_DIAGNOSTICS_MAX_WAIT_MS;
+  if (raw === undefined)
+    return;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return;
+  return parsed;
+}
+function readTsserverSyncGraceMs() {
+  const raw = process.env.DM_LENS_TSSERVER_SYNC_GRACE_MS;
+  if (raw === undefined)
+    return 300;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return 300;
+  return parsed;
+}
+const MAX_TOUCH_CANDIDATES = 8;
+const DIAGNOSTICS_SEMANTIC_SETTLE_THRESHOLD_MS = Math.max(0, Number.parseInt(process.env.DM_LENS_LSP_DIAGNOSTICS_SEMANTIC_THRESHOLD_MS ?? "250", 10) || 250);
+const DIAGNOSTICS_SEMANTIC_SETTLE_WAIT_MS = Math.max(0, Number.parseInt(process.env.DM_LENS_LSP_DIAGNOSTICS_SEMANTIC_SETTLE_MS ?? "400", 10) || 400);
+const EARLY_UNBLOCK_GRACE_MS = Math.max(0, Number.parseInt(process.env.DM_LENS_LSP_EARLY_UNBLOCK_GRACE_MS ?? "400", 10) || 400);
+function mergeLspDiagnostics(diagnostics) {
+  const merged = [];
+  const seen = new Set;
+  for (const diagnostic of diagnostics) {
+    const key = [
+      diagnostic.range.start.line,
+      diagnostic.range.start.character,
+      diagnostic.message
+    ].join(":");
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    merged.push(diagnostic);
+  }
+  return merged;
+}
+function attributeDiagnostics(serverId, diagnostics) {
+  return diagnostics.map((diagnostic) => ({ ...diagnostic, serverId }));
+}
+export function createSweepIndexGate() {
+  const seen = new Set;
+  return {
+    consumeFirstTouch(serverId) {
+      if (seen.has(serverId))
+        return false;
+      seen.add(serverId);
+      return true;
+    }
+  };
+}
+const WORKSPACE_DIAGNOSTICS_CONCURRENCY = 8;
+const WORKSPACE_SWEEP_PREOPEN_CHUNK_SIZE = (() => {
+  const raw = Number(process.env.DM_LENS_LSP_WORKSPACE_PREOPEN_CHUNK);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 8;
+})();
+const WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS = new Set([
+  "opengrep"
+]);
+function notifyWriteBudgetMs() {
+  const raw = Number(process.env.DM_LENS_LSP_NOTIFY_BUDGET_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 2000;
+}
+function primaryServerWaitFloorMs(filePath, maxWaitMs) {
+  const serverWaitOverrideMs = getServersForFileWithConfig(filePath).filter((s) => !isAuxiliary(s)).reduce((max, server) => Math.max(max, server.clientWaitTimeoutMs ?? 0), 0);
+  return Math.max(maxWaitMs ?? 0, serverWaitOverrideMs);
+}
+const NOTIFY_WEDGED_BUDGET_MULTIPLIER = 5;
+function notifyWedgedMs() {
+  return notifyWriteBudgetMs() * NOTIFY_WEDGED_BUDGET_MULTIPLIER;
+}
+const NOTIFY_WEDGED_EWMA_MULTIPLIER = 2;
+const NOTIFY_WEDGED_CAP_MS = 60000;
+function notifyWedgedCapMs() {
+  const raw = Number(process.env.DM_LENS_LSP_NOTIFY_WEDGED_CAP_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : NOTIFY_WEDGED_CAP_MS;
+}
+function notifyStallCpuSampleMs() {
+  const raw = Number(process.env.DM_LENS_LSP_NOTIFY_STALL_CPU_SAMPLE_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 1200;
+}
+const NOTIFY_STALL_CPU_BUSY_FLOOR_PERCENT = 10;
+function workspacePullBudgetMs() {
+  const raw = Number(process.env.DM_LENS_LSP_WORKSPACE_PULL_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 30000;
+}
+const DEFAULT_MAX_WORKSPACE_DIAGNOSTIC_FILES = 5000;
+function getMaxWorkspaceDiagnosticFiles() {
+  const override = Number.parseInt(process.env.DM_LENS_LSP_WORKSPACE_MAX_FILES ?? "", 10);
+  return Number.isFinite(override) && override > 0 ? override : DEFAULT_MAX_WORKSPACE_DIAGNOSTIC_FILES;
+}
+async function collectWorkspaceDiagnosticFiles(root, maxFiles = getMaxWorkspaceDiagnosticFiles(), signal, homeDir) {
+  const files = [];
+  if (isAtOrAboveHomeDir(root, homeDir))
+    return files;
+  const ignoreMatcher = getProjectIgnoreMatcher(root);
+  await ignoreMatcher.ensureTrackedIndex();
+  async function walk(current) {
+    if (signal?.aborted || files.length >= maxFiles)
+      return;
+    let entries;
+    try {
+      entries = await nodeFs.promises.readdir(current, {
+        withFileTypes: true
+      });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (signal?.aborted || files.length >= maxFiles)
+        return;
+      if (entry.isSymbolicLink())
+        continue;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (isExcludedDirName(entry.name))
+          continue;
+        if (ignoreMatcher.isIgnored(full, true))
+          continue;
+        await walk(full);
+      } else if (entry.isFile() && getServersForFileWithConfig(full).length > 0 && !ignoreMatcher.isIgnored(full, false)) {
+        files.push(full);
+      }
+    }
+  }
+  await walk(root);
+  return files;
+}
+
+export class LSPService {
+  static MAX_SIBLING_ANNOUNCEMENTS = 1024;
+  sessionCwd;
+  state;
+  siblingAnnouncementHashes = new BoundedFifoMap(LSPService.MAX_SIBLING_ANNOUNCEMENTS);
+  workspaceProbeLogged = new Set;
+  projectBoundaryCache = new Map;
+  warmStartLogged = new Set;
+  optionalFailureLogged = new Set;
+  unavailableLogged = new Set;
+  optionalDisabled = new Set;
+  firstContactWaits = new Map;
+  auxWaitPressureStreak = new Map;
+  auxWaitFastAnswerStreak = new Map;
+  demotedAuxiliaryServerIds = new Set;
+  demotedAuxiliaryBudgets = new Map;
+  lastSpawnVerdict = new Map;
+  failureCounts = new Map;
+  runtimeExitCounts = new Map;
+  runtimeExitWindow = new Map;
+  permanentlyBroken = new Set;
+  lastKnownDiagnostics = new Map;
+  lastKnownContentHash = new Map;
+  documentDrift = new DocumentDriftTracker;
+  diskBindingCache = createDiskBindingCache();
+  lastDiagnosticsHealth = new Map;
+  recentTouches = new Map;
+  notifyWriteBackpressureStreak = new Map;
+  auxNotifyDrainLatencyEwma = new Map;
+  auxNotifyInflight = new Map;
+  outstandingAuxNotifyWrites = new Map;
+  static MAX_NOTIFY_STALL_DEMOTIONS = 50;
+  notifyStallDemotions = new BoundedFifoMap(LSPService.MAX_NOTIFY_STALL_DEMOTIONS);
+  clientLastUsedAt = new Map;
+  adoptedRootLastUsedAt = new Map;
+  adoptedClientKeys = new Set;
+  clientLeases = new Map;
+  idleEvictionTimers = new Map;
+  clientSpawnGate = Promise.resolve();
+  isDestroyed = false;
+  shutdownController = new AbortController;
+  generationHandoff;
+  constructor(generationHandoff, sessionCwd) {
+    this.generationHandoff = generationHandoff;
+    this.sessionCwd = sessionCwd;
+    this.state = {
+      clients: new Map,
+      servers: new Map,
+      broken: new Map,
+      inFlight: new Map,
+      clientSpawnedAt: new Map,
+      demonstratedReady: new Set,
+      demonstratedCold: new Set,
+      diagnosticsPublished: new Set,
+      diagnosticsUnsupported: new Set
+    };
+  }
+  isAuxiliaryWaitDemoted(serverId, root) {
+    return this.demotedAuxiliaryServerIds.has(`${serverId}:${normalizeMapKey(root ?? "")}`);
+  }
+  noteAuxiliaryWait(key, budgetMs, elapsedMs) {
+    if (this.demotedAuxiliaryServerIds.has(key))
+      return;
+    if (elapsedMs < AUX_WAIT_DEMOTION_RATIO * budgetMs) {
+      this.auxWaitPressureStreak.delete(key);
+      return;
+    }
+    const streak = (this.auxWaitPressureStreak.get(key) ?? 0) + 1;
+    if (streak >= AUX_WAIT_DEMOTION_THRESHOLD) {
+      this.demotedAuxiliaryServerIds.add(key);
+      this.demotedAuxiliaryBudgets.set(key, budgetMs);
+      this.auxWaitPressureStreak.delete(key);
+      this.auxWaitFastAnswerStreak.delete(key);
+      recordDegradationOnce({
+        kind: "aux_wait_demoted",
+        subject: key,
+        reason: "auxiliary reached at least 90% of its declared wait budget for five consecutive dispatches"
+      });
+      return;
+    }
+    this.auxWaitPressureStreak.set(key, streak);
+  }
+  noteAuxiliaryLateAnswer(key, elapsedMs) {
+    if (!this.demotedAuxiliaryServerIds.has(key))
+      return;
+    const budgetMs = this.demotedAuxiliaryBudgets.get(key);
+    if (budgetMs === undefined || elapsedMs >= AUX_WAIT_REPROMOTION_RATIO * budgetMs) {
+      this.auxWaitFastAnswerStreak.delete(key);
+      return;
+    }
+    const streak = (this.auxWaitFastAnswerStreak.get(key) ?? 0) + 1;
+    if (streak < AUX_WAIT_REPROMOTION_THRESHOLD) {
+      this.auxWaitFastAnswerStreak.set(key, streak);
+      return;
+    }
+    this.demotedAuxiliaryServerIds.delete(key);
+    this.demotedAuxiliaryBudgets.delete(key);
+    this.auxWaitFastAnswerStreak.delete(key);
+    recordDegradationOnce({
+      kind: "aux_wait_repromoted",
+      subject: key,
+      reason: "auxiliary produced five consecutive late answers below half its declared wait budget"
+    });
+  }
+  analysisRootModeForFile(filePath) {
+    const roots = getSessionRootsForTelemetry(128);
+    if (this.sessionCwd)
+      roots.push(this.sessionCwd);
+    let adopted = false;
+    for (const root of new Set(roots)) {
+      const mode = resolveAnalysisRoot(filePath, root);
+      if (mode === "session" || mode === "linked-worktree")
+        return mode;
+      adopted ||= mode === "adopted";
+    }
+    return adopted ? "adopted" : "none";
+  }
+  fileIsOutsideRegisteredRoots(filePath) {
+    const roots = getSessionRootsForTelemetry(128);
+    if (roots.length === 0)
+      return isOutsideAllSessionRoots(filePath);
+    return !roots.some((root) => isSameOrWithin(root, filePath));
+  }
+  admitAdoptedRoot(root, filePath) {
+    if (this.analysisRootModeForFile(filePath) !== "adopted")
+      return false;
+    const normalized = normalizeMapKey(root);
+    const liveRoots = new Set;
+    for (const key of this.state.clients.keys()) {
+      if (this.adoptedClientKeys.has(key))
+        liveRoots.add(key.slice(key.indexOf(":") + 1));
+    }
+    for (const root of this.adoptedRootLastUsedAt.keys()) {
+      if (!liveRoots.has(root))
+        this.adoptedRootLastUsedAt.delete(root);
+    }
+    if (liveRoots.has(normalized)) {
+      this.adoptedRootLastUsedAt.set(normalized, Date.now());
+      return true;
+    }
+    if (this.adoptedRootLastUsedAt.size < ADOPTED_ROOT_CAP) {
+      this.adoptedRootLastUsedAt.set(normalized, Date.now());
+      return true;
+    }
+    this.adoptedRootLastUsedAt.set(normalized, Date.now());
+    const victim = [...this.adoptedRootLastUsedAt.keys()].sort((a, b) => (this.adoptedRootLastUsedAt.get(a) ?? 0) - (this.adoptedRootLastUsedAt.get(b) ?? 0)).find((candidate) => candidate !== normalized);
+    if (!victim)
+      return true;
+    this.adoptedRootLastUsedAt.delete(victim);
+    for (const [key, client] of this.state.clients) {
+      if (!this.adoptedClientKeys.has(key) || !key.endsWith(`:${victim}`))
+        continue;
+      if ((this.clientLeases.get(key) ?? 0) > 0)
+        continue;
+      this.retireClient(key);
+      client.shutdown({ reason: "adopted-root-lru" }).catch(() => {});
+    }
+    incrementDegradationCount({
+      kind: "lsp-adopted-root-evicted",
+      subject: victim,
+      reason: `adopted root cap ${ADOPTED_ROOT_CAP} evicted ${victim}`
+    });
+    return true;
+  }
+  async resolveServerRoot(server, filePath, onRootFailure) {
+    const candidate = await resolveLspServerCwd(server, filePath, this.sessionCwd ?? process.cwd(), onRootFailure);
+    if (!candidate)
+      return;
+    const mode = this.analysisRootModeForFile(filePath);
+    if (mode === "adopted") {
+      const classifierRoot = resolveAnalysisRootPath(filePath, this.sessionCwd ?? process.cwd());
+      if (!classifierRoot || normalizeMapKey(classifierRoot) !== normalizeMapKey(candidate))
+        return;
+    }
+    if (this.fileIsOutsideRegisteredRoots(filePath) && this.analysisRootModeForFile(filePath) !== "adopted")
+      return;
+    const root = enforceLspRootCeiling(candidate, process.cwd(), filePath);
+    if (normalizeMapKey(root) === normalizeMapKey(process.cwd()))
+      return root;
+    const rootKey = normalizeMapKey(root);
+    const prefix = `${server.id}:`;
+    let nearestAncestor;
+    for (const key of new Set([
+      ...this.state.clients.keys(),
+      ...this.state.inFlight.keys()
+    ])) {
+      if (!key.startsWith(prefix))
+        continue;
+      const ancestorKey = key.slice(prefix.length);
+      const pathApi = isWindowsPath(ancestorKey) || isWindowsPath(rootKey) ? path.win32 : path;
+      const relative = pathApi.relative(ancestorKey, rootKey);
+      if (relative === "" || relative.startsWith("..") || pathApi.isAbsolute(relative)) {
+        continue;
+      }
+      if (!nearestAncestor || ancestorKey.length > nearestAncestor.length) {
+        nearestAncestor = ancestorKey;
+      }
+    }
+    if (!nearestAncestor)
+      return root;
+    let boundary = this.projectBoundaryCache.get(rootKey);
+    if (!boundary) {
+      boundary = hasProjectBoundaryMarker(root);
+      this.projectBoundaryCache.set(rootKey, boundary);
+    }
+    if (await boundary)
+      return root;
+    return this.state.clients.get(`${server.id}:${nearestAncestor}`)?.root ?? nearestAncestor;
+  }
+  checkDestroyed() {
+    return this.isDestroyed;
+  }
+  announceToSiblings(filePath, content, contentHash = this.hashContent(content)) {
+    const normalizedPath = normalizeMapKey(filePath);
+    if (this.siblingAnnouncementHashes.get(normalizedPath) === contentHash) {
+      return Promise.resolve();
+    }
+    return Promise.all(getServersForFileWithConfig(filePath).map((server) => this.resolveServerRoot(server, filePath).then((root) => {
+      if (!root)
+        return false;
+      const ownKey = `${server.id}:${normalizeMapKey(root)}`;
+      return this.notifyLiveClientsForServer(server.id, filePath, 2, ownKey, false);
+    }))).then(() => {
+      this.siblingAnnouncementHashes.set(normalizedPath, contentHash);
+    });
+  }
+  notifyLiveClientsForServer(serverId, filePath, type, ownKey, includeOwn) {
+    let notified = false;
+    const prefix = `${serverId}:`;
+    for (const [key, client] of this.state.clients) {
+      if (!key.startsWith(prefix) || !includeOwn && key === ownKey || !client.isAlive()) {
+        continue;
+      }
+      client.notify.watchedFileChange(filePath, type);
+      notified = true;
+    }
+    return notified;
+  }
+  async withClientSpawnGate(operation) {
+    const previous = this.clientSpawnGate;
+    let release;
+    this.clientSpawnGate = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  async clientKeyFor(entry, filePath) {
+    const root = await this.resolveServerRoot(entry.info, filePath);
+    return root ? `${entry.info.id}:${normalizeMapKey(root)}` : undefined;
+  }
+  async acquireClientLease(entry, filePath) {
+    const key = await this.clientKeyFor(entry, filePath);
+    if (!key)
+      return;
+    return this.withClientSpawnGate(async () => {
+      if (this.isDestroyed || this.state.clients.get(key) !== entry.client) {
+        return;
+      }
+      this.clientLeases.set(key, (this.clientLeases.get(key) ?? 0) + 1);
+      return key;
+    });
+  }
+  async acquireClientLeases(entries, filePath) {
+    const keys = await Promise.all(entries.map((entry) => this.clientKeyFor(entry, filePath)));
+    if (keys.some((key) => key === undefined))
+      return;
+    const keyed = entries.map((entry, index) => [keys[index], entry]);
+    return this.withClientSpawnGate(async () => {
+      if (this.isDestroyed || keyed.some(([key, entry]) => this.state.clients.get(key) !== entry.client)) {
+        return;
+      }
+      for (const [key] of keyed) {
+        this.clientLeases.set(key, (this.clientLeases.get(key) ?? 0) + 1);
+      }
+      return keyed.map(([key, entry]) => ({ key, server: entry.info }));
+    });
+  }
+  releaseClientLease(key, server) {
+    const remaining = (this.clientLeases.get(key) ?? 1) - 1;
+    if (remaining > 0) {
+      this.clientLeases.set(key, remaining);
+      return;
+    }
+    this.clientLeases.delete(key);
+    if (this.state.clients.has(key)) {
+      this.clientLastUsedAt.set(key, Date.now());
+      this.scheduleIdleEviction(key, server);
+    }
+  }
+  async withClientForFileUse(filePath, maxWaitMs, hardCapMs, use) {
+    while (!this.isDestroyed) {
+      const entry = await this.getClientForFile(filePath, maxWaitMs, hardCapMs);
+      if (!entry)
+        return;
+      const leaseKey = await this.acquireClientLease(entry, filePath);
+      if (!leaseKey)
+        continue;
+      try {
+        return await use(entry);
+      } finally {
+        this.releaseClientLease(leaseKey, entry.info);
+      }
+    }
+    return;
+  }
+  async makeCapacityForClient(key) {
+    const occupiedKeys = new Set(this.state.inFlight.keys());
+    for (const [clientKey, client] of this.state.clients) {
+      if (client.isAlive())
+        occupiedKeys.add(clientKey);
+    }
+    const occupied = occupiedKeys.size;
+    if (occupied < getLspClientCeiling())
+      return true;
+    const idle = [...this.state.clients.entries()].filter(([candidateKey, client]) => candidateKey !== key && client.isAlive() && client.isBusy?.() !== true && (this.clientLeases.get(candidateKey) ?? 0) === 0).sort(([a], [b]) => (this.clientLastUsedAt.get(a) ?? this.state.clientSpawnedAt.get(a) ?? 0) - (this.clientLastUsedAt.get(b) ?? this.state.clientSpawnedAt.get(b) ?? 0));
+    const victim = idle[0];
+    if (!victim) {
+      logSessionStart(`lsp client ceiling ${getLspClientCeiling()}: spawn declined; all clients are in use`);
+      return false;
+    }
+    const [victimKey, victimClient] = victim;
+    this.releaseOutstandingAuxNotifyWrite(victimKey);
+    await victimClient.shutdown({ reason: "client_ceiling_lru" });
+    this.retireClient(victimKey);
+    logSessionStart(`lsp client ceiling ${getLspClientCeiling()}: evicted idle LRU ${victimKey}`);
+    return true;
+  }
+  clearIdleEvictionTimer(key) {
+    const timer = this.idleEvictionTimers.get(key);
+    if (timer)
+      clearTimeout(timer);
+    this.idleEvictionTimers.delete(key);
+  }
+  retireClient(key) {
+    this.releaseOutstandingAuxNotifyWrite(key);
+    this.state.clients.delete(key);
+    this.state.clientSpawnedAt.delete(key);
+    this.forgetReadiness(key);
+    this.clientLastUsedAt.delete(key);
+    if (this.adoptedClientKeys.delete(key)) {
+      const root = key.slice(key.indexOf(":") + 1);
+      if (![...this.adoptedClientKeys].some((candidate) => candidate.endsWith(`:${root}`)))
+        this.adoptedRootLastUsedAt.delete(root);
+    }
+    this.clearIdleEvictionTimer(key);
+    this.auxNotifyInflight.delete(key);
+    this.auxNotifyDrainLatencyEwma.delete(key);
+  }
+  releaseOutstandingAuxNotifyWrite(key, token) {
+    const current = this.outstandingAuxNotifyWrites.get(key);
+    if (!current || token !== undefined && current !== token)
+      return;
+    clearTimeout(current.wedgeTimer);
+    this.outstandingAuxNotifyWrites.delete(key);
+    current.resolveSettled();
+  }
+  scheduleIdleEviction(key, server) {
+    if (server.idleEviction !== "transparent" && !this.adoptedClientKeys.has(key))
+      return;
+    this.clearIdleEvictionTimer(key);
+    const lastUsedAt = this.clientLastUsedAt.get(key) ?? Date.now();
+    const root = key.slice(key.indexOf(":") + 1);
+    const idleMs = this.adoptedClientKeys.has(key) ? ADOPTED_ROOT_IDLE_EVICT_MS : getLspIdleEvictMsForRoot(root);
+    const timer = setTimeout(() => {
+      this.idleEvictionTimers.delete(key);
+      this.withClientSpawnGate(async () => {
+        if (this.isDestroyed)
+          return;
+        const client = this.state.clients.get(key);
+        if (!client?.isAlive())
+          return;
+        if (client.isBusy?.() === true || (this.clientLeases.get(key) ?? 0) > 0 || (this.clientLastUsedAt.get(key) ?? 0) !== lastUsedAt) {
+          this.scheduleIdleEviction(key, server);
+          return;
+        }
+        this.retireClient(key);
+        try {
+          await client.shutdown({ reason: "idle_eviction" });
+        } catch {}
+        logSessionStart(`lsp idle eviction: released ${key}`);
+        recordDegradation({
+          kind: "lsp-idle-eviction",
+          subject: key,
+          reason: "idle LSP client released to bound memory"
+        });
+      }).catch(() => {});
+    }, idleMs);
+    timer.unref?.();
+    this.idleEvictionTimers.set(key, timer);
+  }
+  shouldSkipTouch(filePath, contentFingerprint, clientScope, waitForDiagnostics, spawned) {
+    if (waitForDiagnostics)
+      return false;
+    if (spawned.length === 0)
+      return false;
+    return spawned.every((entry) => this.shouldSkipNotify(filePath, contentFingerprint, clientScope, entry.info.id, entry.client));
+  }
+  shouldSkipNotify(filePath, contentFingerprint, clientScope, serverId, client) {
+    if (TOUCH_DEBOUNCE_MS <= 0)
+      return false;
+    const previous = this.recentTouches.get(this.recentTouchKey(filePath, clientScope, serverId));
+    if (!previous)
+      return false;
+    const now = Date.now();
+    if (now - previous.touchedAt > TOUCH_DEBOUNCE_MS)
+      return false;
+    if (previous.client.deref() !== client)
+      return false;
+    return previous.fingerprint === contentFingerprint();
+  }
+  recentTouchKey(filePath, clientScope, serverId) {
+    return `${normalizeMapKey(filePath)}:${clientScope}:${serverId}`;
+  }
+  markTouched(filePath, contentFingerprint, clientScope, serverId, client) {
+    const key = this.recentTouchKey(filePath, clientScope, serverId);
+    const now = Date.now();
+    this.recentTouches.set(key, {
+      fingerprint: contentFingerprint,
+      touchedAt: now,
+      clientScope,
+      client: new WeakRef(client)
+    });
+    if (this.recentTouches.size > 800) {
+      for (const [k, v] of this.recentTouches) {
+        if (now - v.touchedAt > TOUCH_DEBOUNCE_MS) {
+          this.recentTouches.delete(k);
+        }
+      }
+    }
+  }
+  async demonstratedReadyKeyFor(server, filePath) {
+    const root = await this.resolveServerRoot(server, filePath);
+    if (!root)
+      return;
+    return `${server.id}:${normalizeMapKey(root)}`;
+  }
+  forgetReadiness(key) {
+    this.state.demonstratedReady.delete(key);
+    this.state.demonstratedCold.delete(key);
+    this.notifyWriteBackpressureStreak.delete(key);
+  }
+  markDemonstratedReadyKey(key) {
+    this.state.demonstratedReady.add(key);
+    this.state.demonstratedCold.delete(key);
+  }
+  recordBreaker(key, reason) {
+    recordDegradationOnce({ kind: "lsp-breaker", subject: key, reason });
+  }
+  recordNotifyWriteBackpressure(key, entry, filePath) {
+    if (!key)
+      return;
+    if (this.state.clients.get(key) !== entry.client)
+      return;
+    const streak = (this.notifyWriteBackpressureStreak.get(key) ?? 0) + 1;
+    if (streak < NOTIFY_BACKPRESSURE_BROKEN_AFTER) {
+      this.notifyWriteBackpressureStreak.set(key, streak);
+      return;
+    }
+    this.notifyWriteBackpressureStreak.delete(key);
+    this.demoteNotifyStallCpuGuarded(key, entry, filePath, {
+      consecutiveTimeouts: NOTIFY_BACKPRESSURE_BROKEN_AFTER
+    });
+  }
+  async demoteNotifyStallCpuGuarded(key, entry, filePath, reason) {
+    if (this.state.clients.get(key) !== entry.client)
+      return;
+    this.clearIdleEvictionTimer(key);
+    const verdict = await this.notifyStallCpuVerdict(entry);
+    if (verdict.cpuVerdict === "busy") {
+      if (this.state.clients.get(key) === entry.client) {
+        this.scheduleIdleEviction(key, entry.info);
+      }
+      this.logNotifyStallCpuBusy(key, entry, filePath, 0, verdict);
+      return;
+    }
+    if (this.state.clients.get(key) !== entry.client)
+      return;
+    this.demoteForNotifyStall(key, entry, filePath, {
+      ...reason,
+      discriminator: "consecutive-timeouts",
+      cpuVerdict: verdict.cpuVerdict
+    });
+  }
+  async notifyStallCpuVerdict(entry) {
+    const pid = entry.client.getProcessPid?.();
+    if (pid === undefined || !(Number.isFinite(pid) && pid > 0)) {
+      return { cpuVerdict: "unmeasured", cpuPercent: null };
+    }
+    const sample = await sampleProcessTreeCpuPercent(pid, notifyStallCpuSampleMs(), NOTIFY_STALL_CPU_BUSY_FLOOR_PERCENT);
+    if (!sample.measured) {
+      return { cpuVerdict: "unmeasured", cpuPercent: null };
+    }
+    if (sample.busy) {
+      return { cpuVerdict: "busy", cpuPercent: sample.cpuPercent };
+    }
+    return { cpuVerdict: "flat", cpuPercent: sample.cpuPercent };
+  }
+  logNotifyStallCpuBusy(key, entry, filePath, outstandingMs, verdict, extra = {}) {
+    emitBounded("lsp_notify_stall_cpu_busy", `${key}:${normalizeMapKey(filePath)}`, {
+      type: "phase",
+      durationMs: outstandingMs,
+      metadata: {
+        serverId: entry.info.id,
+        clientKey: key,
+        outstandingMs,
+        cpuPercent: verdict.cpuPercent ?? null,
+        ...extra
+      }
+    }, {
+      ledgerKind: "lsp-notify-stall-cpu-busy",
+      risingEdgePer: "identity"
+    });
+  }
+  auxNotifyWedgeBudgetMs(key) {
+    let budgetMs = notifyWedgedMs();
+    const ewma = this.auxNotifyDrainLatencyEwma.get(key);
+    if (ewma !== undefined && ewma > 0) {
+      const unacked = this.auxNotifyInflight.get(key)?.unacked ?? 0;
+      budgetMs = Math.max(budgetMs, NOTIFY_WEDGED_EWMA_MULTIPLIER * ewma * unacked);
+    }
+    return Math.min(budgetMs, notifyWedgedCapMs());
+  }
+  demoteForNotifyStall(key, entry, filePath, reason) {
+    if (this.state.clients.get(key) !== entry.client)
+      return;
+    this.state.broken.set(key, Date.now() + BROKEN_BASE_COOLDOWN_MS);
+    this.notifyStallDemotions.set(key, Date.now());
+    entry.client.shutdown().catch(() => {});
+    this.retireClient(key);
+    logLatency({
+      type: "phase",
+      phase: "lsp_notify_backpressure_broken",
+      filePath: normalizeMapKey(filePath),
+      durationMs: 0,
+      metadata: {
+        serverId: entry.info.id,
+        cooldownMs: BROKEN_BASE_COOLDOWN_MS,
+        ...reason
+      }
+    });
+  }
+  retractNotifyWriteBackpressure(key, serverId, filePath, outstandingMs, client) {
+    if (this.state.clients.get(key) !== client)
+      return;
+    const streak = this.notifyWriteBackpressureStreak.get(key);
+    if (!streak)
+      return;
+    const streakAfter = streak - 1;
+    if (streakAfter <= 0)
+      this.notifyWriteBackpressureStreak.delete(key);
+    else
+      this.notifyWriteBackpressureStreak.set(key, streakAfter);
+    logLatency({
+      type: "phase",
+      phase: "lsp_notify_write_late_landed",
+      filePath: normalizeMapKey(filePath),
+      durationMs: outstandingMs,
+      metadata: { serverId, outstandingMs, streakAfter }
+    });
+  }
+  noteAuxNotifyIssued(key, client) {
+    const record = this.auxNotifyInflight.get(key);
+    if (record && record.client === client) {
+      record.unacked += 1;
+      return;
+    }
+    this.auxNotifyInflight.set(key, { client, unacked: 1 });
+  }
+  noteAuxNotifyDrainLatency(key, durationMs, outstanding, record) {
+    if (!(outstanding > 0 && durationMs > 0))
+      return;
+    if (record && this.auxNotifyInflight.get(key) !== record)
+      return;
+    const perWriteMs = durationMs / outstanding;
+    const prev = this.auxNotifyDrainLatencyEwma.get(key);
+    this.auxNotifyDrainLatencyEwma.set(key, prev === undefined ? perWriteMs : 0.5 * perWriteMs + 0.5 * prev);
+  }
+  async decideNotifyStallTeardown(key, entry, filePath, token) {
+    if (this.state.clients.get(key) !== entry.client || this.outstandingAuxNotifyWrites.get(key) !== token) {
+      throw new Error("stale notify generation");
+    }
+    const outstandingMs = Date.now() - token.startedAt;
+    const armedBudgetMs = token.armedBudgetMs;
+    if (outstandingMs >= notifyWedgedCapMs()) {
+      return {
+        action: "demote",
+        reason: {
+          outstandingMs,
+          discriminator: "cap-exceeded",
+          budgetMs: armedBudgetMs
+        }
+      };
+    }
+    const verdict = await this.notifyStallCpuVerdict(entry);
+    if (this.state.clients.get(key) !== entry.client || this.outstandingAuxNotifyWrites.get(key) !== token) {
+      throw new Error("stale notify generation");
+    }
+    if (verdict.cpuVerdict === "busy") {
+      this.logNotifyStallCpuBusy(key, entry, filePath, outstandingMs, verdict, {
+        budgetMs: armedBudgetMs
+      });
+      return { action: "rearm", budgetMs: this.auxNotifyWedgeBudgetMs(key) };
+    }
+    return {
+      action: "demote",
+      reason: {
+        outstandingMs,
+        discriminator: verdict.cpuVerdict === "unmeasured" ? "budget-exceeded" : "budget-exceeded-cpu-flat",
+        budgetMs: armedBudgetMs,
+        ewmaInputMs: this.auxNotifyDrainLatencyEwma.get(key),
+        unackedDepth: this.auxNotifyInflight.get(key)?.unacked ?? 0,
+        cpuVerdict: verdict.cpuVerdict,
+        cpuPercent: verdict.cpuPercent ?? null
+      }
+    };
+  }
+  auxNotifyBacklogAtCeiling(key, entry) {
+    const record = this.auxNotifyInflight.get(key);
+    if (!record || record.client !== entry.client)
+      return false;
+    if (record.gateOpen)
+      return false;
+    return record.unacked >= serverTraits(entry.info).notifyInflightLimit;
+  }
+  async paceAuxNotify(key, entry, filePath, waitMs, context) {
+    const record = this.auxNotifyInflight.get(key);
+    if (!record)
+      return;
+    if (record.client !== entry.client) {
+      this.auxNotifyInflight.delete(key);
+      return;
+    }
+    if (record.gateOpen)
+      return;
+    const traits = serverTraits(entry.info);
+    const limit = traits.notifyInflightLimit;
+    if (record.unacked < limit)
+      return;
+    const ping = traits.replyOrdering === "threaded" ? undefined : entry.client.pingLiveness;
+    if (!ping) {
+      record.unacked = 0;
+      return;
+    }
+    if (waitMs <= 0) {
+      this.openAuxNotifyGate(key, entry, filePath, context, {
+        unacked: record.unacked,
+        limit,
+        waitMs,
+        durationMs: 0
+      });
+      return;
+    }
+    if (!record.drain) {
+      const startedAt = Date.now();
+      const outstanding = record.unacked;
+      const client = entry.client;
+      const barrier = (async () => {
+        let drained = false;
+        try {
+          drained = await ping.call(client, waitMs);
+        } catch {
+          drained = false;
+        }
+        const current = this.auxNotifyInflight.get(key);
+        if (current === record && current.client === client) {
+          current.drain = undefined;
+          if (drained)
+            current.unacked = Math.max(0, current.unacked - outstanding);
+        }
+        const durationMs = Date.now() - startedAt;
+        if (drained)
+          this.noteAuxNotifyDrainLatency(key, durationMs, outstanding, record);
+        this.noteDrainBarrierOutcome(key, entry, filePath, context, {
+          unacked: outstanding,
+          limit,
+          waitMs,
+          durationMs,
+          outcome: drained ? "drained" : "stalled"
+        });
+        return drained;
+      })();
+      barrier.catch(() => {});
+      record.drain = barrier;
+      record.stallLogged = false;
+    }
+    const waitStartedAt = Date.now();
+    const drained = await withDeadline(record.drain, {
+      ms: waitMs,
+      onTimeout: "undefined",
+      onReject: "undefined"
+    });
+    if (drained !== true) {
+      this.openAuxNotifyGate(key, entry, filePath, context, {
+        unacked: record.unacked,
+        limit,
+        waitMs,
+        durationMs: Date.now() - waitStartedAt
+      });
+    }
+  }
+  openAuxNotifyGate(key, entry, filePath, context, detail) {
+    const record = this.auxNotifyInflight.get(key);
+    if (record && record.client === entry.client) {
+      record.gateOpen = true;
+    }
+    this.noteDrainBarrierOutcome(key, entry, filePath, context, {
+      ...detail,
+      outcome: "stalled"
+    });
+  }
+  noteDrainBarrierOutcome(key, entry, filePath, context, detail) {
+    const record = this.auxNotifyInflight.get(key);
+    if (detail.outcome === "stalled" && record) {
+      if (record.stallLogged)
+        return;
+      record.stallLogged = true;
+    }
+    this.logDrainBarrier(key, entry, filePath, context, detail);
+  }
+  logDrainBarrier(key, entry, filePath, context, detail) {
+    if (detail.outcome === "stalled") {
+      incrementDegradationCount({
+        kind: "lsp-notify-inflight-stall",
+        subject: `${entry.info.id}:${normalizeMapKey(filePath)}`,
+        reason: `notify barrier stalled with ${detail.unacked} unacknowledged writes`
+      });
+    }
+    logLatency({
+      type: "phase",
+      phase: "lsp_notify_inflight_barrier",
+      filePath: normalizeMapKey(filePath),
+      durationMs: detail.durationMs,
+      metadata: {
+        serverId: entry.info.id,
+        clientKey: key,
+        source: context.source,
+        clientScope: context.clientScope,
+        ...detail
+      }
+    });
+  }
+  async claimAuxNotifySlot(clientKey, entry, filePath, budgetMs) {
+    const deadline = Date.now() + budgetMs;
+    for (;; ) {
+      const outstanding = this.outstandingAuxNotifyWrites.get(clientKey);
+      if (outstanding && outstanding.client !== entry.client) {
+        this.releaseOutstandingAuxNotifyWrite(clientKey, outstanding);
+      } else if (outstanding) {
+        const outstandingMs = Date.now() - outstanding.startedAt;
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+          return { outstandingMs };
+        await withDeadline(outstanding.settled, {
+          ms: remainingMs,
+          onTimeout: "undefined",
+          onReject: "undefined"
+        });
+        continue;
+      }
+      const current = this.state.clients.get(clientKey);
+      if (current !== entry.client) {
+        return { outstandingMs: 0 };
+      }
+      let resolveSettled;
+      const settled = new Promise((resolve) => {
+        resolveSettled = resolve;
+      });
+      const token = {
+        startedAt: Date.now(),
+        client: entry.client,
+        settled,
+        armedBudgetMs: 0,
+        wedgeTimer: undefined,
+        resolveSettled: () => resolveSettled?.()
+      };
+      const fireWedge = async () => {
+        if (this.outstandingAuxNotifyWrites.get(clientKey) !== token || this.state.clients.get(clientKey) !== entry.client) {
+          this.releaseOutstandingAuxNotifyWrite(clientKey, token);
+          return;
+        }
+        let decision;
+        try {
+          decision = await this.decideNotifyStallTeardown(clientKey, entry, filePath, token);
+        } catch {
+          decision = {
+            action: "demote",
+            reason: {
+              outstandingMs: Date.now() - token.startedAt,
+              discriminator: "budget-exceeded",
+              budgetMs: token.armedBudgetMs
+            }
+          };
+        }
+        if (this.outstandingAuxNotifyWrites.get(clientKey) !== token || this.state.clients.get(clientKey) !== entry.client) {
+          this.releaseOutstandingAuxNotifyWrite(clientKey, token);
+          return;
+        }
+        if (decision.action === "demote") {
+          this.demoteForNotifyStall(clientKey, entry, filePath, decision.reason);
+          resolveSettled?.();
+          return;
+        }
+        token.wedgeTimer = setTimeout(() => void fireWedge(), decision.budgetMs);
+        token.wedgeTimer.unref?.();
+      };
+      token.armedBudgetMs = this.auxNotifyWedgeBudgetMs(clientKey);
+      token.wedgeTimer = setTimeout(() => void fireWedge(), token.armedBudgetMs);
+      token.wedgeTimer.unref?.();
+      this.outstandingAuxNotifyWrites.set(clientKey, token);
+      return {
+        release: () => {
+          this.releaseOutstandingAuxNotifyWrite(clientKey, token);
+        }
+      };
+    }
+  }
+  async brokenSkippedAuxiliaryServerIds(filePath, clientScope, options, spawned) {
+    if (clientScope === "primary")
+      return [];
+    const enabledAuxiliaries = clientScope === "with-auxiliary" ? new Set(options.auxiliaryServerIds ?? []) : undefined;
+    const attached = new Set(spawned.map((entry) => entry.info.id));
+    const skipped = [];
+    for (const server of getServersForFileWithConfig(filePath)) {
+      if (!isAuxiliary(server))
+        continue;
+      if (attached.has(server.id))
+        continue;
+      if (options.excludeServerIds?.has(server.id))
+        continue;
+      if (enabledAuxiliaries && !enabledAuxiliaries.has(server.id))
+        continue;
+      const key = await this.demonstratedReadyKeyFor(server, filePath);
+      if (!key)
+        continue;
+      const brokenUntil = this.state.broken.get(key);
+      if (this.permanentlyBroken.has(key) || typeof brokenUntil === "number" && brokenUntil > Date.now()) {
+        skipped.push(server.id);
+      }
+    }
+    return skipped;
+  }
+  activeClientsForCwd(cwd, priorityServerIds = []) {
+    const normalizedCwd = normalizeMapKey(cwd);
+    const priority = new Map(priorityServerIds.map((serverId, index) => [serverId, index]));
+    const entries = [];
+    for (const [key, client] of this.state.clients) {
+      if (!client.isAlive())
+        continue;
+      const separator = key.indexOf(":");
+      const serverId = separator >= 0 ? key.slice(0, separator) : key;
+      const root = normalizeMapKey(client.root);
+      const sameOrNested = root === normalizedCwd || root.startsWith(`${normalizedCwd}/`) || normalizedCwd.startsWith(`${root}/`);
+      if (!sameOrNested)
+        continue;
+      entries.push({ serverId, client });
+    }
+    return entries.sort((a, b) => (priority.get(a.serverId) ?? Number.MAX_SAFE_INTEGER) - (priority.get(b.serverId) ?? Number.MAX_SAFE_INTEGER));
+  }
+  getOpenDocumentPaths(cwd) {
+    const paths = new Set;
+    for (const { client } of this.activeClientsForCwd(cwd)) {
+      try {
+        for (const filePath of client.openDocumentPaths?.() ?? [])
+          paths.add(filePath);
+      } catch {}
+    }
+    return [...paths];
+  }
+  getTrackedContent(filePath, cwd) {
+    const priorityServerIds = getServersForFileWithConfig(filePath).map((server) => server.id);
+    for (const { client } of this.activeClientsForCwd(cwd, priorityServerIds)) {
+      const sent = client.getSentContent?.(filePath);
+      if (sent !== undefined)
+        return sent;
+    }
+    return;
+  }
+  async getClientForFile(filePath, maxWaitMs, hardCapMs, resolvedRoots, waitSkipReasons) {
+    if (this.checkDestroyed())
+      return;
+    const servers = getServersForFileWithConfig(filePath).filter((s) => !isAuxiliary(s));
+    const rootMemo = new Map;
+    const partitionCandidates = async () => {
+      const resolved = await Promise.all(servers.map(async (server) => {
+        let rootFailureReason;
+        try {
+          return {
+            server,
+            root: await this.resolveServerRootOnce(server, filePath, rootMemo, (reason) => {
+              rootFailureReason = reason;
+            }),
+            reason: rootFailureReason
+          };
+        } catch (error) {
+          return {
+            server,
+            root: undefined,
+            reason: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }));
+      const unrootedReasons = {};
+      for (const entry of resolved) {
+        if (entry.root === undefined && entry.reason !== undefined) {
+          unrootedReasons[entry.server.id] = entry.reason;
+        }
+      }
+      return {
+        rooted: resolved.filter((entry) => entry.root !== undefined).map(({ server, root }) => ({ server, root })),
+        unrootedIds: resolved.filter((entry) => entry.root === undefined).map((entry) => entry.server.id),
+        unrootedReasons
+      };
+    };
+    const serverBaseMs = primaryServerWaitFloorMs(filePath, maxWaitMs);
+    const effectiveMaxWaitMs = hardCapMs !== undefined ? serverBaseMs > 0 ? Math.min(serverBaseMs, hardCapMs) : hardCapMs : serverBaseMs;
+    let knownSlowResolve;
+    const knownSlowSentinel = Symbol("lsp-client-wait-known-slow");
+    const knownSlow = new Promise((resolve) => {
+      knownSlowResolve = () => resolve(knownSlowSentinel);
+    });
+    const noteSpawnInFlight = (serverId) => {
+      const knownDurationMs = getSuccessfulLspSpawnDurationMs(serverId);
+      if (knownDurationMs !== undefined && knownDurationMs > effectiveMaxWaitMs * 2) {
+        queueMicrotask(() => knownSlowResolve?.());
+      }
+    };
+    const withBudget = async () => {
+      if (servers.length === 0)
+        return;
+      let erroredServerId;
+      let erroredOutcome;
+      for (const server of servers) {
+        const acquisition = {
+          outcome: "declined"
+        };
+        const spawned = await this.ensureClientForServer(filePath, server, resolvedRoots, noteSpawnInFlight, (reported) => {
+          acquisition.outcome = reported;
+        }, rootMemo);
+        if (spawned) {
+          logLatency({
+            type: "phase",
+            phase: "lsp_client_selected",
+            filePath,
+            durationMs: 0,
+            metadata: {
+              serverId: server.id,
+              candidateCount: servers.length,
+              outcome: acquisition.outcome
+            }
+          });
+          return spawned;
+        }
+        if (acquisition.outcome === "spawn-failure" || acquisition.outcome === "spawn-failure-joined") {
+          if (erroredServerId === undefined) {
+            erroredServerId = server.id;
+            erroredOutcome = acquisition.outcome;
+          }
+        }
+      }
+      if (erroredServerId !== undefined) {
+        logLatency({
+          type: "phase",
+          phase: "lsp_client_selected",
+          filePath,
+          durationMs: 0,
+          metadata: {
+            serverId: erroredServerId,
+            candidateCount: servers.length,
+            outcome: erroredOutcome ?? "spawn-failure"
+          }
+        });
+      }
+      const unavailable = (await Promise.all(servers.map(async (server) => {
+        const root = await this.resolveServerRootOnce(server, filePath, rootMemo);
+        return {
+          server,
+          key: `${server.id}:${root ? normalizeMapKey(root) : "<unresolved>"}`
+        };
+      }))).filter(({ key }) => !this.unavailableLogged.has(key));
+      for (const { key } of unavailable)
+        this.unavailableLogged.add(key);
+      if (unavailable.length === 0)
+        return;
+      logLatency({
+        type: "phase",
+        phase: "lsp_client_unavailable",
+        filePath,
+        durationMs: 0,
+        metadata: {
+          candidateCount: unavailable.length,
+          servers: unavailable.map(({ server }) => server.id)
+        }
+      });
+      return;
+    };
+    if (!effectiveMaxWaitMs || effectiveMaxWaitMs <= 0) {
+      return withBudget();
+    }
+    const timeoutSentinel = Symbol("lsp-client-wait-timeout");
+    let waitTimer;
+    let waitResult;
+    try {
+      waitResult = await Promise.race([
+        withBudget(),
+        knownSlow,
+        new Promise((resolve) => {
+          waitTimer = setTimeout(() => resolve(timeoutSentinel), effectiveMaxWaitMs);
+        })
+      ]);
+    } finally {
+      if (waitTimer)
+        clearTimeout(waitTimer);
+    }
+    if (waitResult === knownSlowSentinel) {
+      const { rooted, unrootedIds, unrootedReasons } = await partitionCandidates();
+      for (const { server, root } of rooted) {
+        const client = this.state.clients.get(`${server.id}:${normalizeMapKey(root)}`);
+        if (client?.isAlive())
+          return { client, info: server };
+      }
+      waitSkipReasons?.add("budget_skipped_known_slow");
+      logLatency({
+        type: "phase",
+        phase: "lsp_client_wait_skipped",
+        filePath,
+        durationMs: 0,
+        metadata: {
+          maxWaitMs: effectiveMaxWaitMs,
+          serverIds: rooted.map(({ server }) => server.id),
+          unrootedCandidates: {
+            count: unrootedIds.length,
+            ids: unrootedIds,
+            ...Object.keys(unrootedReasons).length > 0 ? { reasons: unrootedReasons } : {}
+          },
+          reason: "budget_skipped_known_slow"
+        }
+      });
+      return;
+    }
+    if (waitResult === timeoutSentinel) {
+      const partitionBudgetMs = hardCapMs !== undefined ? Math.min(250, hardCapMs / 4) : 250;
+      const partitioned = await withDeadline(partitionCandidates(), {
+        ms: partitionBudgetMs,
+        onTimeout: "undefined"
+      });
+      const { rooted, unrootedIds, unrootedReasons } = partitioned ?? {
+        rooted: [],
+        unrootedIds: [],
+        unrootedReasons: {}
+      };
+      const knownHealth = [...this.state.clients.entries()].filter(([k]) => rooted.some(({ server }) => k.startsWith(`${server.id}:`))).map(([k, c]) => ({
+        serverId: k.split(":")[0],
+        alive: c.isAlive(),
+        spawnedAt: this.state.clientSpawnedAt.get(k) ?? null
+      }));
+      logLatency({
+        type: "phase",
+        phase: "lsp_client_wait_timeout",
+        filePath,
+        durationMs: effectiveMaxWaitMs,
+        metadata: {
+          maxWaitMs: effectiveMaxWaitMs,
+          serverIds: rooted.map(({ server }) => server.id),
+          unrootedCandidates: {
+            count: unrootedIds.length,
+            ids: unrootedIds,
+            ...Object.keys(unrootedReasons).length > 0 ? { reasons: unrootedReasons } : {}
+          },
+          knownClientHealth: knownHealth,
+          ...partitioned === undefined ? { partition: "timed-out" } : {}
+        }
+      });
+      return;
+    }
+    return waitResult;
+  }
+  async getClientsForFile(filePath, excludeServerIds, resolvedRoots, auxiliaryRoots) {
+    const allServers = getServersForFileWithConfig(filePath);
+    const servers = excludeServerIds && excludeServerIds.size > 0 ? allServers.filter((s) => !excludeServerIds.has(s.id)) : allServers;
+    if (servers.length === 0)
+      return { clients: [], serverCountAttempted: 0 };
+    const rootedServers = (await Promise.all(servers.map(async (server) => ({
+      server,
+      root: await this.resolveServerRoot(server, filePath)
+    })))).filter((entry) => entry.root !== undefined);
+    for (const { server, root } of rootedServers)
+      if (isAuxiliary(server))
+        auxiliaryRoots?.set(server.id, normalizeMapKey(root));
+    let serverCountAttempted = 0;
+    const acquisitions = new Map;
+    const acquire = (server) => {
+      serverCountAttempted += 1;
+      return this.ensureClientForServer(filePath, server, resolvedRoots);
+    };
+    for (const { server } of rootedServers) {
+      const preferred = server.fallbackFor ? acquisitions.get(server.fallbackFor) : undefined;
+      const acquisition = preferred ? preferred.then((entry) => entry === undefined ? acquire(server) : undefined) : acquire(server);
+      acquisitions.set(server.id, acquisition);
+    }
+    const results = await Promise.all(acquisitions.values());
+    const clients = results.filter((entry) => entry !== undefined);
+    return { clients, serverCountAttempted };
+  }
+  async getAuxiliaryClientsForFile(filePath, enabledIds, onOutcome, maxWaitMs, signal, hook) {
+    if (this.checkDestroyed() || enabledIds.size === 0)
+      return [];
+    const servers = getServersForFileWithConfig(filePath).filter((s) => isAuxiliary(s) && enabledIds.has(s.id));
+    if (servers.length === 0)
+      return [];
+    const rootMemo = new Map;
+    const effectiveSignal = signal ?? getAmbientAbortSignal();
+    const effectiveHook = hook ?? "tool_result_edit";
+    const spawned = await Promise.all(servers.map(async (server) => {
+      const acquisition = this.ensureClientForServer(filePath, server, undefined, undefined, (reported) => onOutcome?.(server.id, reported), rootMemo);
+      if (!maxWaitMs || maxWaitMs <= 0) {
+        return acquisition;
+      }
+      return bounded(acquisition, {
+        ms: maxWaitMs,
+        signal: effectiveSignal,
+        hook: effectiveHook,
+        label: `auxiliary-spawn:${server.id}`
+      });
+    }));
+    return spawned.filter((entry) => Boolean(entry));
+  }
+  async getWarmClientForFile(filePath) {
+    if (this.checkDestroyed())
+      return;
+    const servers = getServersForFileWithConfig(filePath);
+    const missed = [];
+    for (const server of servers) {
+      const root = await this.resolveServerRoot(server, filePath);
+      if (!root)
+        continue;
+      const key = `${server.id}:${normalizeMapKey(root)}`;
+      const existing = this.state.clients.get(key);
+      if (existing?.isAlive()) {
+        return { client: existing, info: server };
+      }
+      missed.push(key);
+    }
+    if (missed.length > 0) {
+      emitBounded("lsp_warm_client_missing", missed.join(","), {
+        filePath,
+        durationMs: 0,
+        metadata: {
+          serverIds: missed.map((key) => key.slice(0, key.indexOf(":"))),
+          roots: missed.map((key) => key.slice(key.indexOf(":") + 1))
+        }
+      }, {
+        ledgerKind: "lsp-warm-client-missing",
+        risingEdgePer: "identity",
+        reason: `no warm client for ${missed.join(",")}`
+      });
+    }
+    return;
+  }
+  async hasServerPublishedForFileRoot(serverId, filePath) {
+    if (this.checkDestroyed())
+      return false;
+    for (const server of getServersForFileWithConfig(filePath)) {
+      if (server.id !== serverId)
+        continue;
+      const root = await this.resolveServerRoot(server, filePath);
+      if (!root)
+        continue;
+      const key = `${server.id}:${normalizeMapKey(root)}`;
+      const client = this.state.clients.get(key);
+      if (client?.isAlive() && client.getDiagnosticsVersionForPath(filePath) > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async readCachedDiagnosticsForServers(filePath, serverIds) {
+    const out = new Map;
+    if (this.checkDestroyed() || serverIds.size === 0)
+      return out;
+    for (const server of getServersForFileWithConfig(filePath)) {
+      if (!serverIds.has(server.id) || out.has(server.id))
+        continue;
+      const root = await this.resolveServerRoot(server, filePath);
+      if (!root)
+        continue;
+      const key = `${server.id}:${normalizeMapKey(root)}`;
+      const client = this.state.clients.get(key);
+      if (!client?.isAlive()) {
+        const demotedAt = this.notifyStallDemotions.get(key);
+        if (demotedAt !== undefined) {
+          out.set(server.id, {
+            diags: [],
+            notifyStallDemoted: true,
+            demotedAt
+          });
+        }
+        continue;
+      }
+      this.notifyStallDemotions.delete(key);
+      const entry = client.getAllDiagnostics().get(normalizeMapKey(filePath));
+      out.set(server.id, {
+        diags: entry?.diags ?? [],
+        publishedAt: entry?.ts
+      });
+    }
+    return out;
+  }
+  async observeLateAuxiliaryAnswer(filePath, serverId, elapsedMs) {
+    for (const server of getServersForFileWithConfig(filePath)) {
+      if (server.id !== serverId)
+        continue;
+      const root = await this.resolveServerRoot(server, filePath);
+      if (root === undefined)
+        return;
+      this.noteAuxiliaryLateAnswer(`${serverId}:${normalizeMapKey(root)}`, elapsedMs);
+      return;
+    }
+  }
+  async notifyExternalFileChange(filePath, type) {
+    if (this.checkDestroyed())
+      return;
+    for (const server of getServersForFileWithConfig(filePath)) {
+      const root = await this.resolveServerRoot(server, filePath);
+      if (!root)
+        continue;
+      this.notifyLiveClientsForServer(server.id, filePath, type, `${server.id}:${normalizeMapKey(root)}`, true);
+    }
+  }
+  async resyncGitChangedFiles(changedPaths, options = {}) {
+    const dispositions = new Map;
+    if (this.checkDestroyed() || changedPaths.length === 0) {
+      return dispositions;
+    }
+    const targets = new Set;
+    const changed = new Map;
+    for (const changedPath of changedPaths) {
+      const resolved = path.resolve(changedPath);
+      for (const server of getServersForFileWithConfig(resolved)) {
+        const root = await this.resolveServerRoot(server, resolved);
+        if (!root)
+          continue;
+        const index = loadReverseDependencyIndexFromSnapshot({ cwd: root });
+        for (const importer of index ? getReverseDepsFromIndex(index, resolved) : []) {
+          targets.add(importer);
+        }
+      }
+      targets.add(resolved);
+      changed.set(changedPath, resolved);
+    }
+    const openTargets = [...targets].filter((filePath) => this.hasLiveClientHoldingDocument(filePath));
+    const written = new Set(changed.values());
+    this.documentDrift.enqueueResync(openTargets.filter((filePath) => !written.has(filePath)));
+    this.documentDrift.enqueueResync(openTargets.filter((filePath) => written.has(filePath)), { saved: options.saved === true });
+    const pass = await this.sweepDocumentDrift({ force: true });
+    logLatency({
+      type: "phase",
+      phase: "lsp_external_change_resync",
+      filePath: changedPaths[0] ?? "",
+      durationMs: 0,
+      metadata: {
+        changedCount: changedPaths.length,
+        enqueued: openTargets.length,
+        deferred: pass?.deferred ?? this.documentDrift.pendingResyncCount
+      }
+    });
+    for (const [changedPath, resolved] of changed) {
+      dispositions.set(changedPath, openTargets.includes(resolved) ? pass?.queued.get(normalizeMapKey(resolved)) ?? "deferred" : "unheld");
+    }
+    return dispositions;
+  }
+  async sweepDocumentDrift(options = {}) {
+    if (this.checkDestroyed())
+      return;
+    return this.documentDrift.sweep({
+      resync: async (filePath, content, _driftAgeMs, readStamp, saved) => {
+        await this.touchFile(filePath, content, {
+          diagnostics: "none",
+          source: "drift_resync",
+          clientScope: "all",
+          excludeServerIds: await this.serverIdsNotHoldingDocument(filePath),
+          readStamp,
+          saved: saved === true
+        });
+        return this.documentDrift.peek(filePath)?.fingerprint === fingerprintDocumentContent(content);
+      },
+      holdsDocument: (filePath) => this.hasLiveClientHoldingDocument(filePath),
+      onDrift: (event) => {
+        if (event.disposition === "unchanged" || event.disposition === "vanished" || event.disposition === "unheld") {
+          return;
+        }
+        incrementDegradationCount({
+          kind: "lsp-document-drift",
+          subject: event.filePath,
+          reason: event.disposition === "deferred" ? `disk drift deferred by resync pacing after ${event.driftAgeMs}ms` : event.disposition === "failed" ? `resync FAILED after ${event.driftAgeMs}ms of untracked disk drift; view still stale (${event.syncedSize}->${event.diskSize} bytes)` : `resynced after ${event.driftAgeMs}ms of untracked disk drift (${event.syncedSize}->${event.diskSize} bytes)`
+        });
+        logLatency({
+          type: "phase",
+          phase: "lsp_document_drift",
+          filePath: event.filePath,
+          durationMs: event.driftAgeMs,
+          metadata: {
+            disposition: event.disposition,
+            driftAgeMs: event.driftAgeMs,
+            syncedSize: event.syncedSize,
+            diskSize: event.diskSize
+          }
+        });
+      }
+    }, options);
+  }
+  _driftTrackedCountForTests() {
+    return this.documentDrift.size;
+  }
+  hasLiveClientHoldingDocument(filePath) {
+    for (const client of this.state.clients.values()) {
+      if (!client.isAlive())
+        continue;
+      if (documentIsOpenOn(client, filePath))
+        return true;
+    }
+    return false;
+  }
+  async serverIdsNotHoldingDocument(filePath) {
+    const exclude = new Set;
+    for (const server of getServersForFileWithConfig(filePath)) {
+      const root = await this.resolveServerRoot(server, filePath);
+      const existing = root ? this.state.clients.get(`${server.id}:${normalizeMapKey(root)}`) : undefined;
+      if (existing?.isAlive() && documentIsOpenOn(existing, filePath))
+        continue;
+      exclude.add(server.id);
+    }
+    return exclude;
+  }
+  recordFullyCoveredSync(filePath, content, targeted, allWritesLanded, at, contentFingerprint) {
+    if (!allWritesLanded || targeted.length === 0)
+      return;
+    const targetedClients = new Set(targeted.map((entry) => entry.client));
+    for (const client of this.state.clients.values()) {
+      if (targetedClients.has(client))
+        continue;
+      if (!client.isAlive())
+        continue;
+      if (documentIsOpenOn(client, filePath))
+        return;
+    }
+    this.documentDrift.recordSynced(filePath, content, at, contentFingerprint?.() ?? fingerprintDocumentContent(content));
+  }
+  noteSpawnVerdict(key, verdict) {
+    this.lastSpawnVerdict.set(key, verdict);
+  }
+  resolveServerRootOnce(server, filePath, memo, onRootFailure) {
+    if (!memo)
+      return this.resolveServerRoot(server, filePath, onRootFailure);
+    const pending = memo.get(server.id);
+    if (pending !== undefined)
+      return pending;
+    const started = this.resolveServerRoot(server, filePath, onRootFailure);
+    memo.set(server.id, started);
+    return started;
+  }
+  async ensureClientForServer(filePath, server, resolvedRoots, onSpawnInFlight, onOutcome, rootMemo) {
+    const handoff = this.generationHandoff;
+    if (handoff) {
+      await handoff;
+      if (this.generationHandoff === handoff) {
+        this.generationHandoff = undefined;
+      }
+      if (this.checkDestroyed())
+        return;
+    }
+    const root = await this.resolveServerRootOnce(server, filePath, rootMemo);
+    if (!root || this.checkDestroyed())
+      return;
+    if (!isAuxiliary(server)) {
+      resolvedRoots?.set(server.id, normalizeMapKey(root));
+    }
+    const allowInstall = this.shouldAllowInstall(server.id);
+    const normalizedRoot = normalizeMapKey(root);
+    const key = `${server.id}:${normalizedRoot}`;
+    const adopted = this.analysisRootModeForFile(filePath) === "adopted";
+    if (adopted) {
+      const localCommand = server.command ?? server.projectLocalCommand ?? server.availabilityKey;
+      const localBinary = localCommand ? path.isAbsolute(localCommand) ? isProjectLocalBinPath(localCommand, root) ? localCommand : undefined : findLocalBinUpwards(localCommand, root) : undefined;
+      if (localBinary) {
+        recordDegradationOnce({
+          kind: "lsp-registry-decision",
+          subject: `${server.id}:${normalizeMapKey(root)}`,
+          reason: "project-local LSP binary refused for adopted root"
+        });
+        return;
+      }
+      this.adoptedClientKeys.add(key);
+      if (!this.admitAdoptedRoot(root, filePath))
+        return;
+    }
+    const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id);
+    if (server.availabilityKey && isDirectLspCommandTemporarilyUnavailable(server.availabilityKey)) {
+      emitBounded("lsp_client_skipped_unavailable_command", `${server.availabilityKey}:${normalizeMapKey(filePath)}`, {
+        filePath,
+        durationMs: 0,
+        metadata: {
+          serverId: server.id,
+          command: server.availabilityKey
+        }
+      }, {
+        ledgerKind: "lsp-client-skipped-unavailable-command",
+        risingEdgePer: "identity",
+        reason: `command ${server.availabilityKey} temporarily unavailable`
+      });
+      return;
+    }
+    if (isOptionalServer && this.optionalDisabled.has(key)) {
+      return;
+    }
+    if (this.permanentlyBroken.has(key)) {
+      emitBounded("lsp_client_skipped_broken", `${server.id}:${normalizeMapKey(filePath)}`, {
+        filePath,
+        durationMs: 0,
+        metadata: {
+          serverId: server.id,
+          permanent: true
+        }
+      }, {
+        ledgerKind: "lsp-client-skipped-broken",
+        risingEdgePer: "identity",
+        reason: `${server.id} latched permanently broken`
+      });
+      return;
+    }
+    const existing = this.state.clients.get(key);
+    if (existing) {
+      if (existing.isAlive()) {
+        this.unavailableLogged.delete(key);
+        this.clientLastUsedAt.set(key, Date.now());
+        this.scheduleIdleEviction(key, server);
+        if (!this.warmStartLogged.has(key)) {
+          logSessionStart(`lsp warm-start ${server.id}: reused root=${root} file=${filePath}`);
+          this.warmStartLogged.add(key);
+        }
+        onOutcome?.("warm-reuse");
+        return { client: existing, info: server };
+      }
+      const spawnedAt = this.state.clientSpawnedAt.get(key);
+      const wasIntentional = existing.wasShutdownIntentional();
+      const exitedAt = existing.getExitedAt();
+      const uptimeMs = exitedAt != null && spawnedAt != null ? exitedAt - spawnedAt : spawnedAt != null ? Date.now() - spawnedAt : null;
+      logLatency({
+        type: "phase",
+        phase: "lsp_server_respawn",
+        filePath,
+        durationMs: 0,
+        metadata: {
+          serverId: server.id,
+          root,
+          uptimeMs,
+          intentional: wasIntentional
+        }
+      });
+      this.releaseOutstandingAuxNotifyWrite(key);
+      try {
+        await existing.shutdown();
+      } catch {}
+      this.retireClient(key);
+      this.state.broken.delete(key);
+      if (wasIntentional) {} else {
+        if (this.recordRuntimeExitWindow(key, exitedAt, uptimeMs)) {
+          const rate = `${RUNTIME_EXIT_WINDOW_TRIP_COUNT} deaths within ${Math.round(RUNTIME_EXIT_WINDOW_MS / 60000)}m`;
+          this.state.broken.set(key, Math.max(this.state.broken.get(key) ?? 0, Date.now() + (isOptionalServer ? OPTIONAL_LSP_RETRY_COOLDOWN_MS : BROKEN_MAX_COOLDOWN_MS)));
+          if (isOptionalServer) {
+            this.optionalDisabled.add(key);
+            this.runtimeExitWindow.delete(key);
+            logSessionStart(`lsp respawn ${server.id}: optional server cooled down (windowed-rate trip: ${rate})`);
+          } else {
+            this.permanentlyBroken.add(key);
+            this.recordBreaker(key, `windowed runtime-exit trip: ${rate}`);
+            logSessionStart(`lsp respawn ${server.id}: permanently disabled (windowed-rate trip: ${rate}, uptimeMs=${uptimeMs})`);
+          }
+        }
+        if (uptimeMs != null && uptimeMs < RUNTIME_EXIT_UPTIME_THRESHOLD_MS) {
+          const rCount = (this.runtimeExitCounts.get(key) ?? 0) + 1;
+          this.runtimeExitCounts.set(key, rCount);
+          const rCooldown = Math.min(BROKEN_BASE_COOLDOWN_MS * 2 ** (rCount - 1), BROKEN_MAX_COOLDOWN_MS);
+          this.state.broken.set(key, Date.now() + rCooldown);
+          if (!isOptionalServer && rCount >= BROKEN_PERMANENT_AFTER) {
+            this.permanentlyBroken.add(key);
+            this.recordBreaker(key, `permanently disabled after ${rCount} early post-init exits`);
+            logSessionStart(`lsp respawn ${server.id}: permanently disabled after ${rCount} early post-init exits (uptimeMs=${uptimeMs})`);
+          } else {
+            logSessionStart(`lsp respawn ${server.id}: early post-init exit ${rCount}/${BROKEN_PERMANENT_AFTER} (uptimeMs=${uptimeMs}), cooldown=${rCooldown}ms`);
+          }
+        } else {
+          this.runtimeExitCounts.delete(key);
+          const windowDeaths = this.runtimeExitWindow.get(key);
+          if (windowDeaths) {
+            const windowNow = exitedAt ?? Date.now();
+            if (!windowDeaths.some((t) => t >= windowNow - RUNTIME_EXIT_WINDOW_MS)) {
+              this.runtimeExitWindow.delete(key);
+            }
+          }
+        }
+      }
+    }
+    const brokenUntil = this.state.broken.get(key);
+    if (typeof brokenUntil === "number" && brokenUntil > Date.now()) {
+      emitBounded("lsp_client_skipped_broken", `${server.id}:${normalizeMapKey(filePath)}`, {
+        filePath,
+        durationMs: 0,
+        metadata: {
+          serverId: server.id,
+          retryInMs: Math.max(0, brokenUntil - Date.now())
+        }
+      }, {
+        ledgerKind: "lsp-client-skipped-broken",
+        risingEdgePer: "identity",
+        reason: `${server.id} in breaker cooldown`
+      });
+      return;
+    }
+    if (typeof brokenUntil === "number" && brokenUntil <= Date.now()) {
+      this.state.broken.delete(key);
+      if (isOptionalServer)
+        this.optionalDisabled.delete(key);
+    }
+    let startedSpawn = false;
+    let spawnPromise = this.state.inFlight.get(key);
+    if (!spawnPromise) {
+      const started = await this.withClientSpawnGate(async () => {
+        const raced = this.state.inFlight.get(key);
+        if (raced)
+          return { promise: raced, startedSpawn: false };
+        if (this.checkDestroyed())
+          return;
+        if (!await this.makeCapacityForClient(key))
+          return;
+        const promise = this.spawnClient(server, root, key, filePath, allowInstall);
+        this.state.inFlight.set(key, promise);
+        return { promise, startedSpawn: true };
+      });
+      if (!started)
+        return;
+      spawnPromise = started.promise;
+      startedSpawn = started.startedSpawn;
+    }
+    onSpawnInFlight?.(server.id);
+    try {
+      const spawned = await spawnPromise;
+      onOutcome?.(spawned ? startedSpawn ? "cold-spawn" : "cold-spawn-joined" : this.lastSpawnVerdict.get(key) === "failed" ? startedSpawn ? "spawn-failure" : "spawn-failure-joined" : "declined");
+      return spawned;
+    } catch (err) {
+      onOutcome?.("spawn-failure");
+      throw err;
+    } finally {
+      if (this.state.inFlight.get(key) === spawnPromise) {
+        this.state.inFlight.delete(key);
+      }
+    }
+  }
+  shouldAllowInstall(serverId) {
+    if (!assertInstallAllowed(`lsp install: ${serverId}`))
+      return false;
+    return process.env.DM_LENS_DISABLE_LSP_INSTALL !== "1";
+  }
+  async spawnClient(server, root, key, filePath, allowInstall) {
+    try {
+      if (server.executesProjectCode === true) {
+        refuseUntrustedLspExecution({
+          kind: "project-code-server",
+          serverId: server.id,
+          root
+        });
+      }
+    } catch (error) {
+      logSessionStart(`lsp spawn ${server.id}: refused — ${error instanceof Error ? error.message : String(error)}`);
+      this.noteSpawnVerdict(key, "failed");
+      return;
+    }
+    if (server.trustAllowed !== true && !isLspSpawnAllowedByTrust()) {
+      logSessionStart(`lsp spawn ${server.id}: refused — ${projectTrustDenialReason()}`);
+      this.noteSpawnVerdict(key, "declined");
+      return;
+    }
+    const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id);
+    const startedAt = Date.now();
+    logSessionStart(`lsp spawn ${server.id}: start root=${root} install=${allowInstall ? "enabled" : "disabled"} file=${filePath}`);
+    recordLsp(server.id, root, "spawn_start");
+    try {
+      const projectCodeAllowed = this.analysisRootModeForFile(filePath) !== "adopted";
+      const spawned = await withLspProjectCodePermission(projectCodeAllowed, () => server.spawn(root, {
+        allowInstall,
+        projectCodeAllowed,
+        sessionRoot: this.sessionCwd ?? process.cwd()
+      }));
+      if (this.isDestroyed) {
+        try {
+          spawned?.process?.process?.kill();
+        } catch {}
+        logSessionStart(`lsp spawn ${server.id}: aborted (service shut down mid-spawn)`);
+        this.noteSpawnVerdict(key, "declined");
+        return;
+      }
+      if (!spawned) {
+        logSessionStart(`lsp spawn ${server.id}: unavailable (${Date.now() - startedAt}ms)`);
+        recordLsp(server.id, root, "spawn_failed", Date.now() - startedAt);
+        if (!allowInstall) {
+          logSessionStart(`lsp spawn ${server.id}: unavailable with install disabled; temporary cooldown only`);
+          this.state.broken.set(key, Date.now() + BROKEN_BASE_COOLDOWN_MS);
+          this.noteSpawnVerdict(key, "declined");
+          return;
+        }
+        const uCount = (this.failureCounts.get(key) ?? 0) + 1;
+        this.failureCounts.set(key, uCount);
+        const uCooldown = Math.min(BROKEN_BASE_COOLDOWN_MS * 2 ** (uCount - 1), BROKEN_MAX_COOLDOWN_MS);
+        this.state.broken.set(key, Date.now() + uCooldown);
+        if (uCount >= BROKEN_PERMANENT_AFTER) {
+          this.permanentlyBroken.add(key);
+          this.recordBreaker(key, `permanently disabled after ${uCount} unavailable spawns`);
+          logSessionStart(`lsp spawn ${server.id}: permanently disabled after ${uCount} failures`);
+        }
+        this.noteSpawnVerdict(key, "failed");
+        return;
+      }
+      const override = getServerInitOverride(server.id, filePath);
+      const mergedInit = spawned.launchVariant === "classic" ? mergeInitializationOptions(override?.initializationOptions, spawned.initialization) : mergeInitializationOptions(spawned.initialization, override?.initializationOptions);
+      this.state.diagnosticsPublished.delete(server.id);
+      this.state.diagnosticsUnsupported.delete(server.id);
+      this.firstContactWaits.delete(server.id);
+      const client = await createLSPClient({
+        serverId: server.id,
+        process: spawned.process,
+        root,
+        sessionCwd: this.sessionCwd,
+        initialization: mergedInit,
+        initializeTimeoutMs: server.initializeTimeoutMs,
+        launchVariant: spawned.launchVariant,
+        onDiagnosticsPublished: (serverId) => {
+          this.state.diagnosticsPublished.add(serverId);
+        }
+      });
+      if (this.isDestroyed) {
+        client.shutdown({ fast: true }).catch(() => {});
+        logSessionStart(`lsp spawn ${server.id}: aborted (service shut down mid-initialize)`);
+        this.noteSpawnVerdict(key, "declined");
+        return;
+      }
+      const wsDiag = typeof client.getWorkspaceDiagnosticsSupport === "function" ? client.getWorkspaceDiagnosticsSupport() : {
+        advertised: false,
+        mode: "push-only",
+        diagnosticProviderKind: "unavailable"
+      };
+      this.state.clients.set(key, client);
+      this.forgetReadiness(key);
+      this.notifyStallDemotions.delete(key);
+      this.unavailableLogged.delete(key);
+      this.lastSpawnVerdict.delete(key);
+      this.state.clientSpawnedAt.set(key, Date.now());
+      this.clientLastUsedAt.set(key, Date.now());
+      this.scheduleIdleEviction(key, server);
+      this.failureCounts.delete(key);
+      if (isOptionalServer) {
+        this.optionalDisabled.delete(key);
+        this.optionalFailureLogged.delete(key);
+      }
+      logSessionStart(`lsp spawn ${server.id}: success source=${spawned.source ?? "unknown"} (${Date.now() - startedAt}ms)`);
+      const spawnDurationMs = Date.now() - startedAt;
+      recordLsp(server.id, root, "spawn_success", spawnDurationMs);
+      recordSuccessfulLspSpawn(server.id, spawnDurationMs);
+      logLatency({
+        type: "phase",
+        phase: "lsp_server_spawned",
+        filePath: root,
+        durationMs: spawnDurationMs,
+        metadata: {
+          serverId: server.id,
+          source: spawned.source ?? "unknown",
+          launchVariant: spawned.launchVariant ?? "default",
+          triggerFilePath: filePath
+        }
+      });
+      if (!this.workspaceProbeLogged.has(key)) {
+        logSessionStart(`lsp workspace-diag probe ${server.id}: advertised=${wsDiag.advertised} mode=${wsDiag.mode} provider=${wsDiag.diagnosticProviderKind}`);
+        this.workspaceProbeLogged.add(key);
+      }
+      return { client, info: server };
+    } catch (err) {
+      recordLsp(server.id, root, "spawn_failed", Date.now() - startedAt);
+      if (!isOptionalServer || !this.optionalFailureLogged.has(key)) {
+        logSessionStart(`lsp spawn ${server.id}: failed (${Date.now() - startedAt}ms) error=${err instanceof Error ? err.message : String(err)}`);
+        if (isOptionalServer) {
+          this.optionalFailureLogged.add(key);
+        }
+      }
+      const eCount = (this.failureCounts.get(key) ?? 0) + 1;
+      this.failureCounts.set(key, eCount);
+      const eCooldown = isOptionalServer ? OPTIONAL_LSP_RETRY_COOLDOWN_MS : Math.min(BROKEN_BASE_COOLDOWN_MS * 2 ** (eCount - 1), BROKEN_MAX_COOLDOWN_MS);
+      this.state.broken.set(key, Date.now() + eCooldown);
+      if (!isOptionalServer && eCount >= BROKEN_PERMANENT_AFTER) {
+        this.permanentlyBroken.add(key);
+        this.recordBreaker(key, `permanently disabled after ${eCount} spawn/initialize failures`);
+        logSessionStart(`lsp spawn ${server.id}: permanently disabled after ${eCount} failures`);
+      }
+      if (isOptionalServer) {
+        this.optionalDisabled.add(key);
+      }
+      this.noteSpawnVerdict(key, "failed");
+      return;
+    }
+  }
+  async openFile(filePath, content, options) {
+    if (this.checkDestroyed())
+      return;
+    const startedAt = Date.now();
+    await this.withClientForFileUse(filePath, undefined, options?.spawnBudgetMs, async (spawned) => {
+      const languageId = getLanguageId(filePath) ?? "plaintext";
+      const sent = await spawned.client.notify.open(filePath, content, languageId, options?.preserveDiagnostics);
+      this.recordFullyCoveredSync(filePath, content, [spawned], sent !== false, startedAt);
+    });
+  }
+  async updateFile(filePath, content) {
+    if (this.checkDestroyed())
+      return;
+    await this.withClientForFileUse(filePath, undefined, undefined, (spawned) => spawned.client.notify.change(filePath, content));
+  }
+  async touchFile(filePath, content, options = {}) {
+    if (this.checkDestroyed()) {
+      const destroyedDiagnosticsMode = options.collectDiagnostics ? options.diagnostics ?? "document" : options.diagnostics ?? "none";
+      logLatency({
+        type: "phase",
+        phase: "lsp_touch_file",
+        filePath: normalizeMapKey(filePath),
+        durationMs: 0,
+        metadata: {
+          serverCountAttempted: 0,
+          serverCountReady: 0,
+          clientScope: options.clientScope ?? (destroyedDiagnosticsMode === "full" ? "all" : "primary"),
+          diagnosticsMode: destroyedDiagnosticsMode,
+          source: options.source ?? "unknown",
+          failureKind: "destroyed"
+        }
+      });
+      return;
+    }
+    const contentHash = this.hashContent(content);
+    if (typeof content === "string") {
+      this.announceToSiblings(filePath, content, contentHash).catch((cause) => {
+        incrementDegradationCount({
+          kind: "lsp-sibling-announcement",
+          subject: normalizeMapKey(filePath),
+          reason: `sibling notification failed: ${String(cause)}`
+        });
+      });
+    }
+    const startedAt = Date.now();
+    let fingerprintMemo;
+    const contentFingerprint = () => fingerprintMemo ??= fingerprintDocumentContent(content);
+    const hookDeadlineAt = options.hook !== undefined && Object.hasOwn(HOOK_WALL_BUDGET_MS, options.hook) ? startedAt + HOOK_WALL_BUDGET_MS[options.hook] : undefined;
+    const normalizedPath = normalizeMapKey(filePath);
+    const outsideRoot = await this.findOutsideProjectRoot(filePath);
+    if (outsideRoot) {
+      this.recordOutsideRootDecline(filePath, outsideRoot, "touchFile");
+      return { diags: [], skipReason: "outside-project-root" };
+    }
+    this.sweepDocumentDrift().catch(() => {});
+    const diagnosticsMode = options.collectDiagnostics ? options.diagnostics ?? "document" : options.diagnostics ?? "none";
+    const source = options.source ?? "unknown";
+    const clientScope = options.clientScope ?? (diagnosticsMode === "full" ? "all" : "primary");
+    const useAllClients = clientScope === "all";
+    const resolvedPrimaryRoots = new Map;
+    const attemptedAuxiliaryRoots = new Map;
+    const waitSkipReasons = new Set;
+    const coldAuxiliaryServerIds = new Set;
+    const noteColdAuxiliary = (serverId, outcome) => {
+      if (outcome === "cold-spawn" || outcome === "cold-spawn-joined") {
+        coldAuxiliaryServerIds.add(serverId);
+      }
+    };
+    let spawned;
+    let serverCountAttempted;
+    if (useAllClients) {
+      const result = await this.getClientsForFile(filePath, options.excludeServerIds, resolvedPrimaryRoots, attemptedAuxiliaryRoots);
+      spawned = result.clients;
+      serverCountAttempted = result.serverCountAttempted;
+    } else if (clientScope === "with-auxiliary") {
+      const auxStartedAt = Date.now();
+      const [entry, aux] = await Promise.all([
+        this.getClientForFile(filePath, options.maxClientWaitMs, undefined, resolvedPrimaryRoots, waitSkipReasons),
+        this.getAuxiliaryClientsForFile(filePath, new Set(options.auxiliaryServerIds ?? []), noteColdAuxiliary, options.maxClientWaitMs, undefined, options.hook)
+      ]);
+      const auxDurationMs = Date.now() - auxStartedAt;
+      if (options.auxiliaryServerIds && options.auxiliaryServerIds.length > 0) {
+        logLatency({
+          type: "phase",
+          phase: "auxiliary_readiness",
+          filePath: normalizedPath,
+          durationMs: auxDurationMs,
+          metadata: {
+            serverIds: aux.map((s) => s.info.id),
+            attemptedCount: options.auxiliaryServerIds.length,
+            readyCount: aux.length,
+            coldServerIds: [...coldAuxiliaryServerIds],
+            source
+          }
+        });
+      }
+      spawned = entry ? [entry, ...aux] : aux;
+      serverCountAttempted = spawned.length;
+    } else {
+      const entry = await this.getClientForFile(filePath, options.maxClientWaitMs, undefined, resolvedPrimaryRoots, waitSkipReasons);
+      spawned = entry ? [entry] : [];
+      serverCountAttempted = spawned.length > 0 ? 1 : getServersForFileWithConfig(filePath).length > 0 ? 1 : 0;
+    }
+    if (spawned.length === 0) {
+      const failureKind = this.isSpawnInFlight(filePath, resolvedPrimaryRoots) ? "spawn_in_flight_budget_elapsed" : "no_clients_none_spawning";
+      logLatency({
+        type: "phase",
+        phase: "lsp_touch_file",
+        filePath: normalizedPath,
+        durationMs: Date.now() - startedAt,
+        metadata: {
+          serverCountAttempted,
+          serverCountReady: 0,
+          clientScope,
+          diagnosticsMode,
+          source,
+          maxClientWaitMs: options.maxClientWaitMs,
+          failureKind,
+          ...waitSkipReasons.size > 0 ? { reason: [...waitSkipReasons][0] } : {},
+          candidates: this.describeTouchCandidates(filePath, resolvedPrimaryRoots, attemptedAuxiliaryRoots)
+        }
+      });
+      return;
+    }
+    const leaseKeys = await this.acquireClientLeases(spawned, filePath);
+    if (!leaseKeys) {
+      if (this.checkDestroyed()) {
+        const primaryServerIds = spawned.filter((entry) => !isAuxiliary(entry.info)).map((entry) => entry.info.id);
+        return {
+          diags: [],
+          inconclusive: true,
+          ...primaryServerIds.length > 0 && {
+            inconclusiveServerIds: primaryServerIds
+          },
+          inconclusiveReason: "diagnostics-wait"
+        };
+      }
+      return this.touchFile(filePath, content, options);
+    }
+    try {
+      if (this.shouldSkipTouch(filePath, contentFingerprint, clientScope, diagnosticsMode !== "none", spawned)) {
+        logLatency({
+          type: "phase",
+          phase: "lsp_touch_file",
+          filePath: normalizedPath,
+          durationMs: Date.now() - startedAt,
+          metadata: {
+            serverCountReady: spawned.length,
+            clientScope,
+            diagnosticsMode,
+            source,
+            failureKind: "success",
+            skipped: true,
+            reason: "debounced_unchanged_content"
+          }
+        });
+        return { diags: [] };
+      }
+      const languageId = getLanguageId(filePath) ?? "plaintext";
+      const silent = options.silent ?? false;
+      const notifySkippedServerIds = new Set(spawned.filter((entry) => this.shouldSkipNotify(filePath, contentFingerprint, clientScope, entry.info.id, entry.client)).map((entry) => entry.info.id));
+      const notifySkipped = spawned.length > 0 && notifySkippedServerIds.size === spawned.length;
+      const readPathVersion = (client) => client.getDiagnosticsVersionForPath?.(filePath);
+      const diagnosticBaselines = new Map(spawned.map((entry) => [entry.client, readPathVersion(entry.client)]));
+      const markedAtMs = Date.now();
+      const touchContentHash = contentHash;
+      const bindingMatchesTouchContent = (binding) => binding?.contentHash === touchContentHash;
+      const carriedAuxiliary = options.collectDiagnostics ? spawned.flatMap((entry) => {
+        if (!isAuxiliary(entry.info))
+          return [];
+        const binding = entry.client.getDiagnosticBinding?.(filePath);
+        if (!bindingMatchesTouchContent(binding))
+          return [];
+        const diags = entry.client.getDiagnostics(filePath);
+        return diags.length > 0 ? [{ serverId: entry.info.id, diags, binding }] : [];
+      }) : [];
+      const auxPublishedThisContent = new Set(spawned.flatMap((entry) => isAuxiliary(entry.info) && bindingMatchesTouchContent(entry.client.getDiagnosticBinding?.(filePath)) ? [entry.info.id] : []));
+      const spawnedByServerId = new Map(spawned.map((entry) => [entry.info.id, entry]));
+      const auxCoversThisContent = (serverId) => {
+        const entry = spawnedByServerId.get(serverId);
+        if (!entry || !isAuxiliary(entry.info))
+          return false;
+        return auxPublishedThisContent.has(serverId) || bindingMatchesTouchContent(entry.client.getDiagnosticBinding?.(filePath));
+      };
+      const notifyWriteTimedOutServerIds = [];
+      const notifyDeferredServerIds = [];
+      const supersededServerIds = [];
+      if (!notifySkipped) {
+        const budget = notifyWriteBudgetMs();
+        const queueWaitMs = options.maxClientWaitMs !== undefined ? Math.min(budget, Math.max(0, primaryServerWaitFloorMs(filePath, options.maxClientWaitMs) - (Date.now() - startedAt))) : budget;
+        await Promise.all(spawned.map(async (entry) => {
+          if (notifySkippedServerIds.has(entry.info.id))
+            return;
+          const clientKey = await this.demonstratedReadyKeyFor(entry.info, filePath);
+          const gated = isAuxiliary(entry.info) && clientKey !== undefined;
+          let slot;
+          if (gated && clientKey) {
+            const barrierStartedAt = Date.now();
+            await this.paceAuxNotify(clientKey, entry, filePath, queueWaitMs, {
+              source,
+              clientScope
+            });
+            const slotWaitMs = Math.max(0, queueWaitMs - (Date.now() - barrierStartedAt));
+            const claim = await this.claimAuxNotifySlot(clientKey, entry, filePath, slotWaitMs);
+            if ("outstandingMs" in claim) {
+              notifyDeferredServerIds.push(entry.info.id);
+              logLatency({
+                type: "phase",
+                phase: "lsp_notify_resync_deferred",
+                filePath: normalizedPath,
+                durationMs: claim.outstandingMs,
+                metadata: {
+                  serverId: entry.info.id,
+                  source,
+                  clientScope,
+                  reason: "outstanding_write",
+                  outstandingMs: claim.outstandingMs,
+                  queueWaitMs
+                }
+              });
+              return;
+            }
+            slot = claim;
+          }
+          let wrote;
+          let rejected = false;
+          try {
+            const writeStartedAt = Date.now();
+            const writePromise = entry.client.notify.open(filePath, content, languageId, undefined, silent, options.saved === true, options.readStamp).then((sent) => sent !== false);
+            if (gated && clientKey) {
+              this.noteAuxNotifyIssued(clientKey, entry.client);
+            }
+            if (slot && clientKey) {
+              const client = entry.client;
+              const release = slot.release;
+              writePromise.then(() => {
+                release();
+                const outstandingMs = Date.now() - writeStartedAt;
+                if (outstandingMs > budget && outstandingMs <= this.auxNotifyWedgeBudgetMs(clientKey)) {
+                  this.retractNotifyWriteBackpressure(clientKey, entry.info.id, filePath, outstandingMs, client);
+                }
+              }, release);
+            }
+            wrote = await withDeadline(writePromise, {
+              ms: budget,
+              onTimeout: "undefined",
+              onReject: "propagate"
+            });
+          } catch {
+            rejected = true;
+            slot?.release();
+          }
+          if (wrote === true) {
+            if (clientKey)
+              this.notifyWriteBackpressureStreak.delete(clientKey);
+            this.markTouched(filePath, contentFingerprint(), clientScope, entry.info.id, entry.client);
+          } else if (wrote === false) {
+            supersededServerIds.push(entry.info.id);
+          } else {
+            notifyWriteTimedOutServerIds.push(entry.info.id);
+            if (!rejected) {
+              this.recordNotifyWriteBackpressure(clientKey, entry, filePath);
+            }
+          }
+        }));
+        this.recordFullyCoveredSync(filePath, content, spawned, notifyWriteTimedOutServerIds.length === 0 && notifyDeferredServerIds.length === 0 && supersededServerIds.length === 0, startedAt, contentFingerprint);
+        if (notifyWriteTimedOutServerIds.length > 0) {
+          logLatency({
+            type: "phase",
+            phase: "lsp_notify_timeout",
+            filePath: normalizedPath,
+            durationMs: Date.now() - startedAt,
+            metadata: {
+              source,
+              clientScope,
+              serverCount: spawned.length,
+              timedOutServerIds: notifyWriteTimedOutServerIds
+            }
+          });
+        }
+      }
+      const notifyWriteTimedOut = notifyWriteTimedOutServerIds.length > 0;
+      const primaryEntries = spawned.filter((entry) => !isAuxiliary(entry.info));
+      const primaryServerIds = new Set(primaryEntries.map((e) => e.info.id));
+      const primaryNotifyWriteTimedOutServerIds = notifyWriteTimedOutServerIds.filter((id) => primaryServerIds.has(id));
+      const primaryNotifyWriteTimedOut = primaryNotifyWriteTimedOutServerIds.length > 0;
+      const deferredResyncServerIds = new Set(notifyDeferredServerIds);
+      let diagnosticsTimedOut = false;
+      let diagnosticsUnansweredServerIds = [];
+      let diagnosticsUnansweredPrimaryServerIds = [];
+      const retractPrimaryTimeoutAttribution = () => {
+        diagnosticsUnansweredPrimaryServerIds = [];
+        diagnosticsUnansweredServerIds = diagnosticsUnansweredServerIds.filter((id) => !primaryServerIds.has(id));
+      };
+      let auxCutOffServerIds;
+      let auxUnconfirmedServerIds;
+      let lateDeliveryServerIds;
+      let tsserverSyncEligible = false;
+      const isWarmupTouch = source === "lsp_sweep_warmup";
+      let tsserverSyncConfirmed;
+      let diagnosticsUnsupportedServerIds = [];
+      if (diagnosticsMode !== "none") {
+        const envWait = readEnvDiagnosticsWaitMs();
+        const callerCap = options.maxDiagnosticsWaitMs ?? options.maxClientWaitMs;
+        const modeFloor = diagnosticsMode === "full" ? 3000 : 1200;
+        const sweepFirstTouch = new Map;
+        if (options.sweepIndexGate) {
+          for (const entry of spawned) {
+            const strategy = getStrategy(entry.client.serverId, entry.client.getLaunchVariant?.());
+            if (strategy.workspaceIndexing) {
+              sweepFirstTouch.set(entry.client.serverId, options.sweepIndexGate.consumeFirstTouch(entry.client.serverId));
+            }
+          }
+        }
+        const silentCleanWarmupServers = new Set;
+        if (options.warmupOverride && (options.warmupAttempt ?? 1) <= 1) {
+          for (const entry of spawned) {
+            const strategy = getStrategy(entry.client.serverId, entry.client.getLaunchVariant?.());
+            if (strategy.workspaceIndexing !== true)
+              continue;
+            try {
+              const snapshot = {
+                serverId: entry.client.serverId,
+                root: entry.client.root,
+                operationSupport: entry.client.getOperationSupport(),
+                workspaceDiagnosticsSupport: entry.client.getWorkspaceDiagnosticsSupport(),
+                customServer: entry.info.custom,
+                diagnosticsPublished: this.state.diagnosticsPublished.has(entry.info.id),
+                diagnosticsUnsupported: this.state.diagnosticsUnsupported.has(entry.info.id),
+                advertisedCommands: entry.client.getAdvertisedCommands(),
+                rawCapabilityKeys: entry.client.getRawCapabilityKeys?.() ?? [],
+                launchVariant: entry.client.getLaunchVariant?.()
+              };
+              if (classifyServerWaitTier(entry.client.serverId, snapshot) === "tier3-silent") {
+                silentCleanWarmupServers.add(entry.client.serverId);
+              }
+            } catch {}
+          }
+        }
+        const perServerTimeout = (serverId) => {
+          const launchVariant = spawned.find((entry) => entry.client.serverId === serverId)?.client.getLaunchVariant?.();
+          const strategy = getStrategy(serverId, launchVariant);
+          let strategyWait = strategy.aggregateWaitMs;
+          const isFirstTouch = sweepFirstTouch.get(serverId);
+          if (isFirstTouch === false && strategy.workspaceIndexing) {
+            strategyWait = strategy.workspaceIndexingWarmWaitMs ?? Math.min(300, strategyWait);
+          }
+          if (callerCap !== undefined) {
+            if (options.warmupOverride) {
+              if (silentCleanWarmupServers.has(serverId)) {
+                return Math.min(callerCap, strategyWait > 0 ? strategyWait : callerCap);
+              }
+              if ((options.warmupAttempt ?? 1) > 1) {
+                return Math.min(callerCap, strategyWait > 0 ? strategyWait : callerCap);
+              }
+              return Math.max(callerCap, strategyWait > 0 ? strategyWait : 0);
+            }
+            return Math.min(callerCap, strategyWait > 0 ? strategyWait : callerCap);
+          }
+          return strategyWait > 0 ? strategyWait : modeFloor;
+        };
+        let timeoutFor;
+        if (envWait !== undefined) {
+          timeoutFor = () => envWait;
+        } else if (!useAllClients && spawned.length === 1 || clientScope === "with-auxiliary" || clientScope === "all") {
+          timeoutFor = perServerTimeout;
+        } else {
+          timeoutFor = () => callerCap ?? modeFloor;
+        }
+        const timeoutMs = Math.max(0, ...spawned.filter((e) => !deferredResyncServerIds.has(e.info.id)).map((e) => timeoutFor(e.client.serverId)));
+        if (!notifyWriteTimedOut && (options.collectDiagnostics === true || isWarmupTouch) && clientScope === "primary" && spawned.length === 1 && spawned[0].client.serverId === "typescript" && getStrategy(spawned[0].client.serverId, spawned[0].client.getLaunchVariant?.()).silentOnClean === true) {
+          try {
+            const snapshots = await this.getCapabilitySnapshots(filePath);
+            tsserverSyncEligible = classifyCascadeWaitTier(this, filePath, snapshots) === "tier3-silent";
+          } catch {}
+        }
+        const waitStartedAt = Date.now();
+        const hasTouchAuxiliaries = clientScope === "with-auxiliary" && options.collectDiagnostics === true && spawned.some((e) => isAuxiliary(e.info));
+        if (spawned.some((entry) => entry.info.custom === true)) {
+          try {
+            const snapshotHook = options.hook ?? "tool_result_edit";
+            const snapshotBudget = hookDeadlineAt === undefined ? HOOK_WALL_BUDGET_MS.tool_result_edit : Math.max(0, hookDeadlineAt - Date.now());
+            const snapshots = await bounded(this.getCapabilitySnapshots(filePath), {
+              ms: snapshotBudget,
+              signal: getAmbientAbortSignal(),
+              shutdownSignal: this.shutdownController.signal,
+              hook: snapshotHook,
+              label: `getCapabilitySnapshots:${filePath}`
+            });
+            if (snapshots !== undefined) {
+              diagnosticsUnsupportedServerIds = spawned.filter((entry) => classifyServerWaitTier(entry.info.id, snapshots.find((s) => s.serverId === entry.info.id)) === "diagnostics-unsupported").map((entry) => entry.info.id);
+            }
+          } catch {}
+        }
+        let pressureSnapshots = [];
+        if (shouldPreferPullOnlyDiagnostics()) {
+          try {
+            pressureSnapshots = await this.getCapabilitySnapshots(filePath);
+          } catch {}
+        }
+        const configuredAuxCeilingMs = readEnvAuxGraceMs();
+        const perServerDeclaredTimeouts = spawned.map((entry) => timeoutFor(entry.client.serverId));
+        const perServerWaitTimeouts = spawned.map((entry, entryIndex) => {
+          const declaredServerTimeout = perServerDeclaredTimeouts[entryIndex];
+          const observedSpawnMs = getSuccessfulLspSpawnDurationMs(entry.client.serverId);
+          return hasTouchAuxiliaries && isAuxiliary(entry.info) && coldAuxiliaryServerIds.has(entry.client.serverId) && (configuredAuxCeilingMs !== undefined || observedSpawnMs !== undefined && observedSpawnMs > 0) ? auxWaitBudgetMs(entry.client.serverId, true, configuredAuxCeilingMs, declaredServerTimeout) : perServerDeclaredTimeouts[entryIndex];
+        });
+        const firstContactCutOffServerIds = new Set;
+        const firstContactErroredServerIds = new Set;
+        const answeredForThisTouch = (entry) => {
+          const baseline = diagnosticBaselines.get(entry.client);
+          const currentPathVersion = readPathVersion(entry.client);
+          if (auxiliaryPublicationEvidence({
+            bindingMatchesContent: false,
+            baseline,
+            currentPathVersion
+          })) {
+            return true;
+          }
+          try {
+            return entry.client.getAllDiagnostics?.().has(normalizedPath) === true;
+          } catch {
+            return false;
+          }
+        };
+        const perServerRaceBudgets = spawned.map((entry, entryIndex) => {
+          return hasTouchAuxiliaries && isAuxiliary(entry.info) ? auxWaitBudgetMs(entry.client.serverId, coldAuxiliaryServerIds.has(entry.client.serverId), configuredAuxCeilingMs, perServerDeclaredTimeouts[entryIndex]) : perServerDeclaredTimeouts[entryIndex];
+        });
+        const perServerWaits = spawned.map((entry, entryIndex) => {
+          if (hasTouchAuxiliaries && isAuxiliary(entry.info) && this.isAuxiliaryWaitDemoted(entry.info.id, entry.client.root ?? filePath)) {
+            return Promise.resolve(undefined);
+          }
+          if (this.state.diagnosticsUnsupported.has(entry.info.id) || diagnosticsUnsupportedServerIds.includes(entry.info.id)) {
+            return Promise.resolve(undefined);
+          }
+          if (deferredResyncServerIds.has(entry.info.id)) {
+            return Promise.resolve(undefined);
+          }
+          const serverTimeout = perServerWaitTimeouts[entryIndex];
+          const baseline = diagnosticBaselines.get(entry.client);
+          const pullOnly = classifyServerWaitTier(entry.client.serverId, pressureSnapshots.find((snapshot) => snapshot.serverId === entry.client.serverId)) === "pull-capable";
+          const waitForDiagnostics = () => !notifySkippedServerIds.has(entry.info.id) && Number.isFinite(baseline) ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
+            minVersion: baseline,
+            ...pullOnly && { pullOnly: true },
+            ...isWarmupTouch && { pullSettleSource: "pull-warmup" }
+          }) : pullOnly ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
+            pullOnly: true,
+            ...isWarmupTouch && { pullSettleSource: "pull-warmup" }
+          }) : isWarmupTouch ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
+            pullSettleSource: "pull-warmup"
+          }) : entry.client.waitForDiagnostics(filePath, serverTimeout);
+          const firstContact = entry.info.custom === true && !this.state.diagnosticsPublished.has(entry.info.id) && !this.state.diagnosticsUnsupported.has(entry.info.id) && entry.client.getWorkspaceDiagnosticsSupport().mode !== "pull";
+          if (!firstContact)
+            return waitForDiagnostics().catch(() => {
+              return;
+            });
+          let shared = this.firstContactWaits.get(entry.info.id);
+          if (!shared) {
+            let removeShutdownListener;
+            const shutdown = new Promise((resolve) => {
+              const onShutdown = () => resolve("shutdown");
+              if (this.shutdownController.signal.aborted) {
+                onShutdown();
+                return;
+              }
+              this.shutdownController.signal.addEventListener("abort", onShutdown, {
+                once: true
+              });
+              removeShutdownListener = () => this.shutdownController.signal.removeEventListener("abort", onShutdown);
+            });
+            const probe = Promise.race([
+              waitForDiagnostics().then(() => "completed", () => "errored"),
+              shutdown
+            ]);
+            const completed = withDeadline(probe, {
+              ms: serverTimeout,
+              onTimeout: "undefined"
+            });
+            shared = completed.then((outcome) => {
+              if (outcome === "errored" || outcome === "shutdown") {
+                return "errored";
+              }
+              if (answeredForThisTouch(entry))
+                return "answered";
+              this.state.diagnosticsUnsupported.add(entry.info.id);
+              recordDegradationOnce({
+                kind: "lsp-diagnostics-unsupported",
+                subject: entry.info.id,
+                reason: "custom server has no pull provider and no publish evidence after first contact wait"
+              });
+              return "silent";
+            }).catch(() => "errored").finally(() => {
+              removeShutdownListener?.();
+              if (this.firstContactWaits.get(entry.info.id) === shared) {
+                this.firstContactWaits.delete(entry.info.id);
+              }
+            });
+            this.firstContactWaits.set(entry.info.id, shared);
+          }
+          const callerWait = hookDeadlineAt === undefined ? shared : withDeadline(shared, {
+            ms: Math.max(0, hookDeadlineAt - Date.now()),
+            onTimeout: "undefined"
+          });
+          return callerWait.then((outcome) => {
+            if (outcome === undefined) {
+              firstContactCutOffServerIds.add(entry.info.id);
+            } else if (outcome === "errored") {
+              firstContactErroredServerIds.add(entry.info.id);
+            }
+            return;
+          });
+        });
+        let pushWaitSettled = false;
+        const pushWait = hasTouchAuxiliaries ? (() => {
+          const primaryWaits = perServerWaits.filter((_, i) => !isAuxiliary(spawned[i].info));
+          const auxWaits = perServerWaits.map((p, i) => isAuxiliary(spawned[i].info) ? {
+            promise: p,
+            serverId: spawned[i].info.id,
+            client: spawned[i].client,
+            baseline: diagnosticBaselines.get(spawned[i].client),
+            budgetMs: perServerRaceBudgets[i],
+            demoted: this.isAuxiliaryWaitDemoted(spawned[i].info.id, spawned[i].client.root ?? filePath),
+            root: spawned[i].client.root ?? filePath
+          } : null).filter((x) => x !== null);
+          return Promise.all(primaryWaits).then(async () => {
+            if (auxWaits.length === 0)
+              return;
+            const auxWaitStartedAt = Date.now();
+            const outcomes = await Promise.all(auxWaits.map(async (aux) => {
+              const { budgetMs } = aux;
+              if (aux.demoted) {
+                return {
+                  serverId: aux.serverId,
+                  outcome: deferredResyncServerIds.has(aux.serverId) ? "deferred" : "demoted",
+                  publishedThisContent: auxiliaryPublicationEvidence({
+                    bindingMatchesContent: auxCoversThisContent(aux.serverId),
+                    baseline: aux.baseline,
+                    currentPathVersion: readPathVersion(aux.client)
+                  }),
+                  budgetMs,
+                  elapsedMs: 0,
+                  elapsedSinceNotifyMs: 0
+                };
+              }
+              let timer;
+              const timeout = new Promise((resolve) => {
+                timer = setTimeout(() => resolve(false), budgetMs);
+                if (typeof timer === "object" && "unref" in timer) {
+                  timer.unref?.();
+                }
+              });
+              const raced = await Promise.race([
+                aux.promise.then(() => true),
+                timeout
+              ]);
+              if (timer)
+                clearTimeout(timer);
+              const currentPathVersion = readPathVersion(aux.client);
+              const publishedEvidence = auxiliaryPublicationEvidence({
+                bindingMatchesContent: false,
+                baseline: aux.baseline,
+                currentPathVersion,
+                raced
+              });
+              const outcome = deferredResyncServerIds.has(aux.serverId) ? "deferred" : !raced ? "cut_off" : publishedEvidence ? "answered" : "silent";
+              const elapsedMs = Date.now() - auxWaitStartedAt;
+              if (outcome !== "deferred") {
+                this.noteAuxiliaryWait(`${aux.serverId}:${normalizeMapKey(aux.root)}`, budgetMs, elapsedMs);
+              }
+              return {
+                serverId: aux.serverId,
+                outcome,
+                publishedThisContent: auxCoversThisContent(aux.serverId),
+                budgetMs,
+                elapsedMs,
+                elapsedSinceNotifyMs: Date.now() - waitStartedAt
+              };
+            }));
+            const unfinished = outcomes.filter((outcome) => outcome.outcome === "cut_off").map((outcome) => outcome.serverId);
+            if (unfinished.length > 0)
+              auxCutOffServerIds = unfinished;
+            const uncovered = auxiliaryCoverageGap(outcomes);
+            if (uncovered.length > 0)
+              auxUnconfirmedServerIds = uncovered;
+            const collectLaterServerIds = outcomes.filter((o) => !o.publishedThisContent && (o.outcome === "cut_off" || o.outcome === "silent" || o.outcome === "demoted") && !(o.serverId === "ast-grep" && napiFallbackCoveredSince(filePath, startedAt))).map((o) => o.serverId);
+            if (collectLaterServerIds.length > 0) {
+              lateDeliveryServerIds = collectLaterServerIds;
+              for (const serverId of collectLaterServerIds) {
+                markPendingAuxiliaryCoverage(filePath, [serverId], startedAt, undefined, undefined, captureAuxPublicationBacklog(auxWaits.find((aux) => aux.serverId === serverId)?.client, filePath));
+              }
+            }
+            logLatency({
+              type: "phase",
+              phase: "lsp_aux_wait_outcome",
+              filePath: normalizedPath,
+              durationMs: Date.now() - auxWaitStartedAt,
+              metadata: { clientScope, waitShape: "aux_grace", outcomes }
+            });
+          });
+        })() : Promise.all(perServerWaits).then(() => {});
+        const markPushWaitSettled = () => {
+          pushWaitSettled = true;
+        };
+        pushWait.then(markPushWaitSettled, markPushWaitSettled);
+        if (tsserverSyncEligible) {
+          const graceMs = readTsserverSyncGraceMs();
+          const primaryClient = spawned[0].client;
+          const syncRacer = (async () => {
+            await new Promise((resolve) => {
+              const timer = setTimeout(resolve, graceMs);
+              timer.unref?.();
+            });
+            const publishedAt = primaryClient.getAllDiagnostics?.().get(normalizedPath)?.ts;
+            if (pushWaitSettled || publishedAt !== undefined && publishedAt > markedAtMs) {
+              return new Promise(() => {});
+            }
+            try {
+              const result = await attemptTsserverSyncDiagnostics(filePath, tsserverSyncChannel(primaryClient));
+              if (result === undefined || pushWaitSettled) {
+                return new Promise(() => {});
+              }
+              return result;
+            } catch {
+              return new Promise(() => {});
+            }
+          })();
+          const raceOutcome = await Promise.race([
+            pushWait.then(() => {
+              return;
+            }),
+            syncRacer
+          ]);
+          if (raceOutcome !== undefined) {
+            tsserverSyncConfirmed = raceOutcome;
+          }
+        } else {
+          await pushWait;
+        }
+        const waitedMs = Date.now() - waitStartedAt;
+        const firstContactCustomServerIds = spawned.filter((entry) => entry.info.custom === true && !this.state.diagnosticsPublished.has(entry.info.id) && !this.state.diagnosticsUnsupported.has(entry.info.id) && !firstContactCutOffServerIds.has(entry.info.id) && !firstContactErroredServerIds.has(entry.info.id) && entry.client.getWorkspaceDiagnosticsSupport().mode !== "pull").map((entry) => entry.info.id);
+        for (const serverId of firstContactCustomServerIds) {
+          const entry = spawned.find((candidate) => candidate.info.id === serverId);
+          if (!entry || answeredForThisTouch(entry))
+            continue;
+          this.state.diagnosticsUnsupported.add(serverId);
+          diagnosticsUnsupportedServerIds.push(serverId);
+          recordDegradationOnce({
+            kind: "lsp-diagnostics-unsupported",
+            subject: serverId,
+            reason: "custom server has no pull provider and no publish evidence after first contact wait"
+          });
+        }
+        for (const entry of spawned) {
+          if (entry.info.custom === true && this.state.diagnosticsUnsupported.has(entry.info.id)) {
+            diagnosticsUnsupportedServerIds.push(entry.info.id);
+          }
+        }
+        diagnosticsUnsupportedServerIds = [
+          ...new Set(diagnosticsUnsupportedServerIds)
+        ];
+        if (!hasTouchAuxiliaries && options.collectDiagnostics === true) {
+          const auxEntries = spawned.filter((entry) => isAuxiliary(entry.info));
+          if (auxEntries.length > 0) {
+            const outcomes = auxEntries.map((entry) => {
+              const baseline = diagnosticBaselines.get(entry.client);
+              const currentPathVersion = readPathVersion(entry.client);
+              const publishedEvidence = auxiliaryPublicationEvidence({
+                bindingMatchesContent: false,
+                baseline,
+                currentPathVersion
+              });
+              return {
+                serverId: entry.info.id,
+                outcome: deferredResyncServerIds.has(entry.info.id) ? "deferred" : publishedEvidence ? "answered" : "silent",
+                publishedThisContent: auxCoversThisContent(entry.info.id),
+                budgetMs: timeoutFor(entry.client.serverId),
+                elapsedMs: waitedMs,
+                elapsedSinceNotifyMs: waitedMs
+              };
+            });
+            const uncovered = auxiliaryCoverageGap(outcomes);
+            if (uncovered.length > 0)
+              auxUnconfirmedServerIds = uncovered;
+            logLatency({
+              type: "phase",
+              phase: "lsp_aux_wait_outcome",
+              filePath: normalizedPath,
+              durationMs: waitedMs,
+              metadata: { clientScope, waitShape: "aggregate", outcomes }
+            });
+          }
+        }
+        if (tsserverSyncConfirmed !== undefined) {
+          logLatency({
+            type: "phase",
+            phase: "lsp_tsserver_sync_confirm",
+            filePath: normalizedPath,
+            durationMs: waitedMs,
+            metadata: {
+              source,
+              serverId: spawned[0]?.client.serverId,
+              clientScope,
+              diagnosticsMode,
+              mode: "race",
+              confirmedDiagnosticCount: tsserverSyncConfirmed.length,
+              budgetMs: timeoutMs,
+              savedVsBudgetMs: Math.max(0, timeoutMs - waitedMs)
+            }
+          });
+        } else if (waitedMs + 20 >= timeoutMs || firstContactErroredServerIds.size > 0) {
+          const waited = spawned.filter((entry) => !deferredResyncServerIds.has(entry.info.id) && !diagnosticsUnsupportedServerIds.includes(entry.info.id));
+          const unanswered = waited.filter((entry) => !answeredForThisTouch(entry));
+          diagnosticsUnansweredServerIds = unanswered.map((e) => e.info.id);
+          diagnosticsUnansweredPrimaryServerIds = unanswered.filter((entry) => !isAuxiliary(entry.info)).map((e) => e.info.id);
+          const hasWaitedPrimary = waited.some((entry) => !isAuxiliary(entry.info));
+          const hasUnsupportedPrimary = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && !isAuxiliary(entry.info)));
+          diagnosticsTimedOut = !hasWaitedPrimary && !hasUnsupportedPrimary || diagnosticsUnansweredPrimaryServerIds.length > 0;
+          for (const entry of unanswered) {
+            incrementDegradationCount({
+              kind: "lsp-diagnostics-timeout",
+              subject: entry.info.id,
+              reason: "diagnostics wait timed out"
+            });
+          }
+          logLatency({
+            type: "phase",
+            phase: "lsp_diagnostics_timeout",
+            filePath: normalizedPath,
+            durationMs: waitedMs,
+            metadata: {
+              source,
+              serverIds: spawned.map((e) => e.info.id),
+              clientScope,
+              diagnosticsMode,
+              timeoutMs,
+              unansweredServerIds: diagnosticsUnansweredServerIds,
+              attributedToPrimary: diagnosticsTimedOut
+            }
+          });
+        }
+        if (diagnosticsTimedOut && !primaryNotifyWriteTimedOut && clientScope === "all") {
+          try {
+            const outstanding = primaryEntries.filter((entry) => !notifyWriteTimedOutServerIds.includes(entry.info.id) && !entry.client.getAllDiagnostics().has(normalizedPath));
+            if (outstanding.length > 0) {
+              const snapshots = await this.getCapabilitySnapshots(filePath);
+              const allSilent = outstanding.every((entry) => classifyServerWaitTier(entry.client.serverId, snapshots.find((s) => s.serverId === entry.client.serverId)) === "tier3-silent");
+              if (allSilent) {
+                const liveness = await Promise.all(outstanding.map((entry) => (entry.client.pingLiveness?.() ?? Promise.resolve(true)).catch(() => false)));
+                if (liveness.every(Boolean)) {
+                  diagnosticsTimedOut = false;
+                  retractPrimaryTimeoutAttribution();
+                  logLatency({
+                    type: "phase",
+                    phase: "lsp_silent_clean_confirm",
+                    filePath: normalizedPath,
+                    durationMs: Date.now() - startedAt,
+                    metadata: {
+                      source,
+                      clientScope,
+                      diagnosticsMode,
+                      aggregate: true,
+                      serverIds: outstanding.map((entry) => entry.client.serverId)
+                    }
+                  });
+                }
+              }
+            }
+          } catch {}
+        }
+      }
+      const auxCoveredAtMerge = new Set(spawned.filter((entry) => auxCoversThisContent(entry.info.id)).map((entry) => entry.info.id));
+      const uncoveredDeferredServerIds = notifyDeferredServerIds.filter((serverId) => !auxCoveredAtMerge.has(serverId));
+      const staleWriteAuxiliaryServerIds = spawned.filter((entry) => isAuxiliary(entry.info) && notifyWriteTimedOutServerIds.includes(entry.info.id) && !auxCoveredAtMerge.has(entry.info.id)).map((entry) => entry.info.id);
+      const droppedAuxiliaryServerIds = new Set([
+        ...uncoveredDeferredServerIds,
+        ...staleWriteAuxiliaryServerIds
+      ]);
+      let collected = options.collectDiagnostics ? tsserverSyncConfirmed !== undefined ? mergeLspDiagnostics(attributeDiagnostics(spawned[0]?.info.id ?? "unknown", tsserverSyncConfirmed)) : mergeLspDiagnostics([
+        ...spawned.flatMap((entry) => droppedAuxiliaryServerIds.has(entry.info.id) ? [] : attributeDiagnostics(entry.info.id, entry.client.getDiagnostics(filePath))),
+        ...carriedAuxiliary.flatMap((entry) => attributeDiagnostics(entry.serverId, entry.diags))
+      ]) : undefined;
+      let syncConfirmed = tsserverSyncConfirmed !== undefined;
+      const syncClient = spawned[0]?.client;
+      if (diagnosticsTimedOut && tsserverSyncEligible && syncClient !== undefined && collected !== undefined && collected.length === 0) {
+        try {
+          const syncResult = await attemptTsserverSyncDiagnostics(filePath, tsserverSyncChannel(syncClient));
+          if (syncResult !== undefined) {
+            diagnosticsTimedOut = false;
+            retractPrimaryTimeoutAttribution();
+            syncConfirmed = true;
+            collected = syncResult.length > 0 ? mergeLspDiagnostics(attributeDiagnostics(spawned[0]?.info.id ?? "unknown", syncResult)) : [];
+            logLatency({
+              type: "phase",
+              phase: "lsp_tsserver_sync_confirm",
+              filePath: normalizedPath,
+              durationMs: Date.now() - startedAt,
+              metadata: {
+                source,
+                clientScope,
+                diagnosticsMode,
+                mode: "end-of-wait",
+                confirmedDiagnosticCount: collected.length
+              }
+            });
+          }
+        } catch {}
+      }
+      if (diagnosticsTimedOut && !primaryNotifyWriteTimedOut && (!tsserverSyncEligible || isWarmupTouch) && clientScope === "primary" && spawned.length === 1 && getStrategy(spawned[0].client.serverId, spawned[0].client.getLaunchVariant?.()).silentOnClean === true) {
+        try {
+          const snapshots = await this.getCapabilitySnapshots(filePath);
+          if (classifyCascadeWaitTier(this, filePath, snapshots) === "tier3-silent") {
+            const alive = await (spawned[0].client.pingLiveness?.() ?? Promise.resolve(true)).catch(() => false);
+            if (alive) {
+              diagnosticsTimedOut = false;
+              retractPrimaryTimeoutAttribution();
+              if (collected !== undefined)
+                collected = mergeLspDiagnostics([]);
+              logLatency({
+                type: "phase",
+                phase: "lsp_silent_clean_confirm",
+                filePath: normalizedPath,
+                durationMs: Date.now() - startedAt,
+                metadata: {
+                  source,
+                  clientScope,
+                  diagnosticsMode,
+                  serverId: spawned[0].client.serverId
+                }
+              });
+            }
+          }
+        } catch {}
+      }
+      const verdict = resolveTouchVerdict({
+        primaryNotifyWriteTimedOutServerIds,
+        diagnosticsTimedOut,
+        diagnosticsUnansweredServerIds: diagnosticsUnansweredPrimaryServerIds
+      });
+      const inconclusive = verdict.inconclusive;
+      const brokenSkippedServerIds = collected !== undefined ? await this.brokenSkippedAuxiliaryServerIds(filePath, clientScope, options, spawned) : [];
+      const auxNoAnswerServerIds = spawned.filter((entry) => isAuxiliary(entry.info) && (diagnosticsUnansweredServerIds.includes(entry.info.id) || notifyWriteTimedOutServerIds.includes(entry.info.id)) && !auxCoveredAtMerge.has(entry.info.id)).map((entry) => entry.info.id);
+      const unconfirmedServerIds = [
+        ...new Set([
+          ...auxUnconfirmedServerIds ?? [],
+          ...auxNoAnswerServerIds,
+          ...uncoveredDeferredServerIds,
+          ...brokenSkippedServerIds
+        ])
+      ].filter((serverId) => !auxCoveredAtMerge.has(serverId));
+      const coverageGap = unconfirmedServerIds.length > 0;
+      if (brokenSkippedServerIds.length > 0 || uncoveredDeferredServerIds.length > 0 || auxNoAnswerServerIds.length > 0) {
+        for (const serverId of unconfirmedServerIds) {
+          const reasons = [
+            brokenSkippedServerIds.includes(serverId) && "breaker skip",
+            uncoveredDeferredServerIds.includes(serverId) && "deferred resync",
+            auxNoAnswerServerIds.includes(serverId) && "no diagnostics answer"
+          ].filter(Boolean);
+          incrementDegradationCount({
+            kind: "lsp-scanner-coverage-gap",
+            subject: `${serverId}:${normalizedPath}`,
+            reason: reasons.join(", ") || "scanner coverage gap"
+          });
+        }
+        emitBounded("lsp_scanner_coverage_gap", `${source}:${normalizedPath}`, {
+          filePath: normalizedPath,
+          durationMs: Date.now() - startedAt,
+          metadata: {
+            source,
+            clientScope,
+            ...brokenSkippedServerIds.length > 0 && {
+              brokenSkippedServerIds
+            },
+            ...uncoveredDeferredServerIds.length > 0 && {
+              deferredResyncServerIds: uncoveredDeferredServerIds
+            },
+            ...auxNoAnswerServerIds.length > 0 && { auxNoAnswerServerIds }
+          }
+        });
+      }
+      const notifyTimedOutServerIds = new Set(notifyWriteTimedOutServerIds);
+      const uncoveredServerIds = new Set(unconfirmedServerIds);
+      if (diagnosticsMode !== "none" && !diagnosticsTimedOut) {
+        for (const entry of spawned) {
+          if (notifyTimedOutServerIds.has(entry.info.id))
+            continue;
+          if (uncoveredServerIds.has(entry.info.id))
+            continue;
+          const key = await this.demonstratedReadyKeyFor(entry.info, filePath);
+          if (key && this.state.clients.get(key) === entry.client)
+            this.markDemonstratedReadyKey(key);
+        }
+      }
+      if (collected !== undefined && !inconclusive && !coverageGap) {
+        const normalizedKey = normalizeMapKey(filePath);
+        if (collected.length > 0) {
+          this.lastKnownDiagnostics.set(normalizedKey, collected);
+          this.lastKnownContentHash.set(normalizedKey, this.hashContent(content));
+        } else {
+          this.lastKnownDiagnostics.delete(normalizedKey);
+          this.lastKnownContentHash.delete(normalizedKey);
+        }
+      }
+      const result = { diags: collected ?? [] };
+      const primaryDiagnosticsUnsupported = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && !isAuxiliary(entry.info)));
+      if (diagnosticsUnsupportedServerIds.length > 0) {
+        result.diagnosticsUnsupportedServerIds = diagnosticsUnsupportedServerIds;
+      }
+      if (collected !== undefined && inconclusive) {
+        result.inconclusive = true;
+        if (verdict.inconclusiveServerIds) {
+          result.inconclusiveServerIds = verdict.inconclusiveServerIds;
+        }
+        result.inconclusiveReason = verdict.inconclusiveReason;
+      } else if (collected !== undefined && primaryDiagnosticsUnsupported) {
+        if (unconfirmedServerIds.length > 0) {
+          result.unconfirmedServerIds = [...unconfirmedServerIds];
+        }
+      } else if (collected !== undefined && coverageGap) {
+        result.confirmation = "partial";
+        result.unconfirmedServerIds = [...unconfirmedServerIds];
+      } else if (collected !== undefined && !primaryDiagnosticsUnsupported) {
+        result.confirmation = "confirmed";
+      }
+      let binding;
+      if (collected !== undefined) {
+        binding = syncConfirmed ? { boundToCurrentDisk: "unknown" } : this.mergeBinding(filePath, [
+          ...spawned.filter((entry) => !droppedAuxiliaryServerIds.has(entry.info.id)).map((entry) => entry.client.getDiagnosticBinding?.(filePath)),
+          ...carriedAuxiliary.map((entry) => entry.binding)
+        ]);
+        result.binding = binding;
+      }
+      const lateDeliveryPending = unconfirmedServerIds.filter((serverId) => (lateDeliveryServerIds ?? []).includes(serverId));
+      if (lateDeliveryPending.length > 0) {
+        result.deferredServerIds = lateDeliveryPending;
+      }
+      if (supersededServerIds.length > 0) {
+        result.supersededServerIds = supersededServerIds;
+      }
+      logLatency({
+        type: "phase",
+        phase: "lsp_touch_file",
+        filePath: normalizedPath,
+        durationMs: Date.now() - startedAt,
+        metadata: {
+          serverCountReady: spawned.length,
+          clientScope,
+          diagnosticsMode,
+          source,
+          failureKind: "success",
+          collectedDiagnostics: collected?.length,
+          ...binding !== undefined && {
+            bindingState: bindingStateLabel(binding.boundToCurrentDisk)
+          },
+          notifySkipped,
+          notifyWriteTimedOut,
+          ...notifyWriteTimedOutServerIds.length > 0 && {
+            notifyWriteTimedOutServerIds
+          },
+          ...supersededServerIds.length > 0 && { supersededServerIds },
+          diagnosticsTimedOut,
+          inconclusive,
+          ...verdict.inconclusiveServerIds && {
+            inconclusiveServerIds: verdict.inconclusiveServerIds
+          },
+          ...verdict.inconclusiveReason && {
+            inconclusiveReason: verdict.inconclusiveReason
+          },
+          ...result.confirmation !== undefined && {
+            confirmation: result.confirmation
+          },
+          ...auxCutOffServerIds !== undefined && { auxCutOffServerIds },
+          ...auxUnconfirmedServerIds !== undefined && {
+            auxUnconfirmedServerIds
+          },
+          ...brokenSkippedServerIds.length > 0 && { brokenSkippedServerIds },
+          ...uncoveredDeferredServerIds.length > 0 && {
+            deferredResyncServerIds: uncoveredDeferredServerIds
+          },
+          ...lateDeliveryPending.length > 0 && {
+            lateDeliveryServerIds: lateDeliveryPending
+          },
+          ...auxNoAnswerServerIds.length > 0 && { auxNoAnswerServerIds }
+        }
+      });
+      return result;
+    } finally {
+      for (const lease of leaseKeys)
+        this.releaseClientLease(lease.key, lease.server);
+    }
+  }
+  async findOutsideProjectRoot(filePath) {
+    if (!this.fileIsOutsideRegisteredRoots(filePath))
+      return;
+    if (this.analysisRootModeForFile(filePath) === "adopted")
+      return;
+    const candidates = await Promise.all(getServersForFileWithConfig(filePath).map((server) => server.root(filePath)));
+    return candidates.find((candidate) => Boolean(candidate));
+  }
+  recordOutsideRootDecline(filePath, nearestRoot, operation) {
+    const root = normalizeMapKey(nearestRoot);
+    const sessionRoots = getSessionRootsForTelemetry().map((sessionRoot) => normalizeMapKey(sessionRoot)).join(", ");
+    emitBounded("lsp_capability_skip", root, {
+      filePath: normalizeMapKey(filePath),
+      durationMs: 0,
+      metadata: {
+        operation,
+        nearestMarkerRoot: root,
+        sessionRoots,
+        identity: root
+      }
+    }, {
+      ledgerKind: "lsp-capability-skip",
+      risingEdgePer: "identity",
+      reason: `declined LSP root outside session cwd: ${root}`
+    });
+  }
+  getDiagnosticsHealth(filePath) {
+    return this.lastDiagnosticsHealth.get(normalizeMapKey(filePath));
+  }
+  getLastKnownDiagnostics(filePath, expectedContentHash) {
+    const normalizedKey = normalizeMapKey(filePath);
+    if (expectedContentHash !== undefined) {
+      const knownHash = this.lastKnownContentHash.get(normalizedKey);
+      if (knownHash === undefined || knownHash !== expectedContentHash) {
+        return;
+      }
+    }
+    return this.lastKnownDiagnostics.get(normalizedKey);
+  }
+  async getDiagnostics(filePath, diagnosticsMode = "full") {
+    const normalizedPath = normalizeMapKey(filePath);
+    const outsideRoot = await this.findOutsideProjectRoot(filePath);
+    if (outsideRoot) {
+      this.recordOutsideRootDecline(filePath, outsideRoot, "getDiagnostics");
+      return [];
+    }
+    if (this.checkDestroyed()) {
+      this.lastDiagnosticsHealth.set(normalizedPath, {
+        health: "destroyed",
+        failureKind: "destroyed",
+        serverCountAttempted: 0,
+        serverCountReady: 0,
+        candidateServerIds: getServersForFileWithConfig(filePath).map((s) => s.id),
+        mergedCount: 0,
+        dedupDroppedCount: 0,
+        checkedAt: new Date().toISOString()
+      });
+      return [];
+    }
+    const startedAt = Date.now();
+    const candidateServerIds = getServersForFileWithConfig(filePath).map((s) => s.id);
+    const { clients: spawned, serverCountAttempted } = await this.getClientsForFile(filePath);
+    if (spawned.length === 0) {
+      const stale = this.lastKnownDiagnostics.get(normalizedPath);
+      const failureKind = stale?.length ? "no_clients_stale" : "no_clients";
+      this.lastDiagnosticsHealth.set(normalizedPath, {
+        health: failureKind,
+        failureKind,
+        serverCountAttempted,
+        serverCountReady: 0,
+        candidateServerIds,
+        mergedCount: stale?.length ?? 0,
+        dedupDroppedCount: 0,
+        checkedAt: new Date().toISOString()
+      });
+      logLatency({
+        type: "phase",
+        phase: "lsp_diagnostics_aggregate",
+        filePath: normalizedPath,
+        durationMs: Date.now() - startedAt,
+        metadata: {
+          serverCountAttempted,
+          serverCountReady: 0,
+          mergedCount: stale?.length ?? 0,
+          dedupDroppedCount: 0,
+          failureKind,
+          health: failureKind,
+          servers: []
+        }
+      });
+      return stale ?? [];
+    }
+    const clientWaits = spawned.map(async (entry) => {
+      const waitStart = Date.now();
+      const launchVariant = entry.client.getLaunchVariant?.();
+      const strategy = getStrategy(entry.info.id, launchVariant);
+      await entry.client.waitForDiagnostics(filePath, strategy.aggregateWaitMs);
+      let diagnostics = entry.client.getDiagnostics(filePath);
+      const firstWaitMs = Date.now() - waitStart;
+      if (strategy.expectSemanticSecondPush && diagnostics.length === 0 && firstWaitMs < DIAGNOSTICS_SEMANTIC_SETTLE_THRESHOLD_MS) {
+        await entry.client.waitForDiagnostics(filePath, DIAGNOSTICS_SEMANTIC_SETTLE_WAIT_MS);
+        diagnostics = entry.client.getDiagnostics(filePath);
+      }
+      return {
+        serverId: entry.info.id,
+        launchVariant,
+        waitMs: Date.now() - waitStart,
+        diagnosticCount: diagnostics.length,
+        diagnostics
+      };
+    });
+    const graceMs = diagnosticsMode === "document" ? 0 : EARLY_UNBLOCK_GRACE_MS;
+    const diagDescriptors = spawned.map((entry) => {
+      if (!isAuxiliary(entry.info))
+        return { role: entry.info.role };
+      const strategy = getStrategy(entry.info.id, entry.client.getLaunchVariant?.());
+      return { role: entry.info.role, budgetMs: strategy.aggregateWaitMs };
+    });
+    const perServer = await raceToCompletion(clientWaits, (results) => results.some((r) => r.diagnosticCount > 0 || getStrategy(r.serverId, r.launchVariant).seedFirstPush), {
+      timeoutMs: Math.max(...spawned.map((entry) => getStrategy(entry.info.id, entry.client.getLaunchVariant?.()).aggregateWaitMs)),
+      graceMs,
+      descriptors: diagDescriptors,
+      auxGraceMs: readEnvAuxGraceMs() ?? DEFAULT_AUX_GRACE_CEILING_MS
+    });
+    const earlyUnblockedCount = spawned.length - perServer.length;
+    const perServerFull = spawned.map((entry) => {
+      const found = perServer.find((r) => r.serverId === entry.info.id);
+      return found ?? {
+        serverId: entry.info.id,
+        launchVariant: entry.client.getLaunchVariant?.(),
+        waitMs: getStrategy(entry.info.id, entry.client.getLaunchVariant?.()).aggregateWaitMs,
+        diagnosticCount: 0,
+        diagnostics: []
+      };
+    });
+    const merged = [];
+    const seen = new Set;
+    for (const entry of perServerFull) {
+      for (const diagnostic of entry.diagnostics) {
+        const key = [
+          diagnostic.range.start.line,
+          diagnostic.range.start.character,
+          diagnostic.message
+        ].join(":");
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        merged.push({ ...diagnostic, serverId: entry.serverId });
+      }
+    }
+    const rawCount = perServerFull.reduce((sum, entry) => sum + entry.diagnosticCount, 0);
+    const serversWithDiagnostics = perServerFull.filter((entry) => entry.diagnosticCount > 0).length;
+    const failureKind = merged.length === 0 ? "ok_empty" : "success";
+    this.lastDiagnosticsHealth.set(normalizedPath, {
+      health: failureKind === "success" ? "ok" : "ok_empty",
+      failureKind,
+      serverCountAttempted,
+      serverCountReady: perServerFull.length,
+      candidateServerIds,
+      mergedCount: merged.length,
+      dedupDroppedCount: rawCount - merged.length,
+      checkedAt: new Date().toISOString()
+    });
+    logLatency({
+      type: "phase",
+      phase: "lsp_diagnostics_aggregate",
+      filePath: normalizedPath,
+      durationMs: Date.now() - startedAt,
+      metadata: {
+        serverCountAttempted,
+        serverCountReady: perServerFull.length,
+        serverCountWithDiagnostics: serversWithDiagnostics,
+        mergedCount: merged.length,
+        dedupDroppedCount: rawCount - merged.length,
+        earlyUnblockedCount,
+        diagnosticsMode,
+        failureKind,
+        health: failureKind === "success" ? "ok" : "ok_empty",
+        servers: perServerFull.map((entry) => ({
+          id: entry.serverId,
+          waitMs: entry.waitMs,
+          diagnosticCount: entry.diagnosticCount
+        }))
+      }
+    });
+    if (merged.length > 0) {
+      this.lastKnownDiagnostics.set(normalizedPath, merged);
+    } else {
+      this.lastKnownDiagnostics.delete(normalizedPath);
+    }
+    this.lastKnownContentHash.delete(normalizedPath);
+    return merged;
+  }
+  hashContent(content) {
+    return hashDiagnosticContent(content);
+  }
+  mergeBinding(filePath, stored) {
+    const verdicts = [];
+    let version;
+    let contentHash;
+    for (const entry of stored) {
+      verdicts.push(this.diskBindingCache.boundToCurrentDisk(filePath, entry ?? {}));
+      if (version === undefined && entry?.version !== undefined) {
+        version = entry.version;
+      }
+      if (contentHash === undefined && entry?.contentHash !== undefined) {
+        contentHash = entry.contentHash;
+      }
+    }
+    return {
+      version,
+      contentHash,
+      boundToCurrentDisk: composeBoundToCurrentDisk(verdicts)
+    };
+  }
+  async definition(filePath, line, character) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().definition) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for definition");
+    }
+    return spawned.client.definition(filePath, line, character);
+  }
+  async typeDefinition(filePath, line, character) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().typeDefinition) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for typeDefinition");
+    }
+    return spawned.client.typeDefinition(filePath, line, character);
+  }
+  async declaration(filePath, line, character) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().declaration) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for declaration");
+    }
+    return spawned.client.declaration(filePath, line, character);
+  }
+  async references(filePath, line, character, includeDeclaration = true) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().references) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for references");
+    }
+    return spawned.client.references(filePath, line, character, includeDeclaration);
+  }
+  async hover(filePath, line, character) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return null;
+    if (!spawned.client.getOperationSupport().hover) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for hover");
+    }
+    return spawned.client.hover(filePath, line, character);
+  }
+  async signatureHelp(filePath, line, character) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return null;
+    if (!spawned.client.getOperationSupport().signatureHelp) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for signatureHelp");
+    }
+    return spawned.client.signatureHelp(filePath, line, character);
+  }
+  async documentSymbol(filePath) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().documentSymbol) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for documentSymbol");
+    }
+    return spawned.client.documentSymbol(filePath);
+  }
+  selectWorkspaceScopeClient(predicate) {
+    let auxFallback;
+    for (const [key, client] of this.state.clients) {
+      if (!client.isAlive())
+        continue;
+      if (predicate && !predicate(client))
+        continue;
+      const separator = key.indexOf(":");
+      const serverId = separator >= 0 ? key.slice(0, separator) : key;
+      if (isAuxiliary(getServerById(serverId))) {
+        if (!auxFallback)
+          auxFallback = { client, serverId };
+        continue;
+      }
+      return { client, serverId };
+    }
+    return auxFallback;
+  }
+  async workspaceSymbol(query, filePath, attribution) {
+    if (filePath) {
+      const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+      if (!spawned)
+        return [];
+      if (!spawned.client.getOperationSupport().workspaceSymbol)
+        return [];
+      return spawned.client.workspaceSymbol(query);
+    }
+    const target = this.selectWorkspaceScopeClient((client) => client.getOperationSupport().workspaceSymbol);
+    if (!target)
+      return [];
+    if (attribution)
+      attribution.workspaceSymbol = target.serverId;
+    return target.client.workspaceSymbol(query);
+  }
+  async getAdvertisedCommands(filePath, attribution) {
+    if (filePath) {
+      const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+      if (!spawned)
+        return [];
+      return spawned.client.getAdvertisedCommands();
+    }
+    const first = this.selectWorkspaceScopeClient();
+    if (!first)
+      return [];
+    if (attribution)
+      attribution.getAdvertisedCommands = first.serverId;
+    return first.client.getAdvertisedCommands();
+  }
+  async executeCommand(filePath, command, args, mutationContext, attribution) {
+    if (filePath) {
+      const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+      if (!spawned) {
+        return { executed: false, reason: "no LSP server for file" };
+      }
+      return spawned.client.executeCommand(command, args, mutationContext);
+    }
+    const first = this.selectWorkspaceScopeClient();
+    if (!first)
+      return { executed: false, reason: "no active LSP server" };
+    if (attribution)
+      attribution.executeCommand = first.serverId;
+    return first.client.executeCommand(command, args, mutationContext);
+  }
+  async executeReadOnlyCommandOnLiveClient(filePath, command, args) {
+    if (this.checkDestroyed()) {
+      return { executed: false, reason: "lsp service destroyed" };
+    }
+    for (const server of getServersForFileWithConfig(filePath)) {
+      const root = await this.resolveServerRoot(server, filePath);
+      if (!root)
+        continue;
+      const entry = this.state.clients.get(`${server.id}:${normalizeMapKey(root)}`);
+      if (!entry?.isAlive())
+        continue;
+      const run = entry.executeReadOnlyCommand;
+      if (typeof run !== "function")
+        continue;
+      return run.call(entry, command, args);
+    }
+    return { executed: false, reason: "no live LSP server for file" };
+  }
+  async getOperationSupport(filePath, attribution) {
+    if (filePath) {
+      const spawned = await this.getClientForFile(filePath);
+      if (!spawned)
+        return null;
+      const getter = spawned.client.getOperationSupport;
+      if (typeof getter !== "function")
+        return null;
+      return getter();
+    }
+    const readable = (client) => typeof client.getOperationSupport === "function";
+    const first = this.selectWorkspaceScopeClient(readable);
+    if (!first)
+      return null;
+    const aggregate = { ...first.client.getOperationSupport() };
+    const contributors = {};
+    for (const capability of Object.keys(aggregate)) {
+      if (aggregate[capability]) {
+        contributors[capability] = first.serverId;
+        continue;
+      }
+      const supporter = this.selectWorkspaceScopeClient((client) => readable(client) && Boolean(client.getOperationSupport()[capability]));
+      if (supporter) {
+        aggregate[capability] = true;
+        contributors[capability] = supporter.serverId;
+      }
+    }
+    if (attribution) {
+      attribution.getOperationSupport = {
+        baseClientId: first.serverId,
+        contributors
+      };
+    }
+    return aggregate;
+  }
+  async getCapabilitySnapshots(filePath, attribution) {
+    if (this.checkDestroyed())
+      return [];
+    const snapshots = [];
+    if (filePath) {
+      const servers = getServersForFileWithConfig(filePath);
+      for (const server of servers) {
+        const root = await this.resolveServerRoot(server, filePath);
+        if (!root)
+          continue;
+        const client = this.state.clients.get(`${server.id}:${normalizeMapKey(root)}`);
+        if (!client?.isAlive())
+          continue;
+        snapshots.push({
+          serverId: server.id,
+          root,
+          operationSupport: client.getOperationSupport(),
+          workspaceDiagnosticsSupport: client.getWorkspaceDiagnosticsSupport(),
+          customServer: server.custom,
+          diagnosticsPublished: this.state.diagnosticsPublished.has(server.id),
+          diagnosticsUnsupported: this.state.diagnosticsUnsupported.has(server.id),
+          advertisedCommands: client.getAdvertisedCommands(),
+          rawCapabilityKeys: client.getRawCapabilityKeys?.() ?? [],
+          textDocumentSave: textDocumentSaveOf(client),
+          launchVariant: client.getLaunchVariant?.()
+        });
+      }
+      return snapshots;
+    }
+    for (const [key, client] of this.state.clients) {
+      if (!client.isAlive())
+        continue;
+      const separator = key.indexOf(":");
+      const serverId = separator >= 0 ? key.slice(0, separator) : key;
+      snapshots.push({
+        serverId,
+        root: client.root,
+        operationSupport: client.getOperationSupport(),
+        workspaceDiagnosticsSupport: client.getWorkspaceDiagnosticsSupport(),
+        customServer: this.state.servers.get(serverId)?.custom,
+        diagnosticsPublished: this.state.diagnosticsPublished.has(serverId),
+        diagnosticsUnsupported: this.state.diagnosticsUnsupported.has(serverId),
+        advertisedCommands: client.getAdvertisedCommands(),
+        rawCapabilityKeys: client.getRawCapabilityKeys?.() ?? [],
+        textDocumentSave: textDocumentSaveOf(client),
+        launchVariant: client.getLaunchVariant?.()
+      });
+    }
+    if (attribution) {
+      attribution.getCapabilitySnapshots = {
+        clientIds: snapshots.slice(0, WORKSPACE_ATTRIBUTION_CLIENT_CAP).map((snapshot) => snapshot.serverId),
+        clientCount: snapshots.length
+      };
+    }
+    return snapshots;
+  }
+  async getWorkspaceDiagnosticsSupport(filePath, attribution) {
+    if (filePath) {
+      const spawned = await this.getClientForFile(filePath);
+      if (!spawned)
+        return null;
+      const getter = spawned.client.getWorkspaceDiagnosticsSupport;
+      if (typeof getter !== "function")
+        return null;
+      return getter();
+    }
+    const first = this.selectWorkspaceScopeClient();
+    if (!first)
+      return null;
+    const getter = first.client.getWorkspaceDiagnosticsSupport;
+    if (typeof getter !== "function")
+      return null;
+    if (attribution)
+      attribution.getWorkspaceDiagnosticsSupport = first.serverId;
+    return getter.call(first.client);
+  }
+  async codeAction(filePath, line, character, endLine, endCharacter) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().codeAction) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for codeAction");
+    }
+    return spawned.client.codeAction(filePath, line, character, endLine, endCharacter);
+  }
+  async rename(filePath, line, character, newName) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return null;
+    if (!spawned.client.getOperationSupport().rename) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for rename");
+    }
+    return spawned.client.rename(filePath, line, character, newName);
+  }
+  async renameFile(oldFilePath, newFilePath, options) {
+    const cwd = options.cwd;
+    const apply = options.apply ?? false;
+    await validateWorkspaceEdit({
+      documentChanges: [
+        {
+          kind: "rename",
+          oldUri: pathToFileURL(oldFilePath).href,
+          newUri: pathToFileURL(newFilePath).href
+        }
+      ]
+    }, cwd);
+    const priorityServerIds = getServersForFileWithConfig(oldFilePath).map((server) => server.id);
+    const activeClients = this.activeClientsForCwd(cwd, priorityServerIds);
+    const willRenameFailures = [];
+    const didRenameFailures = [];
+    const willRenameClients = activeClients.filter(({ serverId, client }) => {
+      if (client.getOperationSupport().willRenameFiles === true)
+        return true;
+      recordDegradationOnce({
+        kind: "lsp-capability-skip",
+        subject: `${serverId}:workspace/willRenameFiles`,
+        reason: client.getMalformedFileOperationRegistrations().has("willRename") ? "malformed-registration" : "no-registration"
+      });
+      return false;
+    });
+    const willResults = await Promise.all(willRenameClients.map(async ({ serverId, client }) => {
+      try {
+        return {
+          serverId,
+          edit: await client.willRenameFiles(oldFilePath, newFilePath)
+        };
+      } catch (err) {
+        willRenameFailures.push({
+          serverId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return { serverId, edit: null };
+      }
+    }));
+    const successfulWillResults = willResults.filter((result) => !willRenameFailures.some((failure) => failure.serverId === result.serverId));
+    if (willRenameClients.length > 0 && successfulWillResults.length === 0) {
+      throw new Error(`workspace/willRenameFiles failed for all active LSP servers: ${willRenameFailures.map((failure) => `${failure.serverId}: ${failure.error}`).join("; ")}`);
+    }
+    const merged = mergeWorkspaceTextEditsByPriority(successfulWillResults);
+    const summary = summarizeWorkspaceEdit(merged.edit, cwd);
+    if (!apply) {
+      return {
+        applied: false,
+        serverIds: activeClients.map((entry) => entry.serverId),
+        willRenameFailures,
+        didRenameFailures,
+        droppedConflicts: merged.droppedConflicts,
+        inputEditCount: merged.inputEditCount,
+        summary
+      };
+    }
+    let applied;
+    try {
+      applied = await applyWorkspaceEdit(merged.edit, cwd, {
+        mutationContext: options.mutationContext,
+        observe: false
+      });
+    } catch (err) {
+      if (options.mutationContext) {
+        const partial = err.appliedWorkspaceEdit;
+        if (partial) {
+          recordLspMutation(options.mutationContext, {
+            results: [partial],
+            status: "failed"
+          });
+        }
+      }
+      throw err;
+    }
+    const openDocuments = activeClients.filter(({ client }) => client.isDocumentOpen(oldFilePath)).map(({ serverId, client }) => ({
+      serverId,
+      client,
+      oldUri: client.getDocumentUri(oldFilePath)
+    }));
+    const closeFailures = [];
+    await Promise.all(activeClients.map(async ({ serverId, client }) => {
+      const result = await runRenameNotify(() => client.closeDocument(oldFilePath), RENAME_NOTIFY_TIMEOUT_MS);
+      if (!result.ok) {
+        closeFailures.push({
+          serverId,
+          error: result.error,
+          disposition: result.disposition
+        });
+      }
+    }));
+    if (closeFailures.length > 0) {
+      if (options.mutationContext) {
+        recordLspMutation(options.mutationContext, {
+          results: [applied],
+          status: "failed"
+        });
+      }
+      const content = await fs.readFile(oldFilePath, "utf-8");
+      const languageId = getLanguageId(oldFilePath) ?? "plaintext";
+      const resyncFailures = [];
+      await Promise.all(openDocuments.map(async ({ serverId, client }) => {
+        const resyncResult = await runRenameNotify(() => client.notify.open(oldFilePath, content, languageId, true, true).then((sent) => {
+          if (sent === false) {
+            throw new Error(client.isAlive() ? "re-open not sent: the close is still queued" : "re-open not sent: the client is dead");
+          }
+        }), RENAME_NOTIFY_TIMEOUT_MS);
+        if (!resyncResult.ok) {
+          resyncFailures.push({
+            serverId,
+            error: resyncResult.error,
+            disposition: resyncResult.disposition
+          });
+        }
+      }));
+      if (resyncFailures.length > 0) {
+        logLatency({
+          type: "phase",
+          phase: "lsp_rename_resync_failed",
+          filePath: oldFilePath,
+          durationMs: 0,
+          metadata: {
+            failures: resyncFailures.map((failure) => ({
+              serverId: failure.serverId,
+              disposition: failure.disposition,
+              error: failure.error
+            }))
+          }
+        });
+      }
+      const closeFailureSummary = closeFailures.map((failure) => `${failure.serverId} (${failure.disposition}): ${failure.error}`).join("; ");
+      const resyncFailureSummary = resyncFailures.length > 0 ? ` (resync also failed: ${resyncFailures.map((failure) => `${failure.serverId} (${failure.disposition}): ${failure.error}`).join("; ")})` : "";
+      throw new Error(`workspace/didClose failed; rename aborted: ${closeFailureSummary}${resyncFailureSummary}`);
+    }
+    let renameApplied;
+    try {
+      renameApplied = await applyWorkspaceEdit({
+        documentChanges: [
+          {
+            kind: "rename",
+            oldUri: pathToFileURL(oldFilePath).href,
+            newUri: pathToFileURL(newFilePath).href
+          }
+        ]
+      }, cwd, { observe: false });
+    } catch (err) {
+      if (options.mutationContext) {
+        recordLspMutation(options.mutationContext, {
+          results: [applied],
+          status: "failed"
+        });
+      }
+      throw err;
+    }
+    const relOld = path.relative(cwd, oldFilePath).replace(/\\/g, "/") || path.basename(oldFilePath);
+    const relNew = path.relative(cwd, newFilePath).replace(/\\/g, "/") || path.basename(newFilePath);
+    const renameDescription = `Renamed ${relOld} → ${relNew}`;
+    await Promise.all(activeClients.map(async ({ serverId, client }) => {
+      if (client.getOperationSupport().didRenameFiles !== true) {
+        recordDegradationOnce({
+          kind: "lsp-capability-skip",
+          subject: `${serverId}:workspace/didRenameFiles`,
+          reason: client.getMalformedFileOperationRegistrations().has("didRename") ? "malformed-registration" : "no-registration"
+        });
+        return;
+      }
+      const opened = openDocuments.find((entry) => entry.serverId === serverId);
+      const result = await runRenameNotify(() => opened?.oldUri ? client.didRenameFiles(oldFilePath, newFilePath, opened.oldUri, destinationUriPreservingSpelling(opened.oldUri, oldFilePath, newFilePath)) : client.didRenameFiles(oldFilePath, newFilePath), RENAME_NOTIFY_TIMEOUT_MS);
+      if (!result.ok) {
+        didRenameFailures.push({
+          serverId,
+          error: result.error,
+          disposition: result.disposition
+        });
+      }
+    }));
+    const files = [...new Set([...applied.files, oldFilePath, newFilePath])];
+    if (options.mutationContext) {
+      recordLspMutation(options.mutationContext, {
+        results: [
+          {
+            ...applied,
+            files,
+            operationTotal: applied.operationTotal + renameApplied.operationTotal,
+            appliedOperationTotal: applied.appliedOperationTotal + renameApplied.appliedOperationTotal,
+            appliedOperationIndexes: [
+              ...applied.appliedOperationIndexes,
+              ...renameApplied.appliedOperationIndexes.map((index) => applied.operationTotal + index)
+            ],
+            operationCounts: {
+              textEdits: applied.operationCounts.textEdits + renameApplied.operationCounts.textEdits,
+              create: applied.operationCounts.create + renameApplied.operationCounts.create,
+              rename: applied.operationCounts.rename + renameApplied.operationCounts.rename,
+              delete: applied.operationCounts.delete + renameApplied.operationCounts.delete
+            },
+            fileDetails: [...applied.fileDetails, ...renameApplied.fileDetails]
+          }
+        ],
+        status: "success"
+      });
+    }
+    return {
+      applied: true,
+      serverIds: activeClients.map((entry) => entry.serverId),
+      willRenameFailures,
+      didRenameFailures,
+      droppedConflicts: merged.droppedConflicts,
+      inputEditCount: merged.inputEditCount,
+      summary,
+      descriptions: [...applied.descriptions, renameDescription],
+      files
+    };
+  }
+  async implementation(filePath, line, character) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().implementation) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for implementation");
+    }
+    return spawned.client.implementation(filePath, line, character);
+  }
+  async prepareCallHierarchy(filePath, line, character) {
+    const spawned = await this.getClientForFile(filePath, NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().callHierarchy) {
+      throw new Error("__UNSUPPORTED__ Active LSP server does not advertise support for prepareCallHierarchy");
+    }
+    return spawned.client.prepareCallHierarchy(filePath, line, character);
+  }
+  async incomingCalls(item) {
+    const spawned = await this.getClientForFile(uriToPath(item.uri), NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().callHierarchy)
+      return [];
+    return spawned.client.incomingCalls(item);
+  }
+  async outgoingCalls(item) {
+    const spawned = await this.getClientForFile(uriToPath(item.uri), NAV_CLIENT_WAIT_TIMEOUT_MS);
+    if (!spawned)
+      return [];
+    if (!spawned.client.getOperationSupport().callHierarchy)
+      return [];
+    return spawned.client.outgoingCalls(item);
+  }
+  async ensureWarmForSweep(representativeFile, options = {}) {
+    if (this.checkDestroyed() || options.signal?.aborted) {
+      return { performedWarmup: false, failedServerIds: [] };
+    }
+    const servers = getServersForFileWithConfig(representativeFile).filter((s) => !isAuxiliary(s));
+    if (servers.length === 0) {
+      return { performedWarmup: false, failedServerIds: [] };
+    }
+    const keys = await Promise.all(servers.map((server) => this.demonstratedReadyKeyFor(server, representativeFile)));
+    const headOf = new Map;
+    const familyHead = servers.map((server) => {
+      const preferredHead = server.fallbackFor === undefined ? undefined : headOf.get(server.fallbackFor);
+      const head = preferredHead ?? server.id;
+      headOf.set(server.id, head);
+      return head;
+    });
+    const isColdAt = (i) => {
+      const key = keys[i];
+      if (key === undefined || this.state.demonstratedReady.has(key)) {
+        return false;
+      }
+      return !servers.some((_, j) => {
+        const peerKey = keys[j];
+        return peerKey !== undefined && familyHead[j] === familyHead[i] && this.state.demonstratedReady.has(peerKey);
+      });
+    };
+    const alreadyWarm = servers.every((_, i) => !isColdAt(i));
+    if (alreadyWarm)
+      return { performedWarmup: false, failedServerIds: [] };
+    const cachedColdServerIds = [];
+    let allNonWarmCached = true;
+    for (let i = 0;i < servers.length; i++) {
+      const key = keys[i];
+      if (key === undefined || !isColdAt(i))
+        continue;
+      if (this.state.demonstratedCold.has(key)) {
+        cachedColdServerIds.push(servers[i].id);
+      } else {
+        allNonWarmCached = false;
+      }
+    }
+    if (allNonWarmCached && cachedColdServerIds.length > 0) {
+      logLatency({
+        type: "phase",
+        phase: "lsp_sweep_warmup_cached_cold",
+        filePath: representativeFile,
+        durationMs: 0,
+        metadata: { serverIds: cachedColdServerIds }
+      });
+      return {
+        performedWarmup: false,
+        failedServerIds: cachedColdServerIds,
+        skippedFromCache: true
+      };
+    }
+    let content;
+    try {
+      content = await nodeFs.promises.readFile(representativeFile, "utf-8");
+    } catch {
+      return { performedWarmup: false, failedServerIds: [] };
+    }
+    if (options.signal?.aborted) {
+      return { performedWarmup: false, failedServerIds: [] };
+    }
+    const timeoutMs = options.timeoutMs ?? warmupTimeoutMs();
+    const rootedServerIds = [];
+    const unrootedServerIds = [];
+    for (let i = 0;i < servers.length; i++) {
+      if (keys[i] !== undefined)
+        rootedServerIds.push(servers[i].id);
+      else
+        unrootedServerIds.push(servers[i].id);
+    }
+    const unrootedCandidates = {
+      count: unrootedServerIds.length,
+      ids: unrootedServerIds
+    };
+    const stillColdServerIds = () => {
+      const cold = [];
+      for (let i = 0;i < servers.length; i++) {
+        if (isColdAt(i))
+          cold.push(servers[i].id);
+      }
+      return cold;
+    };
+    const runWarmupTouch = async (attempt) => {
+      if (options.signal?.aborted)
+        return;
+      const startedAt = Date.now();
+      logLatency({
+        type: "phase",
+        phase: "lsp_sweep_warmup_start",
+        filePath: representativeFile,
+        durationMs: 0,
+        metadata: {
+          serverIds: rootedServerIds,
+          unrootedCandidates,
+          timeoutMs,
+          attempt
+        }
+      });
+      const warmupAttempt = this.touchFile(representativeFile, content, {
+        diagnostics: "document",
+        collectDiagnostics: false,
+        clientScope: "primary",
+        source: "lsp_sweep_warmup",
+        maxClientWaitMs: timeoutMs,
+        maxDiagnosticsWaitMs: timeoutMs,
+        warmupOverride: true,
+        warmupAttempt: attempt
+      });
+      await (options.signal ? Promise.race([
+        withDeadline(warmupAttempt, {
+          ms: timeoutMs,
+          onTimeout: "undefined"
+        }),
+        new Promise((resolve) => {
+          if (options.signal.aborted) {
+            resolve();
+            return;
+          }
+          options.signal.addEventListener("abort", () => resolve(), {
+            once: true
+          });
+        })
+      ]) : withDeadline(warmupAttempt, {
+        ms: timeoutMs,
+        onTimeout: "undefined"
+      }));
+      const coldServerIds = stillColdServerIds();
+      logLatency({
+        type: "phase",
+        phase: options.signal?.aborted ? "lsp_sweep_warmup_aborted" : coldServerIds.length > 0 ? "lsp_sweep_warmup_failed" : "lsp_sweep_warmup_done",
+        filePath: representativeFile,
+        durationMs: Date.now() - startedAt,
+        metadata: {
+          serverIds: rootedServerIds,
+          unrootedCandidates,
+          timeoutMs,
+          attempt,
+          coldServerIds
+        }
+      });
+    };
+    await runWarmupTouch(1);
+    let failedServerIds = stillColdServerIds();
+    const warmedClients = keys.map((key) => key === undefined ? undefined : this.state.clients.get(key));
+    if (failedServerIds.length > 0 && !options.signal?.aborted) {
+      const backoffMs = warmupRetryBackoffMs();
+      if (backoffMs > 0) {
+        await new Promise((resolve) => {
+          const timer = setTimeout(resolve, backoffMs);
+          timer.unref?.();
+          options.signal?.addEventListener("abort", () => resolve(), {
+            once: true
+          });
+        });
+      }
+      if (!options.signal?.aborted) {
+        await runWarmupTouch(2);
+        failedServerIds = stillColdServerIds();
+      }
+    }
+    if (failedServerIds.length > 0) {
+      for (let i = 0;i < servers.length; i++) {
+        const key = keys[i];
+        if (key !== undefined && failedServerIds.includes(servers[i].id) && this.state.clients.get(key) === warmedClients[i]) {
+          this.state.demonstratedCold.add(key);
+        }
+      }
+    }
+    return { performedWarmup: true, failedServerIds };
+  }
+  async runWorkspaceDiagnostics(cwd, options = {}) {
+    const releaseSweepHold = acquireWorkspaceSweepHold();
+    try {
+      return await this.runWorkspaceDiagnosticsSwept(cwd, options);
+    } finally {
+      releaseSweepHold();
+    }
+  }
+  async runWorkspaceDiagnosticsSwept(cwd, options = {}) {
+    const startedAt = Date.now();
+    const root = path.resolve(cwd);
+    const { signal } = options;
+    this.sweepDocumentDrift().catch(() => {});
+    const maxFiles = typeof options.maxFiles === "number" && Number.isFinite(options.maxFiles) && options.maxFiles > 0 ? Math.floor(options.maxFiles) : getMaxWorkspaceDiagnosticFiles();
+    const files = options.files ? options.files.slice(0, maxFiles) : await collectWorkspaceDiagnosticFiles(root, maxFiles, signal);
+    const perFileMs = (() => {
+      const raw = Number(process.env.DM_LENS_LSP_WORKSPACE_PER_FILE_MS);
+      return Number.isFinite(raw) && raw > 0 ? raw : 15000;
+    })();
+    const results = [];
+    let completed = 0;
+    let timedOutFiles = 0;
+    let lastHeartbeat = Date.now();
+    const workspaceDiagnosticsCacheCtx = createWorkspaceDiagnosticsCacheContext(root);
+    const workspaceSweepScopeKey = buildScopeKey("all", [
+      ...WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS
+    ]);
+    const touchScopedOpenDependencies = async (filePath) => {
+      if (options.files === undefined)
+        return true;
+      const imports = workspaceDiagnosticsCacheCtx.importsFor(filePath);
+      if (!imports)
+        return false;
+      const openImports = imports.filter((dependency) => this.hasLiveClientHoldingDocument(dependency));
+      const capped = openImports.length > SCOPED_DEPENDENCY_TOUCH_MAX;
+      if (capped) {
+        recordDegradationOnce({
+          kind: "lsp_dependency_touch_capped",
+          subject: filePath,
+          reason: `scoped full scan limited open import touches to ${SCOPED_DEPENDENCY_TOUCH_MAX}`
+        });
+      }
+      await Promise.all(openImports.slice(0, SCOPED_DEPENDENCY_TOUCH_MAX).map(async (dependency) => {
+        let content;
+        try {
+          content = await fs.readFile(dependency, "utf8");
+        } catch {
+          return;
+        }
+        await this.touchFile(dependency, content, {
+          diagnostics: "none",
+          source: "lens_diagnostics_full_dependency",
+          clientScope: "all",
+          excludeServerIds: await this.serverIdsNotHoldingDocument(dependency)
+        });
+      }));
+      return !capped;
+    };
+    const cachedResults = [];
+    const filesToTouch = [];
+    const writeIndexByPath = new Map;
+    for (const filePath of files) {
+      writeIndexByPath.set(normalizeMapKey(filePath), options.nextWriteIndex?.());
+      const cached = workspaceDiagnosticsCacheCtx.lookup(filePath, workspaceSweepScopeKey);
+      if (cached && cached.binding.boundToCurrentDisk !== false) {
+        const dependenciesConfirmed = await touchScopedOpenDependencies(filePath);
+        if (dependenciesConfirmed)
+          cachedResults.push({
+            filePath,
+            diagnostics: cached.diagnostics,
+            count: cached.count,
+            observedAt: cached.scannedAt,
+            contentHash: cached.binding.contentHash,
+            boundToCurrentDisk: cached.binding.boundToCurrentDisk,
+            writeIndex: writeIndexByPath.get(normalizeMapKey(filePath))
+          });
+        else
+          filesToTouch.push(filePath);
+      } else {
+        filesToTouch.push(filePath);
+      }
+    }
+    completed = cachedResults.length;
+    if (cachedResults.length > 0) {
+      options.onProgress?.(completed, files.length);
+    }
+    const cacheServedKeys = new Set(cachedResults.map((result) => normalizeMapKey(result.filePath)));
+    const supersededCacheKeys = new Set;
+    const pullAnsweredFiles = new Set;
+    const scannedMtimeByFile = new Map;
+    const scannedSizeByFile = new Map;
+    const scannedAtByFile = new Map;
+    const noteScanStat = (filePath) => {
+      scannedAtByFile.set(filePath, Date.now());
+      try {
+        const scanStat = nodeFs.statSync(filePath);
+        scannedMtimeByFile.set(filePath, scanStat.mtimeMs);
+        scannedSizeByFile.set(filePath, scanStat.size);
+      } catch {}
+    };
+    const groups = groupFilesByPrimaryServer(filesToTouch);
+    const sweepIndexGate = createSweepIndexGate();
+    const workspacePullEnabled = process.env.DM_LENS_LSP_WORKSPACE_PULL === "1";
+    logLatency({
+      type: "phase",
+      phase: "lsp_workspace_diagnostics_start",
+      filePath: root,
+      durationMs: 0,
+      metadata: {
+        fileCount: files.length,
+        cacheHits: cachedResults.length,
+        filesToTouch: filesToTouch.length,
+        maxFiles,
+        perFileMs,
+        serverGroups: groups.length
+      }
+    });
+    const contentCache = new Map;
+    const preOpenGroupFiles = async (groupFiles) => {
+      if (isWarmAttached())
+        return;
+      for (const filePath of groupFiles) {
+        if (signal?.aborted)
+          return;
+        let content;
+        noteScanStat(filePath);
+        try {
+          content = await nodeFs.promises.readFile(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        contentCache.set(filePath, content);
+        const languageId = getLanguageId(filePath) ?? "plaintext";
+        const preOpenAttempt = withDeadline((async () => {
+          const { clients } = await this.getClientsForFile(filePath, WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS);
+          for (const entry of clients) {
+            let auxKey;
+            if (isAuxiliary(entry.info)) {
+              auxKey = await this.demonstratedReadyKeyFor(entry.info, filePath);
+              if (auxKey && this.auxNotifyBacklogAtCeiling(auxKey, entry)) {
+                continue;
+              }
+            }
+            try {
+              const sent = await entry.client.notify.open(filePath, content, languageId);
+              if (auxKey && sent !== false) {
+                this.noteAuxNotifyIssued(auxKey, entry.client);
+              }
+            } catch {}
+          }
+        })(), { ms: perFileMs, onTimeout: "undefined" });
+        await (signal ? Promise.race([
+          preOpenAttempt,
+          new Promise((resolve) => {
+            if (signal.aborted) {
+              resolve();
+              return;
+            }
+            signal.addEventListener("abort", () => resolve(), {
+              once: true
+            });
+          })
+        ]) : preOpenAttempt);
+      }
+    };
+    const markServiceDestroyed = (remainingFiles) => {
+      for (const filePath of remainingFiles) {
+        results.push({
+          filePath,
+          diagnostics: [],
+          count: 0,
+          timedOut: true,
+          unconfirmedReason: "service_destroyed",
+          writeIndex: writeIndexByPath.get(normalizeMapKey(filePath))
+        });
+        timedOutFiles += 1;
+        completed += 1;
+      }
+      options.onProgress?.(completed, files.length);
+    };
+    const processFile = async (filePath) => {
+      try {
+        let content = contentCache.get(filePath);
+        if (content === undefined) {
+          noteScanStat(filePath);
+          content = await nodeFs.promises.readFile(filePath, "utf-8");
+        }
+        const attached = isWarmAttached() ? await tryWarmAttachedDiagnostics(filePath, content, perFileMs, "sweep") : undefined;
+        if (attached && !attached.available) {
+          await this.ensureWarmForSweep(filePath, { signal });
+        }
+        const touchResult = attached?.available ? {
+          diags: attached.response.diagnostics,
+          ...attached.response.unconfirmedServerIds !== undefined && {
+            unconfirmedServerIds: attached.response.unconfirmedServerIds
+          }
+        } : await withDeadline(this.touchFile(filePath, content, {
+          diagnostics: "document",
+          collectDiagnostics: true,
+          clientScope: "all",
+          source: "lens_diagnostics_full",
+          excludeServerIds: WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS,
+          sweepIndexGate
+        }), { ms: perFileMs, onTimeout: "undefined" });
+        const diagnostics = touchResult?.diags;
+        const inconclusive = touchResult?.inconclusive === true;
+        const unconfirmedServerIds = touchCoverageGap(touchResult);
+        const coverageGap = unconfirmedServerIds.length > 0;
+        const declinedOutsideRoot = touchResult?.skipReason === "outside-project-root";
+        const timedOut = touchResult === undefined || inconclusive || declinedOutsideRoot;
+        if (timedOut)
+          timedOutFiles += 1;
+        const unconfirmedReason = touchResult === undefined ? "budget" : declinedOutsideRoot ? "outside_project_root" : inconclusive ? "inconclusive" : undefined;
+        const rawBinding = touchResult?.binding;
+        const filteredDiagnostics = diagnostics ? applyAuxiliarySuppressions(diagnostics, content, {
+          fileRole: detectFileRole(filePath, content),
+          filePath,
+          scanRoot: root
+        }) : diagnostics;
+        results.push({
+          filePath,
+          diagnostics: filteredDiagnostics ?? [],
+          count: filteredDiagnostics?.length ?? 0,
+          ...timedOut && { timedOut: true, unconfirmedReason },
+          ...coverageGap && {
+            unconfirmedServerIds: [...unconfirmedServerIds]
+          },
+          contentHash: rawBinding?.contentHash,
+          boundToCurrentDisk: rawBinding?.boundToCurrentDisk,
+          writeIndex: writeIndexByPath.get(normalizeMapKey(filePath))
+        });
+      } catch (err) {
+        results.push({
+          filePath,
+          diagnostics: [],
+          count: 0,
+          error: err instanceof Error ? err.message : String(err),
+          timedOut: true,
+          unconfirmedReason: "error",
+          writeIndex: writeIndexByPath.get(normalizeMapKey(filePath))
+        });
+      }
+      completed += 1;
+      options.onProgress?.(completed, files.length);
+      if (Date.now() - lastHeartbeat >= 1e4) {
+        lastHeartbeat = Date.now();
+        logLatency({
+          type: "phase",
+          phase: "lsp_workspace_diagnostics_progress",
+          filePath: root,
+          durationMs: Date.now() - startedAt,
+          metadata: {
+            completed,
+            total: files.length,
+            timedOutFiles,
+            aborted: signal?.aborted ?? false
+          }
+        });
+      }
+    };
+    const groupWorkers = Math.min(WORKSPACE_DIAGNOSTICS_CONCURRENCY, groups.length);
+    const sweepPhase = phaseStarted("lsp_workspace_diagnostics_touch");
+    try {
+      await runPerServerGroups(groups, groupWorkers, async (group) => {
+        if (signal?.aborted)
+          return;
+        if (this.checkDestroyed()) {
+          markServiceDestroyed(group.files);
+          return;
+        }
+        if (!isWarmAttached() && workspacePullEnabled && !group.multiServer) {
+          const pullStartedAt = Date.now();
+          const pulled = await this.tryWorkspacePull(group.files, perFileMs, cacheServedKeys);
+          if (pulled) {
+            for (const clean of pulled.extraClean) {
+              supersededCacheKeys.add(normalizeMapKey(clean.filePath));
+            }
+            for (const result of [...pulled.results, ...pulled.extraClean]) {
+              results.push({
+                ...result,
+                writeIndex: writeIndexByPath.get(normalizeMapKey(result.filePath))
+              });
+              pullAnsweredFiles.add(result.filePath);
+              try {
+                const pullStat = nodeFs.statSync(result.filePath);
+                scannedMtimeByFile.set(result.filePath, pullStat.mtimeMs);
+                scannedSizeByFile.set(result.filePath, pullStat.size);
+                scannedAtByFile.set(result.filePath, pullStartedAt);
+              } catch {}
+            }
+            completed += group.files.length;
+            options.onProgress?.(completed, files.length);
+            return;
+          }
+        }
+        const first = group.files[0];
+        if (first && !isWarmAttached()) {
+          const warmup = await this.ensureWarmForSweep(first, { signal });
+          if (signal?.aborted)
+            return;
+          if (warmup.failedServerIds.length > 0) {
+            logLatency({
+              type: "phase",
+              phase: "lsp_sweep_group_skipped_warmup",
+              filePath: first,
+              durationMs: 0,
+              metadata: {
+                failedServerIds: warmup.failedServerIds,
+                skippedFromCache: warmup.skippedFromCache ?? false,
+                skippedFiles: group.files.length
+              }
+            });
+            for (const filePath of group.files) {
+              results.push({
+                filePath,
+                diagnostics: [],
+                count: 0,
+                timedOut: true,
+                unconfirmedReason: "inconclusive",
+                skippedWarmupFailure: true
+              });
+              timedOutFiles += 1;
+              completed += 1;
+            }
+            options.onProgress?.(completed, files.length);
+            return;
+          }
+          if (warmup.performedWarmup)
+            options.onServerReady?.();
+        }
+        for (let chunkStart = 0;chunkStart < group.files.length; chunkStart += WORKSPACE_SWEEP_PREOPEN_CHUNK_SIZE) {
+          if (signal?.aborted)
+            return;
+          if (this.checkDestroyed()) {
+            markServiceDestroyed(group.files.slice(chunkStart));
+            return;
+          }
+          const chunk = group.files.slice(chunkStart, chunkStart + WORKSPACE_SWEEP_PREOPEN_CHUNK_SIZE);
+          await preOpenGroupFiles(chunk);
+          for (const filePath of chunk) {
+            if (signal?.aborted)
+              return;
+            if (this.checkDestroyed()) {
+              markServiceDestroyed(group.files.slice(group.files.indexOf(filePath)));
+              return;
+            }
+            await processFile(filePath);
+          }
+        }
+      }, signal);
+    } finally {
+      phaseFinished(sweepPhase);
+    }
+    const unconfirmedByReason = {};
+    for (const result of results) {
+      if (!result.timedOut)
+        continue;
+      const reason = result.unconfirmedReason ?? "budget";
+      unconfirmedByReason[reason] = (unconfirmedByReason[reason] ?? 0) + 1;
+    }
+    const partiallyCoveredFiles = results.filter((result) => (result.unconfirmedServerIds?.length ?? 0) > 0).length;
+    const unconfirmedServerIds = [
+      ...new Set(results.flatMap((result) => result.unconfirmedServerIds ?? []))
+    ].sort((a, b) => Number(a > b) - Number(a < b));
+    let pullUnbound = 0;
+    for (const result of results) {
+      if (pullAnsweredFiles.has(result.filePath) && result.contentHash === undefined)
+        pullUnbound += 1;
+    }
+    logLatency({
+      type: "phase",
+      phase: "lsp_workspace_diagnostics",
+      filePath: root,
+      durationMs: Date.now() - startedAt,
+      metadata: {
+        filesChecked: files.length,
+        cacheHits: cachedResults.length,
+        diagnosticCount: results.reduce((sum, result) => sum + (result?.count ?? 0), 0),
+        serverGroups: groups.length,
+        concurrency: groupWorkers,
+        maxFiles,
+        timedOutFiles,
+        unconfirmedByReason,
+        partiallyCoveredFiles,
+        pullUnbound,
+        ...unconfirmedServerIds.length > 0 && { unconfirmedServerIds },
+        aborted: signal?.aborted ?? false
+      }
+    });
+    for (const result of results) {
+      const scannedAt = scannedMtimeByFile.get(result.filePath);
+      if (result.error || result.timedOut || (result.unconfirmedServerIds?.length ?? 0) > 0 || scannedAt === undefined) {
+        continue;
+      }
+      if (pullAnsweredFiles.has(result.filePath) && result.contentHash === undefined) {
+        workspaceDiagnosticsCacheCtx.forget(result.filePath);
+        continue;
+      }
+      workspaceDiagnosticsCacheCtx.record(result.filePath, workspaceSweepScopeKey, result.diagnostics, scannedAt, result.contentHash, scannedSizeByFile.get(result.filePath), scannedAtByFile.get(result.filePath));
+    }
+    workspaceDiagnosticsCacheCtx.persist();
+    const servedCacheResults = supersededCacheKeys.size === 0 ? cachedResults : cachedResults.filter((result) => !supersededCacheKeys.has(normalizeMapKey(result.filePath)));
+    const freshResults = results.map((result) => ({
+      ...result,
+      observedAt: scannedAtByFile.get(result.filePath)
+    }));
+    return [...servedCacheResults, ...freshResults].filter(Boolean);
+  }
+  async tryWorkspacePull(groupFiles, perFileMs, reanswerFor) {
+    try {
+      const first = groupFiles[0];
+      if (!first)
+        return;
+      const spawned = await this.getClientForFile(first, perFileMs);
+      if (!spawned)
+        return;
+      if (!spawned.client.getWorkspaceDiagnosticsSupport().workspaceDiagnostics) {
+        return;
+      }
+      const report = await spawned.client.requestWorkspaceDiagnostics(Math.max(perFileMs, workspacePullBudgetMs()));
+      if (!report)
+        return;
+      const byPath = new Map;
+      for (const entry of report) {
+        byPath.set(normalizeMapKey(entry.filePath), entry);
+      }
+      const results = groupFiles.map((filePath) => {
+        const entry = byPath.get(normalizeMapKey(filePath));
+        const diagnostics = entry?.diagnostics ?? [];
+        return {
+          filePath,
+          diagnostics,
+          count: diagnostics.length,
+          timedOut: false,
+          contentHash: entry?.contentHash
+        };
+      });
+      const extraClean = [];
+      if (reanswerFor && reanswerFor.size > 0) {
+        const asked = new Set(groupFiles.map((f) => normalizeMapKey(f)));
+        const withFindings = new Set;
+        for (const entry of report) {
+          if (entry.diagnostics.length > 0) {
+            withFindings.add(normalizeMapKey(entry.filePath));
+          }
+        }
+        for (const [key, entry] of byPath) {
+          if (asked.has(key) || !reanswerFor.has(key))
+            continue;
+          if (entry.diagnostics.length > 0 || withFindings.has(key))
+            continue;
+          extraClean.push({
+            filePath: entry.filePath,
+            diagnostics: [],
+            count: 0,
+            timedOut: false,
+            contentHash: entry.contentHash
+          });
+        }
+      }
+      return { results, extraClean };
+    } catch {
+      return;
+    }
+  }
+  async getAllDiagnostics() {
+    const all = new Map;
+    const bindingsByPath = new Map;
+    const now = Date.now();
+    for (const [_key, client] of this.state.clients) {
+      const trackedPaths = client.getTrackedDiagnosticPaths();
+      const existingPaths = new Set;
+      await Promise.all(trackedPaths.map(async (filePath) => {
+        try {
+          await nodeFs.promises.access(filePath);
+          existingPaths.add(filePath);
+        } catch {}
+        return true;
+      }));
+      client.pruneDiagnostics((filePath, ts) => !existingPaths.has(filePath) || now - ts > CASCADE_DIAGNOSTICS_TTL_MS);
+      const clientDiags = client.getAllDiagnostics();
+      for (const [filePath, entry] of clientDiags) {
+        const attributed = attributeDiagnostics(client.serverId, entry.diags);
+        const existing = all.get(filePath);
+        if (existing) {
+          existing.diags = mergeLspDiagnostics([
+            ...existing.diags,
+            ...attributed
+          ]);
+          existing.ts = Math.max(existing.ts, entry.ts);
+        } else {
+          all.set(filePath, { diags: attributed, ts: entry.ts });
+        }
+        const list = bindingsByPath.get(filePath) ?? [];
+        list.push(entry.binding);
+        bindingsByPath.set(filePath, list);
+      }
+    }
+    for (const [filePath, entry] of all) {
+      const stored = bindingsByPath.get(filePath) ?? [];
+      let memo;
+      Object.defineProperty(entry, "binding", {
+        enumerable: false,
+        configurable: true,
+        get: () => memo ??= this.mergeBinding(filePath, stored)
+      });
+    }
+    return all;
+  }
+  supportsLSP(filePath) {
+    return getServersForFileWithConfig(filePath).length > 0;
+  }
+  isSpawnInFlight(_filePath, resolvedRoots = new Map) {
+    for (const [serverId, root] of resolvedRoots) {
+      if (this.state.inFlight.has(`${serverId}:${root}`))
+        return true;
+    }
+    return false;
+  }
+  describeTouchCandidates(filePath, resolvedRoots, auxiliaryRoots = new Map) {
+    const candidates = [];
+    for (const server of getServersForFileWithConfig(filePath)) {
+      const auxiliary = isAuxiliary(server);
+      if (auxiliary && !auxiliaryRoots.has(server.id))
+        continue;
+      if (candidates.length >= MAX_TOUCH_CANDIDATES)
+        break;
+      const root = (auxiliary ? auxiliaryRoots : resolvedRoots).get(server.id);
+      const key = root === undefined ? undefined : `${server.id}:${root}`;
+      const client = key === undefined ? undefined : this.state.clients.get(key);
+      candidates.push({
+        serverId: server.id,
+        rooted: root !== undefined,
+        clientFound: client ? client.isAlive() ? "alive" : "dead" : "none",
+        generation: key === undefined ? undefined : this.state.clientSpawnedAt.get(key)
+      });
+    }
+    return candidates;
+  }
+  async hasWarmLSP(filePath) {
+    const spawned = await this.getWarmClientForFile(filePath);
+    return Boolean(spawned);
+  }
+  async hasLSP(filePath) {
+    const spawned = await this.getClientForFile(filePath);
+    return Boolean(spawned);
+  }
+  async shutdown(options = {}) {
+    const resetStartedAt = Date.now();
+    if (this.checkDestroyed())
+      return;
+    this.isDestroyed = true;
+    this.shutdownController.abort();
+    for (const [key, token] of this.outstandingAuxNotifyWrites) {
+      this.releaseOutstandingAuxNotifyWrite(key, token);
+    }
+    for (const key of this.idleEvictionTimers.keys()) {
+      this.clearIdleEvictionTimer(key);
+    }
+    if (!options.processExiting && this.state.inFlight.size > 0) {
+      const pending = Array.from(this.state.inFlight.values());
+      this.state.inFlight.clear();
+      const settled = await Promise.allSettled(pending);
+      for (const result of settled) {
+        if (result.status === "fulfilled" && result.value?.client) {
+          result.value.client.shutdown({ fast: true }).catch(() => {});
+        }
+      }
+    } else {
+      this.state.inFlight.clear();
+    }
+    const aliveClients = this.getAliveClientCount();
+    await Promise.allSettled(Array.from(this.state.clients.values(), (client) => Promise.resolve().then(() => client.shutdown(options))));
+    logLatency({
+      type: "phase",
+      phase: "lsp_service_reset",
+      filePath: "",
+      startedAt: new Date(resetStartedAt).toISOString(),
+      durationMs: Date.now() - resetStartedAt,
+      metadata: {
+        reason: options.reason ?? null,
+        aliveClients,
+        fast: !!options.fast,
+        processExiting: !!options.processExiting
+      }
+    });
+    this.state.clients.clear();
+    this.state.broken.clear();
+    this.firstContactWaits.clear();
+    this.lastSpawnVerdict.clear();
+    for (const [key, token] of this.outstandingAuxNotifyWrites) {
+      this.releaseOutstandingAuxNotifyWrite(key, token);
+    }
+    this.notifyStallDemotions.clear();
+    this.auxNotifyDrainLatencyEwma.clear();
+    this.auxNotifyInflight.clear();
+    this.documentDrift.clear();
+    this.workspaceProbeLogged.clear();
+    this.warmStartLogged.clear();
+  }
+  getStatus() {
+    return Array.from(this.state.clients.entries()).map(([key, client]) => {
+      const [serverId, root] = key.split(":");
+      return {
+        serverId,
+        root,
+        connected: client.isAlive(),
+        pullFailureHistory: (client.getPullFailureHistory?.() ?? []).map((entry) => ({
+          ...entry,
+          message: entry.message.slice(0, 200)
+        }))
+      };
+    });
+  }
+  recordRuntimeExitWindow(key, exitedAt, uptimeMs) {
+    if (exitedAt == null || uptimeMs == null || uptimeMs > RUNTIME_EXIT_WINDOW_UPTIME_CEILING_MS) {
+      return false;
+    }
+    const deaths = this.runtimeExitWindow.get(key) ?? [];
+    deaths.push(exitedAt);
+    const windowRef = Math.max(...deaths);
+    const windowStart = windowRef - RUNTIME_EXIT_WINDOW_MS;
+    let pruned = deaths.filter((t) => t >= windowStart);
+    if (pruned.length > RUNTIME_EXIT_WINDOW_TRIP_COUNT) {
+      pruned = pruned.slice(pruned.length - RUNTIME_EXIT_WINDOW_TRIP_COUNT);
+    }
+    this.runtimeExitWindow.set(key, pruned);
+    return pruned.length >= RUNTIME_EXIT_WINDOW_TRIP_COUNT;
+  }
+  getBrokenStatus() {
+    const keys = new Set([
+      ...this.state.broken.keys(),
+      ...this.permanentlyBroken
+    ]);
+    return [...keys].map((key) => {
+      const separator = key.indexOf(":");
+      return {
+        serverId: separator >= 0 ? key.slice(0, separator) : key,
+        root: separator >= 0 ? key.slice(separator + 1) : "",
+        failures: (this.failureCounts.get(key) ?? 0) + Math.max(this.runtimeExitCounts.get(key) ?? 0, this.runtimeExitWindow.get(key)?.length ?? 0),
+        permanentlyBroken: this.permanentlyBroken.has(key),
+        cooldownUntil: this.state.broken.get(key) ?? 0
+      };
+    });
+  }
+  getAliveClientCount() {
+    let count = 0;
+    for (const client of this.state.clients.values()) {
+      if (client.isAlive())
+        count++;
+    }
+    return count;
+  }
+  getAliveServerIds() {
+    const primary = [];
+    const aux = [];
+    const seen = new Set;
+    for (const client of this.state.clients.values()) {
+      if (!client.isAlive())
+        continue;
+      const id = client.serverId;
+      if (seen.has(id))
+        continue;
+      seen.add(id);
+      (isAuxiliary(getServerById(id)) ? aux : primary).push(id);
+    }
+    return [...primary, ...aux];
+  }
+}
+configureLspServiceLifecycle({
+  create: (generationHandoff) => new LSPService(generationHandoff, process.cwd()),
+  beforeReset: (options) => {
+    abortDeferredLspWork(`lsp service reset: ${options.reason ?? "unspecified"}`);
+    resetLspLaunchAvailabilityGeneration();
+    if (options.reason === "session_start") {
+      resetClassicTsRepairGuard();
+    }
+  },
+  destroy: (service, options) => service.shutdown(options)
+});
+export function getLSPService() {
+  return getOwnedLspService();
+}
+export function peekLSPService() {
+  return peekOwnedLspService();
+}
+export async function hasAuxiliaryLspPublishedForRoot(serverId, filePath) {
+  return getLSPService().hasServerPublishedForFileRoot(serverId, filePath);
+}
+export async function notifyExternalFileChange(filePath, type) {
+  return getLSPService().notifyExternalFileChange(filePath, type);
+}
+export async function resyncGitChangedFiles(changedPaths) {
+  return getLSPService().resyncGitChangedFiles(changedPaths);
+}
+export function resetLSPService(options = {}) {
+  if (options.reason === "session_start") {
+    resetClassicTsRepairGuard();
+    clearWorkspaceSweepHoldForSessionStart();
+  }
+  resetOwnedLspService(options);
+}
+export function __collectWorkspaceDiagnosticFilesForTest(root, maxFiles, signal, homeDir) {
+  return collectWorkspaceDiagnosticFiles(path.resolve(root), maxFiles ?? getMaxWorkspaceDiagnosticFiles(), signal, homeDir);
+}