@duckmind/dm-linux-x64 0.65.4 → 0.65.6

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

@@ -23,7 +23,9 @@ import {
 } from "../project-trust.js";
 import { shouldPreferPullOnlyDiagnostics } from "../lsp-budget.js";
 import { sampleProcessTreeCpuPercent } from "../resource-sampler.js";
-import { withDeadline, withTimeout } from "../deadline-utils.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,
@@ -47,6 +49,7 @@ import { recordLspMutation } from "../lsp-mutation.js";
 import { createLSPClient } from "./client.js";
 import {
   auxiliaryCoverageGap,
+  auxiliaryPublicationEvidence,
   bindingStateLabel,
   composeBoundToCurrentDisk,
   createDiskBindingCache,
@@ -64,13 +67,18 @@ import {
 } from "./session-roots.js";
 import { getProcessSingleton } from "../process-singletons.js";
 import { getLanguageId } from "./language.js";
+import {
+  getReverseDepsFromIndex,
+  loadReverseDependencyIndexFromSnapshot
+} from "../reverse-deps.js";
 import {
   LSP_SERVERS,
   enforceLspRootCeiling,
   hasProjectBoundaryMarker,
   isDirectLspCommandTemporarilyUnavailable,
   resetClassicTsRepairGuard,
-  resetLspLaunchAvailabilityGeneration
+  resetLspLaunchAvailabilityGeneration,
+  resolveLspServerCwd
 } from "./server.js";
 import {
   classifyCascadeWaitTier,
@@ -78,6 +86,10 @@ import {
   getStrategy
 } from "./wait-policy/index.js";
 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;
 import { raceToCompletion } from "./aggregation.js";
 import {
   applyWorkspaceEdit,
@@ -159,6 +171,7 @@ 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 {
@@ -260,6 +273,9 @@ function mergeLspDiagnostics(diagnostics) {
   }
   return merged;
 }
+function attributeDiagnostics(serverId, diagnostics) {
+  return diagnostics.map((diagnostic) => ({ ...diagnostic, serverId }));
+}
 export function groupFilesByPrimaryServer(files) {
   const byServer = new Map;
   for (const filePath of files) {
@@ -400,6 +416,11 @@ export class LSPService {
   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;
@@ -422,6 +443,7 @@ export class LSPService {
   typeScriptIdleTimers = new Map;
   clientSpawnGate = Promise.resolve();
   isDestroyed = false;
+  shutdownController = new AbortController;
   generationHandoff;
   constructor(generationHandoff, sessionCwd) {
     this.generationHandoff = generationHandoff;
@@ -433,11 +455,60 @@ export class LSPService {
       inFlight: new Map,
       clientSpawnedAt: new Map,
       demonstratedReady: new Set,
-      demonstratedCold: new Set
+      demonstratedCold: new Set,
+      diagnosticsPublished: new Set,
+      diagnosticsUnsupported: new Set
     };
   }
-  async resolveServerRoot(server, filePath) {
-    const candidate = await server.root(filePath);
+  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"
+    });
+  }
+  async resolveServerRoot(server, filePath, onRootFailure) {
+    const candidate = await resolveLspServerCwd(server, filePath, this.sessionCwd ?? process.cwd(), onRootFailure);
     if (!candidate)
       return;
     if (isOutsideAllSessionRoots(filePath))
@@ -1115,11 +1186,14 @@ export class LSPService {
     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: undefined
+            root: await this.resolveServerRootOnce(server, filePath, rootMemo, (reason) => {
+              rootFailureReason = reason;
+            }),
+            reason: rootFailureReason
           };
         } catch (error) {
           return {
@@ -1328,13 +1402,27 @@ export class LSPService {
     const clients = results.filter((entry) => entry !== undefined);
     return { clients, serverCountAttempted };
   }
-  async getAuxiliaryClientsForFile(filePath, enabledIds, onOutcome) {
+  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));
     if (servers.length === 0)
       return [];
-    const spawned = await Promise.all(servers.map((server) => this.ensureClientForServer(filePath, server, undefined, undefined, (reported) => onOutcome?.(server.id, reported))));
+    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) {
@@ -1418,6 +1506,17 @@ export class LSPService {
     }
     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;
@@ -1432,6 +1531,38 @@ export class LSPService {
       }
     }
   }
+  async resyncGitChangedFiles(changedPaths) {
+    if (this.checkDestroyed() || changedPaths.length === 0)
+      return;
+    const targets = new Set;
+    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);
+    }
+    const openTargets = [...targets].filter((filePath) => this.hasLiveClientHoldingDocument(filePath));
+    this.documentDrift.enqueueResync(openTargets);
+    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
+      }
+    });
+  }
   async sweepDocumentDrift(options = {}) {
     if (this.checkDestroyed())
       return;
@@ -1510,13 +1641,13 @@ export class LSPService {
   noteSpawnVerdict(key, verdict) {
     this.lastSpawnVerdict.set(key, verdict);
   }
-  resolveServerRootOnce(server, filePath, memo) {
+  resolveServerRootOnce(server, filePath, memo, onRootFailure) {
     if (!memo)
-      return this.resolveServerRoot(server, filePath);
+      return this.resolveServerRoot(server, filePath, onRootFailure);
     const pending = memo.get(server.id);
     if (pending !== undefined)
       return pending;
-    const started = this.resolveServerRoot(server, filePath);
+    const started = this.resolveServerRoot(server, filePath, onRootFailure);
     memo.set(server.id, started);
     return started;
   }
@@ -1752,6 +1883,9 @@ export class LSPService {
       }
       const override = getServerInitOverride(server.id, filePath);
       const mergedInit = 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,
@@ -1759,7 +1893,10 @@ export class LSPService {
         sessionCwd: this.sessionCwd,
         initialization: mergedInit,
         initializeTimeoutMs: server.initializeTimeoutMs,
-        launchVariant: spawned.launchVariant
+        launchVariant: spawned.launchVariant,
+        onDiagnosticsPublished: (serverId) => {
+          this.state.diagnosticsPublished.add(serverId);
+        }
       });
       if (this.isDestroyed) {
         client.shutdown({ fast: true }).catch(() => {});
@@ -1864,6 +2001,7 @@ export class LSPService {
       return;
     }
     const startedAt = Date.now();
+    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) {
@@ -1890,10 +2028,27 @@ export class LSPService {
       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)
+        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 {
@@ -1923,6 +2078,17 @@ 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);
+        return {
+          diags: [],
+          inconclusive: true,
+          ...primaryServerIds.length > 0 && {
+            inconclusiveServerIds: primaryServerIds
+          },
+          inconclusiveReason: "diagnostics-wait"
+        };
+      }
       return this.touchFile(filePath, content, options);
     }
     try {
@@ -1961,7 +2127,7 @@ export class LSPService {
         if (!bindingMatchesTouchContent(binding))
           return [];
         const diags = entry.client.getDiagnostics(filePath);
-        return diags.length > 0 ? [{ diags, binding }] : [];
+        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 spawnedByServerId = new Map(spawned.map((entry) => [entry.info.id, entry]));
@@ -2014,7 +2180,7 @@ export class LSPService {
           let rejected = false;
           try {
             const writeStartedAt = Date.now();
-            const writePromise = entry.client.notify.open(filePath, content, languageId, undefined, silent).then(() => true);
+            const writePromise = entry.client.notify.open(filePath, content, languageId, undefined, silent, options.saved === true).then(() => true);
             if (gated && clientKey) {
               this.noteAuxNotifyIssued(clientKey, entry.client);
             }
@@ -2080,8 +2246,11 @@ export class LSPService {
       };
       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;
@@ -2107,6 +2276,9 @@ export class LSPService {
                 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?.()
@@ -2148,7 +2320,7 @@ export class LSPService {
           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 && clientScope === "primary" && spawned.length === 1 && spawned[0].client.serverId === "typescript" && getStrategy(spawned[0].client.serverId, spawned[0].client.getLaunchVariant?.()).silentOnClean === true) {
+        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";
@@ -2156,6 +2328,22 @@ export class LSPService {
         }
         const waitStartedAt = Date.now();
         const hasTouchAuxiliaries = clientScope === "with-auxiliary" && options.collectDiagnostics === true && spawned.some((e) => e.info.role === "auxiliary");
+        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 {
@@ -2169,18 +2357,41 @@ export class LSPService {
           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];
         });
+        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 && entry.info.role === "auxiliary" ? 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)) {
+            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 isWarmupTouch = source === "lsp_sweep_warmup";
-          const wait = !notifySkippedServerIds.has(entry.info.id) && Number.isFinite(baseline) ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
+          const waitForDiagnostics = () => !notifySkippedServerIds.has(entry.info.id) && Number.isFinite(baseline) ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
             minVersion: baseline,
             ...pullOnly && { pullOnly: true },
             ...isWarmupTouch && { pullSettleSource: "pull-warmup" }
@@ -2190,7 +2401,64 @@ export class LSPService {
           }) : isWarmupTouch ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
             pullSettleSource: "pull-warmup"
           }) : entry.client.waitForDiagnostics(filePath, serverTimeout);
-          return wait.catch(() => {
+          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;
           });
         });
@@ -2202,7 +2470,9 @@ export class LSPService {
             serverId: spawned[i].info.id,
             client: spawned[i].client,
             baseline: diagnosticBaselines.get(spawned[i].client),
-            budgetMs: perServerRaceBudgets[i]
+            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)
@@ -2210,6 +2480,20 @@ export class LSPService {
             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);
@@ -2224,14 +2508,23 @@ export class LSPService {
               if (timer)
                 clearTimeout(timer);
               const currentPathVersion = readPathVersion(aux.client);
-              const publishedEvidence = raced && Number.isFinite(aux.baseline) && currentPathVersion !== undefined && currentPathVersion > aux.baseline;
+              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: Date.now() - auxWaitStartedAt,
+                elapsedMs,
                 elapsedSinceNotifyMs: Date.now() - waitStartedAt
               };
             }));
@@ -2241,9 +2534,10 @@ export class LSPService {
             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.serverId === "ast-grep" && napiFallbackCoveredSince(filePath, startedAt))).map((o) => o.serverId);
+            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) {
-              markPendingAuxiliaryCoverage(filePath, collectLaterServerIds);
+              lateDeliveryServerIds = collectLaterServerIds;
+              markPendingAuxiliaryCoverage(filePath, collectLaterServerIds, Date.now());
             }
             logLatency({
               type: "phase",
@@ -2254,9 +2548,10 @@ export class LSPService {
             });
           });
         })() : Promise.all(perServerWaits).then(() => {});
-        pushWait.then(() => {
+        const markPushWaitSettled = () => {
           pushWaitSettled = true;
-        });
+        };
+        pushWait.then(markPushWaitSettled, markPushWaitSettled);
         if (tsserverSyncEligible) {
           const graceMs = readTsserverSyncGraceMs();
           const primaryClient = spawned[0].client;
@@ -2292,13 +2587,38 @@ export class LSPService {
           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) => entry.info.role === "auxiliary");
           if (auxEntries.length > 0) {
             const outcomes = auxEntries.map((entry) => {
               const baseline = diagnosticBaselines.get(entry.client);
               const currentPathVersion = readPathVersion(entry.client);
-              const publishedEvidence = Number.isFinite(baseline) && currentPathVersion !== undefined && currentPathVersion > baseline;
+              const publishedEvidence = auxiliaryPublicationEvidence({
+                bindingMatchesContent: false,
+                baseline,
+                currentPathVersion
+              });
               return {
                 serverId: entry.info.id,
                 outcome: deferredResyncServerIds.has(entry.info.id) ? "deferred" : publishedEvidence ? "answered" : "silent",
@@ -2337,25 +2657,14 @@ export class LSPService {
               savedVsBudgetMs: Math.max(0, timeoutMs - waitedMs)
             }
           });
-        } else if (waitedMs + 20 >= timeoutMs) {
-          const answeredForThisTouch = (entry) => {
-            const baseline = diagnosticBaselines.get(entry.client);
-            const currentPathVersion = readPathVersion(entry.client);
-            if (Number.isFinite(baseline) && currentPathVersion !== undefined && currentPathVersion > baseline) {
-              return true;
-            }
-            try {
-              return entry.client.getAllDiagnostics?.().has(normalizedPath) === true;
-            } catch {
-              return false;
-            }
-          };
-          const waited = spawned.filter((entry) => !deferredResyncServerIds.has(entry.info.id));
+        } 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) => entry.info.role !== "auxiliary").map((e) => e.info.id);
           const hasWaitedPrimary = waited.some((entry) => entry.info.role !== "auxiliary");
-          diagnosticsTimedOut = !hasWaitedPrimary || diagnosticsUnansweredPrimaryServerIds.length > 0;
+          const hasUnsupportedPrimary = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && entry.info.role !== "auxiliary"));
+          diagnosticsTimedOut = !hasWaitedPrimary && !hasUnsupportedPrimary || diagnosticsUnansweredPrimaryServerIds.length > 0;
           for (const entry of unanswered) {
             incrementDegradationCount({
               kind: "lsp-diagnostics-timeout",
@@ -2416,9 +2725,9 @@ export class LSPService {
         ...uncoveredDeferredServerIds,
         ...staleWriteAuxiliaryServerIds
       ]);
-      let collected = options.collectDiagnostics ? tsserverSyncConfirmed !== undefined ? mergeLspDiagnostics(tsserverSyncConfirmed) : mergeLspDiagnostics([
-        ...spawned.flatMap((entry) => droppedAuxiliaryServerIds.has(entry.info.id) ? [] : entry.client.getDiagnostics(filePath)),
-        ...carriedAuxiliary.flatMap((entry) => entry.diags)
+      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;
       if (diagnosticsTimedOut && tsserverSyncEligible && collected !== undefined && collected.length === 0) {
@@ -2428,7 +2737,7 @@ export class LSPService {
             diagnosticsTimedOut = false;
             retractPrimaryTimeoutAttribution();
             syncConfirmed = true;
-            collected = syncResult.length > 0 ? mergeLspDiagnostics(syncResult) : [];
+            collected = syncResult.length > 0 ? mergeLspDiagnostics(attributeDiagnostics(spawned[0]?.info.id ?? "unknown", syncResult)) : [];
             logLatency({
               type: "phase",
               phase: "lsp_tsserver_sync_confirm",
@@ -2445,7 +2754,7 @@ export class LSPService {
           }
         } catch {}
       }
-      if (diagnosticsTimedOut && !primaryNotifyWriteTimedOut && !tsserverSyncEligible && clientScope === "primary" && spawned.length === 1 && getStrategy(spawned[0].client.serverId, spawned[0].client.getLaunchVariant?.()).silentOnClean === true) {
+      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") {
@@ -2541,16 +2850,24 @@ export class LSPService {
         }
       }
       const result = { diags: collected ?? [] };
+      const primaryDiagnosticsUnsupported = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && entry.info.role !== "auxiliary"));
+      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) {
+      } else if (collected !== undefined && !primaryDiagnosticsUnsupported) {
         result.confirmation = "confirmed";
       }
       let binding;
@@ -2561,6 +2878,10 @@ export class LSPService {
         ]);
         result.binding = binding;
       }
+      const lateDeliveryPending = unconfirmedServerIds.filter((serverId) => (lateDeliveryServerIds ?? []).includes(serverId));
+      if (lateDeliveryPending.length > 0) {
+        result.deferredServerIds = lateDeliveryPending;
+      }
       logLatency({
         type: "phase",
         phase: "lsp_touch_file",
@@ -2600,6 +2921,9 @@ export class LSPService {
           ...uncoveredDeferredServerIds.length > 0 && {
             deferredResyncServerIds: uncoveredDeferredServerIds
           },
+          ...lateDeliveryPending.length > 0 && {
+            lateDeliveryServerIds: lateDeliveryPending
+          },
           ...auxNoAnswerServerIds.length > 0 && { auxNoAnswerServerIds }
         }
       });
@@ -2754,7 +3078,7 @@ export class LSPService {
         if (seen.has(key))
           continue;
         seen.add(key);
-        merged.push(diagnostic);
+        merged.push({ ...diagnostic, serverId: entry.serverId });
       }
     }
     const rawCount = perServerFull.reduce((sum, entry) => sum + entry.diagnosticCount, 0);
@@ -3020,6 +3344,9 @@ export class LSPService {
           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?.() ?? [],
           launchVariant: client.getLaunchVariant?.()
@@ -3037,6 +3364,9 @@ export class LSPService {
         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?.() ?? [],
         launchVariant: client.getLaunchVariant?.()
@@ -3515,6 +3845,37 @@ export class LSPService {
     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;
@@ -3522,15 +3883,19 @@ export class LSPService {
       writeIndexByPath.set(normalizeMapKey(filePath), options.nextWriteIndex?.());
       const cached = workspaceDiagnosticsCacheCtx.lookup(filePath, workspaceSweepScopeKey);
       if (cached && cached.binding.boundToCurrentDisk !== false) {
-        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))
-        });
+        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);
       }
@@ -3657,7 +4022,9 @@ export class LSPService {
         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)
+          fileRole: detectFileRole(filePath, content),
+          filePath,
+          scanRoot: root
         }) : diagnostics;
         results.push({
           filePath,
@@ -3905,15 +4272,16 @@ export class LSPService {
       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,
-            ...entry.diags
+            ...attributed
           ]);
           existing.ts = Math.max(existing.ts, entry.ts);
         } else {
-          all.set(filePath, { diags: [...entry.diags], ts: entry.ts });
+          all.set(filePath, { diags: attributed, ts: entry.ts });
         }
         const list = bindingsByPath.get(filePath) ?? [];
         list.push(entry.binding);
@@ -3954,6 +4322,7 @@ export class LSPService {
     if (this.checkDestroyed())
       return;
     this.isDestroyed = true;
+    this.shutdownController.abort();
     for (const [key, token] of this.outstandingAuxNotifyWrites) {
       this.releaseOutstandingAuxNotifyWrite(key, token);
     }
@@ -3989,6 +4358,7 @@ export class LSPService {
     });
     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);
@@ -4109,6 +4479,9 @@ export async function hasAuxiliaryLspPublishedForRoot(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 = {}) {
   abortDeferredLspWork(`lsp service reset: ${options.reason ?? "unspecified"}`);
   resetLspLaunchAvailabilityGeneration();