@herbertgao/pi-extensions 2026.9.1 → 2026.9.3

package/node_modules/pi-lens/dist/clients/lsp/index.js

@@ -25,6 +25,7 @@ import { isLspSpawnAllowedByTrust, assertInstallAllowed, projectTrustDenialReaso
 import { shouldPreferPullOnlyDiagnostics } from "../lsp-budget.js";
 import { sampleProcessTreeCpuPercent } from "../resource-sampler.js";
 import { bounded, withDeadline, withTimeout } from "../deadline-utils.js";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
 import { getAmbientAbortSignal } from "../safe-spawn.js";
 import { abortDeferredLspWork } from "../deferred-lsp-work.js";
 import { acquireWorkspaceSweepHold, clearWorkspaceSweepHoldForSessionStart, } from "./workspace-sweep-hold.js";
@@ -33,7 +34,7 @@ import { markPendingAuxiliaryCoverage, napiFallbackCoveredSince, } from "./pendi
 import { isAtOrAboveHomeDir, isWindowsPath, normalizeMapKey, uriToPath, } from "../path-utils.js";
 import { recordLspMutation } from "../lsp-mutation.js";
 import { createLSPClient } from "./client.js";
-import { auxiliaryCoverageGap, bindingStateLabel, composeBoundToCurrentDisk, createDiskBindingCache, hashDiagnosticContent, resolveTouchVerdict, touchCoverageGap, } from "./diagnostic-binding.js";
+import { auxiliaryCoverageGap, auxiliaryPublicationEvidence, bindingStateLabel, composeBoundToCurrentDisk, createDiskBindingCache, hashDiagnosticContent, resolveTouchVerdict, touchCoverageGap, } from "./diagnostic-binding.js";
 import { getServersForFileWithConfig, getServerInitOverride, } from "./config.js";
 // #2052: deliberately NOT taken from `config.js`. This module's import surface
 // from `config.js` is mirrored by explicit `vi.mock` factories in ~58 test
@@ -41,9 +42,14 @@ import { getServersForFileWithConfig, getServerInitOverride, } from "./config.js
 import { getSessionRootsForTelemetry, isOutsideAllSessionRoots, } from "./session-roots.js";
 import { getProcessSingleton } from "../process-singletons.js";
 import { getLanguageId } from "./language.js";
-import { LSP_SERVERS, enforceLspRootCeiling, hasProjectBoundaryMarker, isDirectLspCommandTemporarilyUnavailable, resetClassicTsRepairGuard, resetLspLaunchAvailabilityGeneration, } from "./server.js";
+import { getReverseDepsFromIndex, loadReverseDependencyIndexFromSnapshot, } from "../reverse-deps.js";
+import { LSP_SERVERS, enforceLspRootCeiling, hasProjectBoundaryMarker, isDirectLspCommandTemporarilyUnavailable, resetClassicTsRepairGuard, resetLspLaunchAvailabilityGeneration, resolveLspServerCwd, } from "./server.js";
 import { classifyCascadeWaitTier, classifyServerWaitTier, 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, mergeWorkspaceTextEditsByPriority, summarizeWorkspaceEdit, validateWorkspaceEdit, } from "./edits.js";
 import { buildScopeKey, createWorkspaceDiagnosticsCacheContext, } from "./workspace-diagnostics-cache.js";
@@ -175,6 +181,7 @@ const NAV_CLIENT_WAIT_TIMEOUT_MS = Math.max(0, Number.parseInt(process.env.PI_LE
     1500);
 const TOUCH_DEBOUNCE_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_LSP_TOUCH_DEBOUNCE_MS ?? "1500", 10) ||
     1500);
+const SCOPED_DEPENDENCY_TOUCH_MAX = 32;
 // #1621: the rename-propagation notifies (`didClose` ahead of the rename,
 // `workspace/didRenameFiles` after) share the exit-notify defect #1620 fixed —
 // a notify write on a pipe that is not draining neither resolves nor rejects,
@@ -344,6 +351,9 @@ function mergeLspDiagnostics(diagnostics) {
     }
     return merged;
 }
+function attributeDiagnostics(serverId, diagnostics) {
+    return diagnostics.map((diagnostic) => ({ ...diagnostic, serverId }));
+}
 /**
  * Group files by their primary language server id (#387/#631 — extracted
  * from `runWorkspaceDiagnostics`'s inline grouping so other callers, e.g.
@@ -646,6 +656,17 @@ export class LSPService {
     /** Server/root pairs that already emitted unavailable for the current occurrence. */
     unavailableLogged = new Set();
     optionalDisabled = new Set();
+    /**
+     * One first-contact diagnostic wait per custom server in this service
+     * generation. Concurrent touches share the probe; a hook cutoff never arms
+     * the navigation-only latch, so the next touch can try again.
+     */
+    firstContactWaits = new Map();
+    /** Session-scoped adaptive demotion for budget-hitting auxiliaries. */
+    auxWaitPressureStreak = new Map();
+    auxWaitFastAnswerStreak = new Map();
+    demotedAuxiliaryServerIds = new Set();
+    demotedAuxiliaryBudgets = new Map();
     /**
      * #1934 review F1: what the last COMPLETED `spawnClient` call for a
      * (server, root) key decided, written by that call at every point it
@@ -833,6 +854,8 @@ export class LSPService {
     clientSpawnGate = Promise.resolve();
     /** True after shutdown() has been called; blocks new operations */
     isDestroyed = false;
+    /** Aborts bounded in-flight service work when this generation is retired. */
+    shutdownController = new AbortController();
     /**
      * #850: teardown completion for every singleton generation retired before
      * this service was published. Only replacement services receive one; direct
@@ -852,15 +875,65 @@ export class LSPService {
             clientSpawnedAt: new Map(),
             demonstratedReady: new Set(),
             demonstratedCold: new Set(),
+            diagnosticsPublished: new Set(),
+            diagnosticsUnsupported: new Set(),
         };
     }
+    isAuxiliaryWaitDemoted(serverId, root) {
+        return this.demotedAuxiliaryServerIds.has(`${serverId}:${normalizeMapKey(root ?? "")}`);
+    }
+    noteAuxiliaryWait(key, budgetMs, elapsedMs) {
+        if (this.demotedAuxiliaryServerIds.has(key))
+            return;
+        if (elapsedMs < AUX_WAIT_DEMOTION_RATIO * budgetMs) {
+            this.auxWaitPressureStreak.delete(key);
+            return;
+        }
+        const streak = (this.auxWaitPressureStreak.get(key) ?? 0) + 1;
+        if (streak >= AUX_WAIT_DEMOTION_THRESHOLD) {
+            this.demotedAuxiliaryServerIds.add(key);
+            this.demotedAuxiliaryBudgets.set(key, budgetMs);
+            this.auxWaitPressureStreak.delete(key);
+            this.auxWaitFastAnswerStreak.delete(key);
+            recordDegradationOnce({
+                kind: "aux_wait_demoted",
+                subject: key,
+                reason: "auxiliary reached at least 90% of its declared wait budget for five consecutive dispatches",
+            });
+            return;
+        }
+        this.auxWaitPressureStreak.set(key, streak);
+    }
+    noteAuxiliaryLateAnswer(key, elapsedMs) {
+        if (!this.demotedAuxiliaryServerIds.has(key))
+            return;
+        const budgetMs = this.demotedAuxiliaryBudgets.get(key);
+        if (budgetMs === undefined ||
+            elapsedMs >= AUX_WAIT_REPROMOTION_RATIO * budgetMs) {
+            this.auxWaitFastAnswerStreak.delete(key);
+            return;
+        }
+        const streak = (this.auxWaitFastAnswerStreak.get(key) ?? 0) + 1;
+        if (streak < AUX_WAIT_REPROMOTION_THRESHOLD) {
+            this.auxWaitFastAnswerStreak.set(key, streak);
+            return;
+        }
+        this.demotedAuxiliaryServerIds.delete(key);
+        this.demotedAuxiliaryBudgets.delete(key);
+        this.auxWaitFastAnswerStreak.delete(key);
+        recordDegradationOnce({
+            kind: "aux_wait_repromoted",
+            subject: key,
+            reason: "auxiliary produced five consecutive late answers below half its declared wait budget",
+        });
+    }
     /**
      * Resolve one server's client identity root. Root selection is hard-bounded
      * by the session cwd, then config-only nested roots reuse an already-hosted
      * same-server ancestor. Real nested projects retain independent clients.
      */
-    async resolveServerRoot(server, filePath) {
-        const candidate = await server.root(filePath);
+    async resolveServerRoot(server, filePath, onRootFailure) {
+        const candidate = await resolveLspServerCwd(server, filePath, this.sessionCwd ?? process.cwd(), onRootFailure);
         if (!candidate)
             return undefined;
         // #2052: a file outside EVERY initialized session cwd gets no client at
@@ -1984,11 +2057,14 @@ export class LSPService {
          */
         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) {
@@ -2455,6 +2531,18 @@ export class LSPService {
         }
         return out;
     }
+    /** Record a fast answer observed by the turn-end late-results path. */
+    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;
+        }
+    }
     /**
      * #1668: deliver a `workspace/didChangeWatchedFiles` event for a disk
      * change the client did not author through open-document sync — a bash
@@ -2481,6 +2569,45 @@ export class LSPService {
             }
         }
     }
+    /**
+     * Re-sync the open views affected by one recovered Git tree change. The
+     * recovery seam already owns the changed-path set, so this deliberately
+     * reads only the cached reverse-import index and never runs another diff.
+     */
+    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,
+            },
+        });
+    }
     /**
      * #1783: disk-drift backstop. Stat one batch of the documents a language
      * server currently holds, and re-push any whose bytes on disk no longer
@@ -2669,13 +2796,13 @@ export class LSPService {
      * instead of each taking their own. Without a `memo` this is a plain
      * passthrough, for callers that have no acquisition to share with.
      */
-    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;
     }
@@ -3117,6 +3244,12 @@ export class LSPService {
             }
             const override = getServerInitOverride(server.id, filePath);
             const mergedInit = mergeInitializationOptions(spawned.initialization, override?.initializationOptions);
+            // A replacement process is a new first-contact identity even when the
+            // configured server id is unchanged. Re-arm both capability latches before
+            // the replacement can publish a snapshot.
+            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,
@@ -3125,6 +3258,9 @@ export class LSPService {
                 initialization: mergedInit,
                 initializeTimeoutMs: server.initializeTimeoutMs,
                 launchVariant: spawned.launchVariant,
+                onDiagnosticsPublished: (serverId) => {
+                    this.state.diagnosticsPublished.add(serverId);
+                },
             });
             // Guard 2: service was shut down while we were completing the initialize
             // handshake. Shut down the live client best-effort and do not register it.
@@ -3286,6 +3422,11 @@ 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) {
@@ -3394,6 +3535,19 @@ export class LSPService {
         if (!leaseKeys) {
             // An idle eviction won between selection and lease admission. Resolve the
             // now-current client set and replay; no notification targets the retiree.
+            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 {
@@ -3475,7 +3629,9 @@ 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 }]
+                        : [];
                 })
                 : [];
             // #1493: auxiliaries whose STORED publication already covers exactly the
@@ -3784,6 +3940,15 @@ export class LSPService {
             // confirmation; `auxCutOffServerIds` stays cut_off-only so the R8 latency
             // field keeps its original meaning.
             let auxUnconfirmedServerIds;
+            // #2810: the auxiliaries this touch handed to the collect-later store —
+            // exactly the servers whose findings a turn-end drain can still deliver.
+            // Written by the ONE producer that marks them, from the same array it
+            // marks, so the promise the agent is shown cannot drift from the store.
+            // Round 3 derived the promise from the #1459 resync deferrals instead —
+            // the one set `pending-aux-coverage.ts` never marks — so the notice
+            // promised delivery that could not happen, while the demoted server,
+            // which IS marked, was reported as an unexplained silence on every edit.
+            let lateDeliveryServerIds;
             // #707: tsserver sync clean-confirm state. `tsserverSyncEligible` is the
             // full gate (evaluated once, before the wait); `tsserverSyncConfirmed`
             // holds the sync commands' answer when the racing confirm won the wait
@@ -3791,6 +3956,7 @@ export class LSPService {
             // fallback below may still fill it in on a timed-out empty result).
             let tsserverSyncEligible = false;
             let tsserverSyncConfirmed;
+            let diagnosticsUnsupportedServerIds = [];
             if (diagnosticsMode !== "none") {
                 // Resolution: env wins so users can tune the cap without rebuilding.
                 // Otherwise, on the single-server hot path (primary scope), use that
@@ -3861,6 +4027,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?.(),
@@ -4004,6 +4173,29 @@ export class LSPService {
                 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 {
+                        // Capability uncertainty fails closed and retains the wait.
+                    }
+                }
                 // Per-server wait promises (each already bounded by its own
                 // perServerTimeout — unchanged from before R8).
                 let pressureSnapshots = [];
@@ -4028,12 +4220,40 @@ export class LSPService {
                         ? 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);
+                    }
                     // #1459: a DEFERRED server never received this content, so its version
                     // can never advance past the baseline — waiting on it burns its whole
                     // budget and would flip the touch to `inconclusive`, discarding a
@@ -4063,7 +4283,7 @@ export class LSPService {
                     const isWarmupTouch = source === "lsp_sweep_warmup";
                     // #743: per-server — a server we DID push to still gets the
                     // version-baseline wait even when a sibling was debounced away.
-                    const wait = !notifySkippedServerIds.has(entry.info.id) &&
+                    const waitForDiagnostics = () => !notifySkippedServerIds.has(entry.info.id) &&
                         Number.isFinite(baseline)
                         ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
                             minVersion: baseline,
@@ -4080,7 +4300,73 @@ export class LSPService {
                                     pullSettleSource: "pull-warmup",
                                 })
                                 : entry.client.waitForDiagnostics(filePath, serverTimeout);
-                    return wait.catch(() => undefined);
+                    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(() => undefined);
+                    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 undefined;
+                    });
                 });
                 // The push wait — same per-server budget composition as before #707;
                 // only the awaiting changed (assigned so it can be raced below).
@@ -4102,6 +4388,8 @@ export class LSPService {
                                 client: spawned[i].client,
                                 baseline: diagnosticBaselines.get(spawned[i].client),
                                 budgetMs: perServerRaceBudgets[i],
+                                demoted: this.isAuxiliaryWaitDemoted(spawned[i].info.id, spawned[i].client.root ?? filePath),
+                                root: spawned[i].client.root ?? filePath,
                             }
                             : null)
                             .filter((x) => x !== null);
@@ -4121,6 +4409,22 @@ 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);
@@ -4159,10 +4463,12 @@ export class LSPService {
                                 // ignoring sibling paths — and it is the SAME axis `baseline`
                                 // was captured on above.
                                 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,
+                                });
                                 // #1459: a DEFERRED aux was never sent this content and is not
                                 // waited on at all, so its instantly-resolved placeholder
                                 // promise must not read as "silent". "Silent" is the reserved
@@ -4176,6 +4482,10 @@ export class LSPService {
                                         : 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,
@@ -4185,9 +4495,12 @@ export class LSPService {
                                     // did not narrow the touch.
                                     // #1586: through the one predicate, so this row and the merge
                                     // below cannot disagree about the same scanner.
+                                    // #2914: binding-only by construction — the direct call
+                                    // below is master's line; the stamp axis already decided
+                                    // the outcome above and must not re-admit the row here.
                                     publishedThisContent: auxCoversThisContent(aux.serverId),
                                     budgetMs,
-                                    elapsedMs: Date.now() - auxWaitStartedAt,
+                                    elapsedMs,
                                     // #1458 S3: elapsed measured from BEFORE the primary wait
                                     // (waitStartedAt), not just from auxWaitStartedAt — this is
                                     // what lets a latency row validate the ~1.3s warm-scanner
@@ -4220,7 +4533,9 @@ export class LSPService {
                             // revision and probing it would replay stale findings.
                             const collectLaterServerIds = outcomes
                                 .filter((o) => !o.publishedThisContent &&
-                                (o.outcome === "cut_off" || o.outcome === "silent") &&
+                                (o.outcome === "cut_off" ||
+                                    o.outcome === "silent" ||
+                                    o.outcome === "demoted") &&
                                 // #2324 R2-A/R3-A: ast-grep's napi fallback is a
                                 // SECOND producer of coverage for this exact pair,
                                 // dispatched CONCURRENTLY with this whole touch
@@ -4240,7 +4555,8 @@ export class LSPService {
                                     napiFallbackCoveredSince(filePath, startedAt)))
                                 .map((o) => o.serverId);
                             if (collectLaterServerIds.length > 0) {
-                                markPendingAuxiliaryCoverage(filePath, collectLaterServerIds);
+                                lateDeliveryServerIds = collectLaterServerIds;
+                                markPendingAuxiliaryCoverage(filePath, collectLaterServerIds, Date.now());
                             }
                             logLatency({
                                 type: "phase",
@@ -4257,9 +4573,14 @@ export class LSPService {
                         });
                     })()
                     : Promise.all(perServerWaits).then(() => { });
-                pushWait.then(() => {
+                // Mark on BOTH paths: a rejected `pushWait` is settled too, and a
+                // resolve-only `.then` left a derived promise that rejected unhandled
+                // whenever a per-server wait failed (oxlint no-floating-promises,
+                // 2026-09-07). The rejection itself still reaches the awaiters below.
+                const markPushWaitSettled = () => {
                     pushWaitSettled = true;
-                });
+                };
+                void pushWait.then(markPushWaitSettled, markPushWaitSettled);
                 if (tsserverSyncEligible) {
                     // #707 racing variant: rather than burning the full push-wait budget
                     // on a silent-on-clean server (which by definition never answers on a
@@ -4331,6 +4652,35 @@ 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),
+                ];
                 // #1533: the same auxiliary coverage evidence for a collecting touch that
                 // did NOT enter the aux-grace wait — in practice `clientScope: "all"`, the
                 // batch/directory scan surface. Auxiliaries ARE spawned on that scope
@@ -4406,9 +4756,11 @@ export class LSPService {
                         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)
@@ -4416,6 +4768,9 @@ export class LSPService {
                                     : publishedEvidence
                                         ? "answered"
                                         : "silent",
+                                // #2914: binding-only by construction — the direct call
+                                // below is master's line; the stamp axis already decided
+                                // the outcome above and must not re-admit the row here.
                                 publishedThisContent: auxCoversThisContent(entry.info.id),
                                 budgetMs: timeoutFor(entry.client.serverId),
                                 elapsedMs: waitedMs,
@@ -4454,7 +4809,8 @@ export class LSPService {
                         },
                     });
                 }
-                else if (waitedMs + 20 >= timeoutMs) {
+                else if (waitedMs + 20 >= timeoutMs ||
+                    firstContactErroredServerIds.size > 0) {
                     // Within ~20 ms of the configured budget we treat it as a timeout;
                     // the LSP didn't beat the cap. Diagnostics that arrive late still
                     // land in the client's cache and surface on the next edit.
@@ -4479,25 +4835,10 @@ export class LSPService {
                     // reads as unanswered, which for a primary is exactly the pre-#1549
                     // verdict. This block can therefore only ever NARROW an inconclusive
                     // touch, never create one.
-                    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 {
-                            // Fail closed: an unreadable cache is not evidence of an answer.
-                            return false;
-                        }
-                    };
                     // A deferred server was never sent this content and is not waited on, so
                     // it cannot have "timed out" — it is already reported as a coverage gap.
-                    const waited = spawned.filter((entry) => !deferredResyncServerIds.has(entry.info.id));
+                    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
@@ -4507,8 +4848,9 @@ export class LSPService {
                     // preserve, so it keeps the pre-#1549 touch-wide verdict rather than
                     // absolving itself on an auxiliary's evidence.
                     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"));
                     diagnosticsTimedOut =
-                        !hasWaitedPrimary ||
+                        (!hasWaitedPrimary && !hasUnsupportedPrimary) ||
                             diagnosticsUnansweredPrimaryServerIds.length > 0;
                     for (const entry of unanswered) {
                         incrementDegradationCount({
@@ -4693,7 +5035,7 @@ export class LSPService {
             // diagnostics from the client cache as always.
             let collected = options.collectDiagnostics
                 ? tsserverSyncConfirmed !== undefined
-                    ? mergeLspDiagnostics(tsserverSyncConfirmed)
+                    ? mergeLspDiagnostics(attributeDiagnostics(spawned[0]?.info.id ?? "unknown", tsserverSyncConfirmed))
                     : mergeLspDiagnostics([
                         // #1459: a DEFERRED server's cache still holds the PREVIOUS
                         // content's findings — the resync that would have cleared it never
@@ -4705,8 +5047,8 @@ export class LSPService {
                         // coverage naming and the merged binding read too.
                         ...spawned.flatMap((entry) => droppedAuxiliaryServerIds.has(entry.info.id)
                             ? []
-                            : entry.client.getDiagnostics(filePath)),
-                        ...carriedAuxiliary.flatMap((entry) => entry.diags),
+                            : attributeDiagnostics(entry.info.id, entry.client.getDiagnostics(filePath))),
+                        ...carriedAuxiliary.flatMap((entry) => attributeDiagnostics(entry.serverId, entry.diags)),
                     ])
                 : undefined;
             // #1095 (P3-b): whether `collected` came from a tsserver sync confirm
@@ -4746,7 +5088,9 @@ export class LSPService {
                         retractPrimaryTimeoutAttribution(); // #1549
                         syncConfirmed = true;
                         collected =
-                            syncResult.length > 0 ? mergeLspDiagnostics(syncResult) : [];
+                            syncResult.length > 0
+                                ? mergeLspDiagnostics(attributeDiagnostics(spawned[0]?.info.id ?? "unknown", syncResult))
+                                : [];
                         logLatency({
                             type: "phase",
                             phase: "lsp_tsserver_sync_confirm",
@@ -5061,6 +5405,11 @@ export class LSPService {
             // collect, `binding` only for a collecting touch — a non-collecting touch
             // keeps resolving `{ diags: [] }`, no flags.
             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;
                 // #1549: name the primary that produced the verdict and which deadline it
@@ -5073,6 +5422,13 @@ export class LSPService {
                 }
                 result.inconclusiveReason = verdict.inconclusiveReason;
             }
+            else if (collected !== undefined && primaryDiagnosticsUnsupported) {
+                // A navigation-only primary has no diagnostic confirmation to report,
+                // but an uncovered auxiliary still needs to be named for delivery.
+                if (unconfirmedServerIds.length > 0) {
+                    result.unconfirmedServerIds = [...unconfirmedServerIds];
+                }
+            }
             else if (collected !== undefined && coverageGap) {
                 // #1470/#1493: narrowed, not collapsed. Reached for EITHER no-answer
                 // shape — a cut-off auxiliary or a silent one with nothing published for
@@ -5083,7 +5439,7 @@ export class LSPService {
                 result.confirmation = "partial";
                 result.unconfirmedServerIds = [...unconfirmedServerIds];
             }
-            else if (collected !== undefined) {
+            else if (collected !== undefined && !primaryDiagnosticsUnsupported) {
                 // Preserve the lower-level affirmative result across consumers. In
                 // particular, the silent-clean gates above clear diagnosticsTimedOut only
                 // after a successful notify and capability-confirmed wait; reclassifying
@@ -5129,6 +5485,17 @@ export class LSPService {
             // fully delivered. Nothing to record here: a skipped server keeps its original
             // entry (and timestamp) so its window still expires naturally instead of being
             // extended by every reuse.
+            // #2810: the half of the coverage gap that has a delivery path. Derived
+            // from `unconfirmedServerIds` so the two can never disagree about the
+            // same scanner, and intersected with the marked set so "findings will
+            // arrive through the late path" is said only where a pending pair
+            // exists. Everything else in the gap — a #1459 deferral, a breaker
+            // skip, an ast-grep already covered by its napi fallback — keeps the
+            // honest "silent, diagnostics are incomplete" half.
+            const lateDeliveryPending = unconfirmedServerIds.filter((serverId) => (lateDeliveryServerIds ?? []).includes(serverId));
+            if (lateDeliveryPending.length > 0) {
+                result.deferredServerIds = lateDeliveryPending;
+            }
             logLatency({
                 type: "phase",
                 phase: "lsp_touch_file",
@@ -5201,6 +5568,14 @@ export class LSPService {
                     ...(uncoveredDeferredServerIds.length > 0 && {
                         deferredResyncServerIds: uncoveredDeferredServerIds,
                     }),
+                    // #2810: the scanners this touch promised late delivery for, so a
+                    // field query can join the promise to the pending pair that has to
+                    // honour it — and tell it apart from `deferredResyncServerIds`
+                    // above, which is the door that opened BEFORE any wait and has no
+                    // delivery path at all.
+                    ...(lateDeliveryPending.length > 0 && {
+                        lateDeliveryServerIds: lateDeliveryPending,
+                    }),
                     // #1549: auxiliaries whose own deadline lapsed — the wait produced no
                     // publication, or the notify write never landed. Distinct from the fields
                     // above (a different door) and from `auxUnconfirmedServerIds` (derived
@@ -5437,7 +5812,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);
@@ -5854,6 +6229,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?.(),
@@ -5871,6 +6249,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?.(),
@@ -6599,6 +6980,42 @@ export class LSPService {
         const workspaceSweepScopeKey = buildScopeKey("all", [
             ...WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS,
         ]);
+        const touchScopedOpenDependencies = async (filePath) => {
+            if (options.files === undefined)
+                return true;
+            // Import coverage is language-neutral. Undefined means this file was
+            // not covered by the facts seam, so its cache entry is not eligible.
+            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();
@@ -6615,18 +7032,22 @@ export class LSPService {
             // exists to detect) must NOT be replayed and reconciled as confirmed via
             // mode=full. On a mismatch, fall through to a fresh touch.
             if (cached && cached.binding.boundToCurrentDisk !== false) {
-                cachedResults.push({
-                    filePath,
-                    diagnostics: cached.diagnostics,
-                    count: cached.count,
-                    // #1093: a cache hit replays an older observation — carry its
-                    // scan time so mode=full's footer reconcile stamps `touchedAt`
-                    // with when the truth was seen, not now().
-                    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,
+                        // #1093: a cache hit replays an older observation — carry its
+                        // scan time so mode=full's footer reconcile stamps `touchedAt`
+                        // with when the truth was seen, not now().
+                        observedAt: cached.scannedAt,
+                        contentHash: cached.binding.contentHash,
+                        boundToCurrentDisk: cached.binding.boundToCurrentDisk,
+                        writeIndex: writeIndexByPath.get(normalizeMapKey(filePath)),
+                    });
+                else
+                    filesToTouch.push(filePath);
             }
             else {
                 filesToTouch.push(filePath);
@@ -7042,7 +7463,7 @@ export class LSPService {
         // ONE bracket for the whole fan-out, not one per file (#2272 review F1).
         // Per-file bracketing was the first shape and it was inert for exactly
         // the case above: `phaseFinished` pushes onto a ring capped at
-        // `CLOSED_BRACKET_CAP` (5, clients/latency-logger.ts), while `turn_end`
+        // `RECENT_PHASE_CAP` (5, clients/latency-logger.ts), while `turn_end`
         // reads `getPhaseForWindow` AFTER the sweep returns. A 225-file sweep
         // therefore evicted the blocking file's own bracket unless the block
         // landed in the last five files, and the survivors were then rejected by
@@ -7412,16 +7833,17 @@ 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);
@@ -7515,6 +7937,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);
         }
@@ -7563,6 +7986,7 @@ export class LSPService {
         });
         this.state.clients.clear();
         this.state.broken.clear();
+        this.firstContactWaits.clear();
         // #1934 review F1: map hygiene alongside the breaker it sits next to.
         // Not load-bearing — every read follows its own attempt's write — but a
         // verdict for a client generation that no longer exists is dead weight.
@@ -7779,6 +8203,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 = {}) {
     // #2504 review round 2 (F3): whatever the retiring service was still being
     // asked for off-hook must stop HERE, before any teardown and before the