@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -16,9 +16,9 @@ import {
   recordDegradation,
   recordDegradationOnce
 } from "../degradation-ledger.js";
+import { assertInstallAllowed } from "../project-trust.js";
 import {
   isLspSpawnAllowedByTrust,
-  assertInstallAllowed,
   projectTrustDenialReason
 } from "../project-trust.js";
 import { shouldPreferPullOnlyDiagnostics } from "../lsp-budget.js";
@@ -36,6 +36,7 @@ import {
   fingerprintDocumentContent
 } from "./document-drift.js";
 import {
+  captureAuxPublicationBacklog,
   markPendingAuxiliaryCoverage,
   napiFallbackCoveredSince
 } from "./pending-aux-coverage.js";
@@ -65,31 +66,68 @@ import {
   getSessionRootsForTelemetry,
   isOutsideAllSessionRoots
 } from "./session-roots.js";
-import { getProcessSingleton } from "../process-singletons.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 {
-  LSP_SERVERS,
   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,
@@ -187,10 +225,25 @@ async function runRenameNotify(send, timeoutMs) {
   }
 }
 const DEFAULT_LSP_CLIENT_CEILING = 24;
-const DEFAULT_TS_IDLE_EVICT_MS = 20 * 60000;
-export function getTypeScriptIdleEvictMs() {
-  const parsed = Number.parseInt(process.env.DM_LENS_TS_IDLE_EVICT_MS ?? "", 10);
-  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_TS_IDLE_EVICT_MS;
+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);
@@ -206,6 +259,12 @@ function documentIsOpenOn(client, filePath) {
     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;
@@ -232,28 +291,7 @@ function readTsserverSyncGraceMs() {
     return 300;
   return parsed;
 }
-function readEnvAuxGraceMs() {
-  const raw = process.env.DM_LENS_AUX_GRACE_MS;
-  if (raw === undefined)
-    return;
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed < 0)
-    return;
-  return parsed;
-}
-const DEFAULT_AUX_GRACE_CEILING_MS = 2000;
-const MAX_ADAPTIVE_AUX_GRACE_CEILING_MS = 8000;
-const ADAPTIVE_AUX_GRACE_MARGIN_MS = 500;
-export function auxWaitBudgetMs(serverId, isCold, configuredCeilingMs, declaredWaitMs) {
-  if (configuredCeilingMs !== undefined || !isCold) {
-    return Math.min(declaredWaitMs, configuredCeilingMs ?? DEFAULT_AUX_GRACE_CEILING_MS);
-  }
-  const observedSpawnMs = getSuccessfulLspSpawnDurationMs(serverId);
-  if (observedSpawnMs === undefined || observedSpawnMs <= 0) {
-    return Math.min(declaredWaitMs, DEFAULT_AUX_GRACE_CEILING_MS);
-  }
-  return Math.min(MAX_ADAPTIVE_AUX_GRACE_CEILING_MS, Math.max(declaredWaitMs, observedSpawnMs + ADAPTIVE_AUX_GRACE_MARGIN_MS));
-}
+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);
@@ -276,25 +314,6 @@ function mergeLspDiagnostics(diagnostics) {
 function attributeDiagnostics(serverId, diagnostics) {
   return diagnostics.map((diagnostic) => ({ ...diagnostic, serverId }));
 }
-export function groupFilesByPrimaryServer(files) {
-  const byServer = new Map;
-  for (const filePath of files) {
-    const servers = getServersForFileWithConfig(filePath);
-    const primary = servers[0]?.id ?? "none";
-    const group = byServer.get(primary);
-    if (group) {
-      group.files.push(filePath);
-      if (servers.length > 1)
-        group.multiServer = true;
-    } else {
-      byServer.set(primary, {
-        files: [filePath],
-        multiServer: servers.length > 1
-      });
-    }
-  }
-  return [...byServer.values()];
-}
 export function createSweepIndexGate() {
   const seen = new Set;
   return {
@@ -306,20 +325,6 @@ export function createSweepIndexGate() {
     }
   };
 }
-export async function runPerServerGroups(groups, concurrency, processGroup, signal) {
-  let nextGroup = 0;
-  const workers = Math.min(Math.max(1, concurrency), groups.length);
-  await Promise.all(Array.from({ length: workers }, async () => {
-    while (!signal?.aborted) {
-      const gi = nextGroup;
-      nextGroup += 1;
-      if (gi >= groups.length)
-        break;
-      await processGroup(groups[gi]);
-    }
-    return true;
-  }));
-}
 const WORKSPACE_DIAGNOSTICS_CONCURRENCY = 8;
 const WORKSPACE_SWEEP_PREOPEN_CHUNK_SIZE = (() => {
   const raw = Number(process.env.DM_LENS_LSP_WORKSPACE_PREOPEN_CHUNK);
@@ -333,7 +338,7 @@ function notifyWriteBudgetMs() {
   return Number.isFinite(raw) && raw > 0 ? raw : 2000;
 }
 function primaryServerWaitFloorMs(filePath, maxWaitMs) {
-  const serverWaitOverrideMs = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary").reduce((max, server) => Math.max(max, server.clientWaitTimeoutMs ?? 0), 0);
+  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;
@@ -351,15 +356,6 @@ function notifyStallCpuSampleMs() {
   return Number.isFinite(raw) && raw > 0 ? raw : 1200;
 }
 const NOTIFY_STALL_CPU_BUSY_FLOOR_PERCENT = 10;
-const AUX_NOTIFY_INFLIGHT_DEFAULT = 8;
-function auxNotifyInflightLimit(info) {
-  const perServer = info.notifyInflightLimit;
-  if (typeof perServer === "number" && Number.isFinite(perServer) && perServer > 0) {
-    return Math.floor(perServer);
-  }
-  const raw = Number(process.env.DM_LENS_LSP_AUX_NOTIFY_INFLIGHT);
-  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : AUX_NOTIFY_INFLIGHT_DEFAULT;
-}
 function workspacePullBudgetMs() {
   const raw = Number(process.env.DM_LENS_LSP_WORKSPACE_PULL_MS);
   return Number.isFinite(raw) && raw > 0 ? raw : 30000;
@@ -408,8 +404,10 @@ async function collectWorkspaceDiagnosticFiles(root, maxFiles = getMaxWorkspaceD
 }
 
 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;
@@ -439,8 +437,10 @@ export class LSPService {
   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;
-  typeScriptIdleTimers = new Map;
+  idleEvictionTimers = new Map;
   clientSpawnGate = Promise.resolve();
   isDestroyed = false;
   shutdownController = new AbortController;
@@ -507,11 +507,77 @@ export class LSPService {
       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;
-    if (isOutsideAllSessionRoots(filePath))
+    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()))
@@ -549,6 +615,32 @@ export class LSPService {
   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;
@@ -590,10 +682,10 @@ export class LSPService {
       for (const [key] of keyed) {
         this.clientLeases.set(key, (this.clientLeases.get(key) ?? 0) + 1);
       }
-      return keyed.map(([key]) => key);
+      return keyed.map(([key, entry]) => ({ key, server: entry.info }));
     });
   }
-  releaseClientLease(key) {
+  releaseClientLease(key, server) {
     const remaining = (this.clientLeases.get(key) ?? 1) - 1;
     if (remaining > 0) {
       this.clientLeases.set(key, remaining);
@@ -602,7 +694,7 @@ export class LSPService {
     this.clientLeases.delete(key);
     if (this.state.clients.has(key)) {
       this.clientLastUsedAt.set(key, Date.now());
-      this.scheduleTypeScriptIdleEviction(key);
+      this.scheduleIdleEviction(key, server);
     }
   }
   async withClientForFileUse(filePath, maxWaitMs, hardCapMs, use) {
@@ -616,7 +708,7 @@ export class LSPService {
       try {
         return await use(entry);
       } finally {
-        this.releaseClientLease(leaseKey);
+        this.releaseClientLease(leaseKey, entry.info);
       }
     }
     return;
@@ -639,20 +731,30 @@ export class LSPService {
     const [victimKey, victimClient] = victim;
     this.releaseOutstandingAuxNotifyWrite(victimKey);
     await victimClient.shutdown({ reason: "client_ceiling_lru" });
-    this.state.clients.delete(victimKey);
-    this.state.clientSpawnedAt.delete(victimKey);
-    this.state.demonstratedReady.delete(victimKey);
-    this.state.demonstratedCold.delete(victimKey);
-    this.clientLastUsedAt.delete(victimKey);
-    this.clearTypeScriptIdleTimer(victimKey);
+    this.retireClient(victimKey);
     logSessionStart(`lsp client ceiling ${getLspClientCeiling()}: evicted idle LRU ${victimKey}`);
     return true;
   }
-  clearTypeScriptIdleTimer(key) {
-    const timer = this.typeScriptIdleTimers.get(key);
+  clearIdleEvictionTimer(key) {
+    const timer = this.idleEvictionTimers.get(key);
     if (timer)
       clearTimeout(timer);
-    this.typeScriptIdleTimers.delete(key);
+    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);
@@ -662,13 +764,15 @@ export class LSPService {
     this.outstandingAuxNotifyWrites.delete(key);
     current.resolveSettled();
   }
-  scheduleTypeScriptIdleEviction(key) {
-    if (!key.startsWith("typescript:"))
+  scheduleIdleEviction(key, server) {
+    if (server.idleEviction !== "transparent" && !this.adoptedClientKeys.has(key))
       return;
-    this.clearTypeScriptIdleTimer(key);
+    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.typeScriptIdleTimers.delete(key);
+      this.idleEvictionTimers.delete(key);
       this.withClientSpawnGate(async () => {
         if (this.isDestroyed)
           return;
@@ -676,43 +780,32 @@ export class LSPService {
         if (!client?.isAlive())
           return;
         if (client.isBusy?.() === true || (this.clientLeases.get(key) ?? 0) > 0 || (this.clientLastUsedAt.get(key) ?? 0) !== lastUsedAt) {
-          this.scheduleTypeScriptIdleEviction(key);
+          this.scheduleIdleEviction(key, server);
           return;
         }
-        this.releaseOutstandingAuxNotifyWrite(key);
-        this.state.clients.delete(key);
-        this.state.clientSpawnedAt.delete(key);
-        this.state.demonstratedReady.delete(key);
-        this.state.demonstratedCold.delete(key);
-        this.clientLastUsedAt.delete(key);
+        this.retireClient(key);
         try {
-          await client.shutdown({ reason: "typescript_idle_eviction" });
+          await client.shutdown({ reason: "idle_eviction" });
         } catch {}
-        logSessionStart(`lsp typescript idle eviction: released ${key}`);
+        logSessionStart(`lsp idle eviction: released ${key}`);
         recordDegradation({
-          kind: "ts-idle-eviction",
+          kind: "lsp-idle-eviction",
           subject: key,
-          reason: "idle TypeScript client released to bound memory"
+          reason: "idle LSP client released to bound memory"
         });
       }).catch(() => {});
-    }, getTypeScriptIdleEvictMs());
+    }, idleMs);
     timer.unref?.();
-    this.typeScriptIdleTimers.set(key, timer);
+    this.idleEvictionTimers.set(key, timer);
   }
-  fingerprintContent(content) {
-    if (content.length <= 96) {
-      return `${content.length}:${content}`;
-    }
-    return `${content.length}:${content.slice(0, 48)}:${content.slice(-48)}`;
-  }
-  shouldSkipTouch(filePath, content, clientScope, waitForDiagnostics, serverIds) {
+  shouldSkipTouch(filePath, contentFingerprint, clientScope, waitForDiagnostics, spawned) {
     if (waitForDiagnostics)
       return false;
-    if (serverIds.length === 0)
+    if (spawned.length === 0)
       return false;
-    return serverIds.every((serverId) => this.shouldSkipNotify(filePath, content, clientScope, serverId));
+    return spawned.every((entry) => this.shouldSkipNotify(filePath, contentFingerprint, clientScope, entry.info.id, entry.client));
   }
-  shouldSkipNotify(filePath, content, clientScope, serverId) {
+  shouldSkipNotify(filePath, contentFingerprint, clientScope, serverId, client) {
     if (TOUCH_DEBOUNCE_MS <= 0)
       return false;
     const previous = this.recentTouches.get(this.recentTouchKey(filePath, clientScope, serverId));
@@ -721,18 +814,21 @@ export class LSPService {
     const now = Date.now();
     if (now - previous.touchedAt > TOUCH_DEBOUNCE_MS)
       return false;
-    return previous.fingerprint === this.fingerprintContent(content);
+    if (previous.client.deref() !== client)
+      return false;
+    return previous.fingerprint === contentFingerprint();
   }
   recentTouchKey(filePath, clientScope, serverId) {
     return `${normalizeMapKey(filePath)}:${clientScope}:${serverId}`;
   }
-  markTouched(filePath, content, clientScope, serverId) {
+  markTouched(filePath, contentFingerprint, clientScope, serverId, client) {
     const key = this.recentTouchKey(filePath, clientScope, serverId);
     const now = Date.now();
     this.recentTouches.set(key, {
-      fingerprint: this.fingerprintContent(content),
+      fingerprint: contentFingerprint,
       touchedAt: now,
-      clientScope
+      clientScope,
+      client: new WeakRef(client)
     });
     if (this.recentTouches.size > 800) {
       for (const [k, v] of this.recentTouches) {
@@ -748,6 +844,11 @@ export class LSPService {
       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);
@@ -758,6 +859,8 @@ export class LSPService {
   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);
@@ -771,11 +874,11 @@ export class LSPService {
   async demoteNotifyStallCpuGuarded(key, entry, filePath, reason) {
     if (this.state.clients.get(key) !== entry.client)
       return;
-    this.clearTypeScriptIdleTimer(key);
+    this.clearIdleEvictionTimer(key);
     const verdict = await this.notifyStallCpuVerdict(entry);
     if (verdict.cpuVerdict === "busy") {
       if (this.state.clients.get(key) === entry.client) {
-        this.scheduleTypeScriptIdleEviction(key);
+        this.scheduleIdleEviction(key, entry.info);
       }
       this.logNotifyStallCpuBusy(key, entry, filePath, 0, verdict);
       return;
@@ -830,17 +933,10 @@ export class LSPService {
   demoteForNotifyStall(key, entry, filePath, reason) {
     if (this.state.clients.get(key) !== entry.client)
       return;
-    this.notifyWriteBackpressureStreak.delete(key);
-    this.releaseOutstandingAuxNotifyWrite(key);
-    this.auxNotifyInflight.delete(key);
     this.state.broken.set(key, Date.now() + BROKEN_BASE_COOLDOWN_MS);
     this.notifyStallDemotions.set(key, Date.now());
     entry.client.shutdown().catch(() => {});
-    this.state.clients.delete(key);
-    this.state.clientSpawnedAt.delete(key);
-    this.state.demonstratedReady.delete(key);
-    this.clientLastUsedAt.delete(key);
-    this.clearTypeScriptIdleTimer(key);
+    this.retireClient(key);
     logLatency({
       type: "phase",
       phase: "lsp_notify_backpressure_broken",
@@ -934,7 +1030,7 @@ export class LSPService {
       return false;
     if (record.gateOpen)
       return false;
-    return record.unacked >= auxNotifyInflightLimit(entry.info);
+    return record.unacked >= serverTraits(entry.info).notifyInflightLimit;
   }
   async paceAuxNotify(key, entry, filePath, waitMs, context) {
     const record = this.auxNotifyInflight.get(key);
@@ -946,10 +1042,11 @@ export class LSPService {
     }
     if (record.gateOpen)
       return;
-    const limit = auxNotifyInflightLimit(entry.info);
+    const traits = serverTraits(entry.info);
+    const limit = traits.notifyInflightLimit;
     if (record.unacked < limit)
       return;
-    const ping = entry.client.pingLiveness;
+    const ping = traits.replyOrdering === "threaded" ? undefined : entry.client.pingLiveness;
     if (!ping) {
       record.unacked = 0;
       return;
@@ -1134,7 +1231,7 @@ export class LSPService {
     const attached = new Set(spawned.map((entry) => entry.info.id));
     const skipped = [];
     for (const server of getServersForFileWithConfig(filePath)) {
-      if (server.role !== "auxiliary")
+      if (!isAuxiliary(server))
         continue;
       if (attached.has(server.id))
         continue;
@@ -1179,10 +1276,19 @@ export class LSPService {
     }
     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) => s.role !== "auxiliary");
+    const servers = getServersForFileWithConfig(filePath).filter((s) => !isAuxiliary(s));
     const rootMemo = new Map;
     const partitionCandidates = async () => {
       const resolved = await Promise.all(servers.map(async (server) => {
@@ -1378,7 +1484,7 @@ export class LSPService {
     }
     return waitResult;
   }
-  async getClientsForFile(filePath, excludeServerIds, resolvedRoots) {
+  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)
@@ -1387,6 +1493,9 @@ export class LSPService {
       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) => {
@@ -1405,7 +1514,7 @@ export class LSPService {
   async getAuxiliaryClientsForFile(filePath, enabledIds, onOutcome, maxWaitMs, signal, hook) {
     if (this.checkDestroyed() || enabledIds.size === 0)
       return [];
-    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role === "auxiliary" && enabledIds.has(s.id));
+    const servers = getServersForFileWithConfig(filePath).filter((s) => isAuxiliary(s) && enabledIds.has(s.id));
     if (servers.length === 0)
       return [];
     const rootMemo = new Map;
@@ -1524,17 +1633,16 @@ export class LSPService {
       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()) {
-        existing.notify.watchedFileChange(filePath, type);
-      }
+      this.notifyLiveClientsForServer(server.id, filePath, type, `${server.id}:${normalizeMapKey(root)}`, true);
     }
   }
-  async resyncGitChangedFiles(changedPaths) {
-    if (this.checkDestroyed() || changedPaths.length === 0)
-      return;
+  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)) {
@@ -1547,9 +1655,12 @@ export class LSPService {
         }
       }
       targets.add(resolved);
+      changed.set(changedPath, resolved);
     }
     const openTargets = [...targets].filter((filePath) => this.hasLiveClientHoldingDocument(filePath));
-    this.documentDrift.enqueueResync(openTargets);
+    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",
@@ -1562,17 +1673,23 @@ export class LSPService {
         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) => {
+      resync: async (filePath, content, _driftAgeMs, readStamp, saved) => {
         await this.touchFile(filePath, content, {
           diagnostics: "none",
           source: "drift_resync",
           clientScope: "all",
-          excludeServerIds: await this.serverIdsNotHoldingDocument(filePath)
+          excludeServerIds: await this.serverIdsNotHoldingDocument(filePath),
+          readStamp,
+          saved: saved === true
         });
         return this.documentDrift.peek(filePath)?.fingerprint === fingerprintDocumentContent(content);
       },
@@ -1624,7 +1741,7 @@ export class LSPService {
     }
     return exclude;
   }
-  recordFullyCoveredSync(filePath, content, targeted, allWritesLanded, at) {
+  recordFullyCoveredSync(filePath, content, targeted, allWritesLanded, at, contentFingerprint) {
     if (!allWritesLanded || targeted.length === 0)
       return;
     const targetedClients = new Set(targeted.map((entry) => entry.client));
@@ -1636,7 +1753,7 @@ export class LSPService {
       if (documentIsOpenOn(client, filePath))
         return;
     }
-    this.documentDrift.recordSynced(filePath, content, at);
+    this.documentDrift.recordSynced(filePath, content, at, contentFingerprint?.() ?? fingerprintDocumentContent(content));
   }
   noteSpawnVerdict(key, verdict) {
     this.lastSpawnVerdict.set(key, verdict);
@@ -1664,12 +1781,28 @@ export class LSPService {
     const root = await this.resolveServerRootOnce(server, filePath, rootMemo);
     if (!root || this.checkDestroyed())
       return;
-    if (server.role !== "auxiliary") {
+    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)}`, {
@@ -1709,7 +1842,7 @@ export class LSPService {
       if (existing.isAlive()) {
         this.unavailableLogged.delete(key);
         this.clientLastUsedAt.set(key, Date.now());
-        this.scheduleTypeScriptIdleEviction(key);
+        this.scheduleIdleEviction(key, server);
         if (!this.warmStartLogged.has(key)) {
           logSessionStart(`lsp warm-start ${server.id}: reused root=${root} file=${filePath}`);
           this.warmStartLogged.add(key);
@@ -1737,10 +1870,7 @@ export class LSPService {
       try {
         await existing.shutdown();
       } catch {}
-      this.state.clients.delete(key);
-      this.state.clientSpawnedAt.delete(key);
-      this.clientLastUsedAt.delete(key);
-      this.clearTypeScriptIdleTimer(key);
+      this.retireClient(key);
       this.state.broken.delete(key);
       if (wasIntentional) {} else {
         if (this.recordRuntimeExitWindow(key, exitedAt, uptimeMs)) {
@@ -1841,7 +1971,20 @@ export class LSPService {
     return process.env.DM_LENS_DISABLE_LSP_INSTALL !== "1";
   }
   async spawnClient(server, root, key, filePath, allowInstall) {
-    if (!isLspSpawnAllowedByTrust()) {
+    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;
@@ -1851,7 +1994,12 @@ export class LSPService {
     logSessionStart(`lsp spawn ${server.id}: start root=${root} install=${allowInstall ? "enabled" : "disabled"} file=${filePath}`);
     recordLsp(server.id, root, "spawn_start");
     try {
-      const spawned = await server.spawn(root, { allowInstall });
+      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();
@@ -1882,7 +2030,7 @@ export class LSPService {
         return;
       }
       const override = getServerInitOverride(server.id, filePath);
-      const mergedInit = mergeInitializationOptions(spawned.initialization, override?.initializationOptions);
+      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);
@@ -1910,12 +2058,13 @@ export class LSPService {
         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.scheduleTypeScriptIdleEviction(key);
+      this.scheduleIdleEviction(key, server);
       this.failureCounts.delete(key);
       if (isOptionalServer) {
         this.optionalDisabled.delete(key);
@@ -1972,8 +2121,8 @@ export class LSPService {
     const startedAt = Date.now();
     await this.withClientForFileUse(filePath, undefined, options?.spawnBudgetMs, async (spawned) => {
       const languageId = getLanguageId(filePath) ?? "plaintext";
-      await spawned.client.notify.open(filePath, content, languageId, options?.preserveDiagnostics);
-      this.recordFullyCoveredSync(filePath, content, [spawned], true, startedAt);
+      const sent = await spawned.client.notify.open(filePath, content, languageId, options?.preserveDiagnostics);
+      this.recordFullyCoveredSync(filePath, content, [spawned], sent !== false, startedAt);
     });
   }
   async updateFile(filePath, content) {
@@ -2000,7 +2149,19 @@ export class LSPService {
       });
       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);
@@ -2014,6 +2175,7 @@ export class LSPService {
     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) => {
@@ -2024,7 +2186,7 @@ export class LSPService {
     let spawned;
     let serverCountAttempted;
     if (useAllClients) {
-      const result = await this.getClientsForFile(filePath, options.excludeServerIds, resolvedPrimaryRoots);
+      const result = await this.getClientsForFile(filePath, options.excludeServerIds, resolvedPrimaryRoots, attemptedAuxiliaryRoots);
       spawned = result.clients;
       serverCountAttempted = result.serverCountAttempted;
     } else if (clientScope === "with-auxiliary") {
@@ -2071,7 +2233,8 @@ export class LSPService {
           source,
           maxClientWaitMs: options.maxClientWaitMs,
           failureKind,
-          ...waitSkipReasons.size > 0 ? { reason: [...waitSkipReasons][0] } : {}
+          ...waitSkipReasons.size > 0 ? { reason: [...waitSkipReasons][0] } : {},
+          candidates: this.describeTouchCandidates(filePath, resolvedPrimaryRoots, attemptedAuxiliaryRoots)
         }
       });
       return;
@@ -2079,7 +2242,7 @@ export class LSPService {
     const leaseKeys = await this.acquireClientLeases(spawned, filePath);
     if (!leaseKeys) {
       if (this.checkDestroyed()) {
-        const primaryServerIds = spawned.filter((entry) => entry.info.role !== "auxiliary").map((entry) => entry.info.id);
+        const primaryServerIds = spawned.filter((entry) => !isAuxiliary(entry.info)).map((entry) => entry.info.id);
         return {
           diags: [],
           inconclusive: true,
@@ -2092,8 +2255,7 @@ export class LSPService {
       return this.touchFile(filePath, content, options);
     }
     try {
-      const spawnedServerIds = spawned.map((entry) => entry.info.id);
-      if (this.shouldSkipTouch(filePath, content, clientScope, diagnosticsMode !== "none", spawnedServerIds)) {
+      if (this.shouldSkipTouch(filePath, contentFingerprint, clientScope, diagnosticsMode !== "none", spawned)) {
         logLatency({
           type: "phase",
           phase: "lsp_touch_file",
@@ -2113,15 +2275,15 @@ export class LSPService {
       }
       const languageId = getLanguageId(filePath) ?? "plaintext";
       const silent = options.silent ?? false;
-      const notifySkippedServerIds = new Set(spawnedServerIds.filter((serverId) => this.shouldSkipNotify(filePath, content, clientScope, serverId)));
+      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 = this.hashContent(content);
+      const touchContentHash = contentHash;
       const bindingMatchesTouchContent = (binding) => binding?.contentHash === touchContentHash;
       const carriedAuxiliary = options.collectDiagnostics ? spawned.flatMap((entry) => {
-        if (entry.info.role !== "auxiliary")
+        if (!isAuxiliary(entry.info))
           return [];
         const binding = entry.client.getDiagnosticBinding?.(filePath);
         if (!bindingMatchesTouchContent(binding))
@@ -2129,16 +2291,17 @@ export class LSPService {
         const diags = entry.client.getDiagnostics(filePath);
         return diags.length > 0 ? [{ serverId: entry.info.id, diags, binding }] : [];
       }) : [];
-      const auxPublishedThisContent = new Set(spawned.flatMap((entry) => entry.info.role === "auxiliary" && bindingMatchesTouchContent(entry.client.getDiagnosticBinding?.(filePath)) ? [entry.info.id] : []));
+      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?.info.role !== "auxiliary")
+        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;
@@ -2146,7 +2309,7 @@ export class LSPService {
           if (notifySkippedServerIds.has(entry.info.id))
             return;
           const clientKey = await this.demonstratedReadyKeyFor(entry.info, filePath);
-          const gated = entry.info.role === "auxiliary" && clientKey !== undefined;
+          const gated = isAuxiliary(entry.info) && clientKey !== undefined;
           let slot;
           if (gated && clientKey) {
             const barrierStartedAt = Date.now();
@@ -2180,7 +2343,7 @@ export class LSPService {
           let rejected = false;
           try {
             const writeStartedAt = Date.now();
-            const writePromise = entry.client.notify.open(filePath, content, languageId, undefined, silent, options.saved === true).then(() => true);
+            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);
             }
@@ -2207,7 +2370,9 @@ export class LSPService {
           if (wrote === true) {
             if (clientKey)
               this.notifyWriteBackpressureStreak.delete(clientKey);
-            this.markTouched(filePath, content, clientScope, entry.info.id);
+            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) {
@@ -2215,7 +2380,7 @@ export class LSPService {
             }
           }
         }));
-        this.recordFullyCoveredSync(filePath, content, spawned, notifyWriteTimedOutServerIds.length === 0 && notifyDeferredServerIds.length === 0, startedAt);
+        this.recordFullyCoveredSync(filePath, content, spawned, notifyWriteTimedOutServerIds.length === 0 && notifyDeferredServerIds.length === 0 && supersededServerIds.length === 0, startedAt, contentFingerprint);
         if (notifyWriteTimedOutServerIds.length > 0) {
           logLatency({
             type: "phase",
@@ -2232,7 +2397,7 @@ export class LSPService {
         }
       }
       const notifyWriteTimedOut = notifyWriteTimedOutServerIds.length > 0;
-      const primaryEntries = spawned.filter((entry) => entry.info.role !== "auxiliary");
+      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;
@@ -2327,7 +2492,7 @@ export class LSPService {
           } catch {}
         }
         const waitStartedAt = Date.now();
-        const hasTouchAuxiliaries = clientScope === "with-auxiliary" && options.collectDiagnostics === true && spawned.some((e) => e.info.role === "auxiliary");
+        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";
@@ -2355,7 +2520,7 @@ export class LSPService {
         const perServerWaitTimeouts = spawned.map((entry, entryIndex) => {
           const declaredServerTimeout = perServerDeclaredTimeouts[entryIndex];
           const observedSpawnMs = getSuccessfulLspSpawnDurationMs(entry.client.serverId);
-          return hasTouchAuxiliaries && entry.info.role === "auxiliary" && coldAuxiliaryServerIds.has(entry.client.serverId) && (configuredAuxCeilingMs !== undefined || observedSpawnMs !== undefined && observedSpawnMs > 0) ? auxWaitBudgetMs(entry.client.serverId, true, configuredAuxCeilingMs, declaredServerTimeout) : perServerDeclaredTimeouts[entryIndex];
+          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;
@@ -2376,10 +2541,10 @@ export class LSPService {
           }
         };
         const perServerRaceBudgets = spawned.map((entry, entryIndex) => {
-          return hasTouchAuxiliaries && entry.info.role === "auxiliary" ? auxWaitBudgetMs(entry.client.serverId, coldAuxiliaryServerIds.has(entry.client.serverId), configuredAuxCeilingMs, perServerDeclaredTimeouts[entryIndex]) : perServerDeclaredTimeouts[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 && entry.info.role === "auxiliary" && this.isAuxiliaryWaitDemoted(entry.info.id, entry.client.root ?? filePath)) {
+          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)) {
@@ -2464,8 +2629,8 @@ export class LSPService {
         });
         let pushWaitSettled = false;
         const pushWait = hasTouchAuxiliaries ? (() => {
-          const primaryWaits = perServerWaits.filter((_, i) => spawned[i].info.role !== "auxiliary");
-          const auxWaits = perServerWaits.map((p, i) => spawned[i].info.role === "auxiliary" ? {
+          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,
@@ -2537,7 +2702,9 @@ export class LSPService {
             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;
-              markPendingAuxiliaryCoverage(filePath, collectLaterServerIds, Date.now());
+              for (const serverId of collectLaterServerIds) {
+                markPendingAuxiliaryCoverage(filePath, [serverId], startedAt, undefined, undefined, captureAuxPublicationBacklog(auxWaits.find((aux) => aux.serverId === serverId)?.client, filePath));
+              }
             }
             logLatency({
               type: "phase",
@@ -2565,7 +2732,7 @@ export class LSPService {
               return new Promise(() => {});
             }
             try {
-              const result = await attemptTsserverSyncDiagnostics(filePath, this);
+              const result = await attemptTsserverSyncDiagnostics(filePath, tsserverSyncChannel(primaryClient));
               if (result === undefined || pushWaitSettled) {
                 return new Promise(() => {});
               }
@@ -2609,7 +2776,7 @@ export class LSPService {
           ...new Set(diagnosticsUnsupportedServerIds)
         ];
         if (!hasTouchAuxiliaries && options.collectDiagnostics === true) {
-          const auxEntries = spawned.filter((entry) => entry.info.role === "auxiliary");
+          const auxEntries = spawned.filter((entry) => isAuxiliary(entry.info));
           if (auxEntries.length > 0) {
             const outcomes = auxEntries.map((entry) => {
               const baseline = diagnosticBaselines.get(entry.client);
@@ -2661,9 +2828,9 @@ export class LSPService {
           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) => entry.info.role !== "auxiliary").map((e) => e.info.id);
-          const hasWaitedPrimary = waited.some((entry) => entry.info.role !== "auxiliary");
-          const hasUnsupportedPrimary = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && entry.info.role !== "auxiliary"));
+          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({
@@ -2720,7 +2887,7 @@ export class LSPService {
       }
       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) => entry.info.role === "auxiliary" && notifyWriteTimedOutServerIds.includes(entry.info.id) && !auxCoveredAtMerge.has(entry.info.id)).map((entry) => entry.info.id);
+      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
@@ -2730,9 +2897,10 @@ export class LSPService {
         ...carriedAuxiliary.flatMap((entry) => attributeDiagnostics(entry.serverId, entry.diags))
       ]) : undefined;
       let syncConfirmed = tsserverSyncConfirmed !== undefined;
-      if (diagnosticsTimedOut && tsserverSyncEligible && collected !== undefined && collected.length === 0) {
+      const syncClient = spawned[0]?.client;
+      if (diagnosticsTimedOut && tsserverSyncEligible && syncClient !== undefined && collected !== undefined && collected.length === 0) {
         try {
-          const syncResult = await attemptTsserverSyncDiagnostics(filePath, this);
+          const syncResult = await attemptTsserverSyncDiagnostics(filePath, tsserverSyncChannel(syncClient));
           if (syncResult !== undefined) {
             diagnosticsTimedOut = false;
             retractPrimaryTimeoutAttribution();
@@ -2787,7 +2955,7 @@ export class LSPService {
       });
       const inconclusive = verdict.inconclusive;
       const brokenSkippedServerIds = collected !== undefined ? await this.brokenSkippedAuxiliaryServerIds(filePath, clientScope, options, spawned) : [];
-      const auxNoAnswerServerIds = spawned.filter((entry) => entry.info.role === "auxiliary" && (diagnosticsUnansweredServerIds.includes(entry.info.id) || notifyWriteTimedOutServerIds.includes(entry.info.id)) && !auxCoveredAtMerge.has(entry.info.id)).map((entry) => entry.info.id);
+      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 ?? [],
@@ -2835,7 +3003,7 @@ export class LSPService {
           if (uncoveredServerIds.has(entry.info.id))
             continue;
           const key = await this.demonstratedReadyKeyFor(entry.info, filePath);
-          if (key)
+          if (key && this.state.clients.get(key) === entry.client)
             this.markDemonstratedReadyKey(key);
         }
       }
@@ -2850,7 +3018,7 @@ export class LSPService {
         }
       }
       const result = { diags: collected ?? [] };
-      const primaryDiagnosticsUnsupported = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && entry.info.role !== "auxiliary"));
+      const primaryDiagnosticsUnsupported = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && !isAuxiliary(entry.info)));
       if (diagnosticsUnsupportedServerIds.length > 0) {
         result.diagnosticsUnsupportedServerIds = diagnosticsUnsupportedServerIds;
       }
@@ -2882,6 +3050,9 @@ export class LSPService {
       if (lateDeliveryPending.length > 0) {
         result.deferredServerIds = lateDeliveryPending;
       }
+      if (supersededServerIds.length > 0) {
+        result.supersededServerIds = supersededServerIds;
+      }
       logLatency({
         type: "phase",
         phase: "lsp_touch_file",
@@ -2902,6 +3073,7 @@ export class LSPService {
           ...notifyWriteTimedOutServerIds.length > 0 && {
             notifyWriteTimedOutServerIds
           },
+          ...supersededServerIds.length > 0 && { supersededServerIds },
           diagnosticsTimedOut,
           inconclusive,
           ...verdict.inconclusiveServerIds && {
@@ -2929,12 +3101,14 @@ export class LSPService {
       });
       return result;
     } finally {
-      for (const key of leaseKeys)
-        this.releaseClientLease(key);
+      for (const lease of leaseKeys)
+        this.releaseClientLease(lease.key, lease.server);
     }
   }
   async findOutsideProjectRoot(filePath) {
-    if (!isOutsideAllSessionRoots(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));
@@ -3044,16 +3218,16 @@ export class LSPService {
     });
     const graceMs = diagnosticsMode === "document" ? 0 : EARLY_UNBLOCK_GRACE_MS;
     const diagDescriptors = spawned.map((entry) => {
-      if (entry.info.role !== "auxiliary")
-        return { role: "primary" };
+      if (!isAuxiliary(entry.info))
+        return { role: entry.info.role };
       const strategy = getStrategy(entry.info.id, entry.client.getLaunchVariant?.());
-      return { role: "auxiliary", budgetMs: strategy.aggregateWaitMs };
+      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() ?? 2000
+      auxGraceMs: readEnvAuxGraceMs() ?? DEFAULT_AUX_GRACE_CEILING_MS
     });
     const earlyUnblockedCount = spawned.length - perServer.length;
     const perServerFull = spawned.map((entry) => {
@@ -3218,8 +3392,7 @@ export class LSPService {
         continue;
       const separator = key.indexOf(":");
       const serverId = separator >= 0 ? key.slice(0, separator) : key;
-      const role = LSP_SERVERS.find((s) => s.id === serverId)?.role;
-      if (role === "auxiliary") {
+      if (isAuxiliary(getServerById(serverId))) {
         if (!auxFallback)
           auxFallback = { client, serverId };
         continue;
@@ -3349,6 +3522,7 @@ export class LSPService {
           diagnosticsUnsupported: this.state.diagnosticsUnsupported.has(server.id),
           advertisedCommands: client.getAdvertisedCommands(),
           rawCapabilityKeys: client.getRawCapabilityKeys?.() ?? [],
+          textDocumentSave: textDocumentSaveOf(client),
           launchVariant: client.getLaunchVariant?.()
         });
       }
@@ -3369,6 +3543,7 @@ export class LSPService {
         diagnosticsUnsupported: this.state.diagnosticsUnsupported.has(serverId),
         advertisedCommands: client.getAdvertisedCommands(),
         rawCapabilityKeys: client.getRawCapabilityKeys?.() ?? [],
+        textDocumentSave: textDocumentSaveOf(client),
         launchVariant: client.getLaunchVariant?.()
       });
     }
@@ -3499,7 +3674,7 @@ export class LSPService {
       oldUri: client.getDocumentUri(oldFilePath)
     }));
     const closeFailures = [];
-    await Promise.all(openDocuments.map(async ({ serverId, client }) => {
+    await Promise.all(activeClients.map(async ({ serverId, client }) => {
       const result = await runRenameNotify(() => client.closeDocument(oldFilePath), RENAME_NOTIFY_TIMEOUT_MS);
       if (!result.ok) {
         closeFailures.push({
@@ -3520,7 +3695,11 @@ export class LSPService {
       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), RENAME_NOTIFY_TIMEOUT_MS);
+        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,
@@ -3665,19 +3844,36 @@ export class LSPService {
     if (this.checkDestroyed() || options.signal?.aborted) {
       return { performedWarmup: false, failedServerIds: [] };
     }
-    const servers = getServersForFileWithConfig(representativeFile).filter((s) => s.role !== "auxiliary");
+    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 alreadyWarm = keys.every((key) => key === undefined || this.state.demonstratedReady.has(key));
+    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 || this.state.demonstratedReady.has(key))
+      if (key === undefined || !isColdAt(i))
         continue;
       if (this.state.demonstratedCold.has(key)) {
         cachedColdServerIds.push(servers[i].id);
@@ -3724,10 +3920,8 @@ export class LSPService {
     const stillColdServerIds = () => {
       const cold = [];
       for (let i = 0;i < servers.length; i++) {
-        const key = keys[i];
-        if (key !== undefined && !this.state.demonstratedReady.has(key)) {
+        if (isColdAt(i))
           cold.push(servers[i].id);
-        }
       }
       return cold;
     };
@@ -3792,6 +3986,7 @@ export class LSPService {
     };
     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) {
@@ -3811,7 +4006,7 @@ export class LSPService {
     if (failedServerIds.length > 0) {
       for (let i = 0;i < servers.length; i++) {
         const key = keys[i];
-        if (key !== undefined && failedServerIds.includes(servers[i].id)) {
+        if (key !== undefined && failedServerIds.includes(servers[i].id) && this.state.clients.get(key) === warmedClients[i]) {
           this.state.demonstratedCold.add(key);
         }
       }
@@ -3906,8 +4101,18 @@ export class LSPService {
     }
     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";
@@ -3933,6 +4138,7 @@ export class LSPService {
         if (signal?.aborted)
           return;
         let content;
+        noteScanStat(filePath);
         try {
           content = await nodeFs.promises.readFile(filePath, "utf-8");
         } catch {
@@ -3944,16 +4150,17 @@ export class LSPService {
           const { clients } = await this.getClientsForFile(filePath, WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS);
           for (const entry of clients) {
             let auxKey;
-            if (entry.info.role === "auxiliary") {
+            if (isAuxiliary(entry.info)) {
               auxKey = await this.demonstratedReadyKeyFor(entry.info, filePath);
               if (auxKey && this.auxNotifyBacklogAtCeiling(auxKey, entry)) {
                 continue;
               }
             }
             try {
-              await entry.client.notify.open(filePath, content, languageId);
-              if (auxKey)
+              const sent = await entry.client.notify.open(filePath, content, languageId);
+              if (auxKey && sent !== false) {
                 this.noteAuxNotifyIssued(auxKey, entry.client);
+              }
             } catch {}
           }
         })(), { ms: perFileMs, onTimeout: "undefined" });
@@ -3988,12 +4195,11 @@ export class LSPService {
     };
     const processFile = async (filePath) => {
       try {
-        const content = contentCache.get(filePath) ?? await nodeFs.promises.readFile(filePath, "utf-8");
-        try {
-          const scanStat = nodeFs.statSync(filePath);
-          scannedMtimeByFile.set(filePath, scanStat.mtimeMs);
-          scannedSizeByFile.set(filePath, scanStat.size);
-        } catch {}
+        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 });
@@ -4078,6 +4284,7 @@ export class LSPService {
           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) {
@@ -4088,10 +4295,12 @@ export class LSPService {
                 ...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;
@@ -4168,6 +4377,11 @@ export class LSPService {
     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",
@@ -4183,6 +4397,7 @@ export class LSPService {
         timedOutFiles,
         unconfirmedByReason,
         partiallyCoveredFiles,
+        pullUnbound,
         ...unconfirmedServerIds.length > 0 && { unconfirmedServerIds },
         aborted: signal?.aborted ?? false
       }
@@ -4192,11 +4407,19 @@ export class LSPService {
       if (result.error || result.timedOut || (result.unconfirmedServerIds?.length ?? 0) > 0 || scannedAt === undefined) {
         continue;
       }
-      workspaceDiagnosticsCacheCtx.record(result.filePath, workspaceSweepScopeKey, result.diagnostics, scannedAt, result.contentHash, scannedSizeByFile.get(result.filePath));
+      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)));
-    return [...servedCacheResults, ...results].filter(Boolean);
+    const freshResults = results.map((result) => ({
+      ...result,
+      observedAt: scannedAtByFile.get(result.filePath)
+    }));
+    return [...servedCacheResults, ...freshResults].filter(Boolean);
   }
   async tryWorkspacePull(groupFiles, perFileMs, reanswerFor) {
     try {
@@ -4309,6 +4532,26 @@ export class LSPService {
     }
     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);
@@ -4326,8 +4569,8 @@ export class LSPService {
     for (const [key, token] of this.outstandingAuxNotifyWrites) {
       this.releaseOutstandingAuxNotifyWrite(key, token);
     }
-    for (const key of this.typeScriptIdleTimers.keys()) {
-      this.clearTypeScriptIdleTimer(key);
+    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());
@@ -4434,44 +4677,27 @@ export class LSPService {
       if (seen.has(id))
         continue;
       seen.add(id);
-      const role = LSP_SERVERS.find((s) => s.id === id)?.role;
-      (role === "auxiliary" ? aux : primary).push(id);
+      (isAuxiliary(getServerById(id)) ? aux : primary).push(id);
     }
     return [...primary, ...aux];
   }
 }
-const LSP_PROCESS_FAMILY = "lsp.service";
-const LSP_PROCESS_VERSION = 1;
-function lspProcessState() {
-  let incompatibleHandoff;
-  return getProcessSingleton(LSP_PROCESS_FAMILY, LSP_PROCESS_VERSION, () => ({ service: null, generationHandoff: incompatibleHandoff }), (value) => {
-    if (!value || typeof value !== "object")
-      return;
-    const candidate = value;
-    const previousHandoff = candidate.generationHandoff;
-    const teardown = candidate.service?.shutdown ? candidate.service.shutdown({ fast: true, reason: "process_singleton_reset" }).catch(() => {
-      return;
-    }) : undefined;
-    if (previousHandoff && teardown) {
-      incompatibleHandoff = Promise.allSettled([
-        previousHandoff,
-        teardown
-      ]).then(() => {
-        return;
-      });
-    } else {
-      incompatibleHandoff = previousHandoff ?? teardown;
-    }
-  });
-}
-function processService() {
-  const state = lspProcessState();
-  if (!state.service)
-    state.service = new LSPService(state.generationHandoff, process.cwd());
-  return state.service;
-}
+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 processService();
+  return getOwnedLspService();
+}
+export function peekLSPService() {
+  return peekOwnedLspService();
 }
 export async function hasAuxiliaryLspPublishedForRoot(serverId, filePath) {
   return getLSPService().hasServerPublishedForFileRoot(serverId, filePath);
@@ -4483,28 +4709,11 @@ export async function resyncGitChangedFiles(changedPaths) {
   return getLSPService().resyncGitChangedFiles(changedPaths);
 }
 export function resetLSPService(options = {}) {
-  abortDeferredLspWork(`lsp service reset: ${options.reason ?? "unspecified"}`);
-  resetLspLaunchAvailabilityGeneration();
   if (options.reason === "session_start") {
     resetClassicTsRepairGuard();
     clearWorkspaceSweepHoldForSessionStart();
   }
-  const state = lspProcessState();
-  const retiringService = state.service;
-  state.service = null;
-  if (!retiringService)
-    return;
-  const teardown = retiringService.shutdown(options);
-  const pending = state.generationHandoff ? [state.generationHandoff, teardown] : [teardown];
-  const handoff = Promise.allSettled(pending).then(() => {
-    return;
-  });
-  state.generationHandoff = handoff;
-  handoff.then(() => {
-    if (state.generationHandoff === handoff) {
-      state.generationHandoff = undefined;
-    }
-  });
+  resetOwnedLspService(options);
 }
 export function __collectWorkspaceDiagnosticFilesForTest(root, maxFiles, signal, homeDir) {
   return collectWorkspaceDiagnosticFiles(path.resolve(root), maxFiles ?? getMaxWorkspaceDiagnosticFiles(), signal, homeDir);