pi-lens 3.8.71 → 3.8.73

package/dist/clients/lsp/index.js

@@ -17,18 +17,19 @@ import { recordLsp } from "../widget-state.js";
 import { applyAuxiliarySuppressions } from "../dispatch/auxiliary-lsp.js";
 import { detectFileRole } from "../file-role.js";
 import { logLatency } from "../latency-logger.js";
+import { shouldPreferPullOnlyDiagnostics } from "../lsp-budget.js";
 import { withDeadline } from "../deadline-utils.js";
-import { normalizeMapKey, uriToPath } from "../path-utils.js";
+import { isAtOrAboveHomeDir, normalizeMapKey, uriToPath, } from "../path-utils.js";
 import { createLSPClient } from "./client.js";
 import { getServersForFileWithConfig, getServerInitOverride } from "./config.js";
 import { getLanguageId } from "./language.js";
 import { LSP_SERVERS, isDirectLspCommandTemporarilyUnavailable, } from "./server.js";
-import { getStrategy } from "./server-strategies.js";
+import { classifyCascadeWaitTier, classifyServerWaitTier, getStrategy, } from "./wait-policy/index.js";
 import { raceToCompletion } from "./aggregation.js";
 import { applyWorkspaceEdit, mergeWorkspaceTextEditsByPriority, summarizeWorkspaceEdit, } from "./edits.js";
 import { buildScopeKey, createWorkspaceDiagnosticsCacheContext, } from "./workspace-diagnostics-cache.js";
 import { attemptTsserverSyncDiagnostics, } from "./tsserver-sync.js";
-import { classifyCascadeWaitTier } from "./cascade-tier.js";
+import { isWarmAttached, tryWarmAttachedDiagnostics, } from "../warm-attach.js";
 // --- Init override helpers ---
 /**
  * Recursively merges `override` onto `base`. Override wins on leaf conflicts
@@ -68,6 +69,12 @@ export function mergeInitializationOptions(base, override) {
 const BROKEN_BASE_COOLDOWN_MS = 15_000;
 const BROKEN_MAX_COOLDOWN_MS = 5 * 60_000; // cap at 5 minutes
 const BROKEN_PERMANENT_AFTER = 5; // disable for session after N consecutive failures
+// #743: a server whose per-server notify write (didOpen/didChange) times out
+// this many times in a row is a persistently backpressured server; it is demoted
+// into the `broken` cooldown map (evicted + cooled down) so subsequent sweeps
+// stop re-paying its notify budget on every file. A single successful write
+// resets the streak.
+const NOTIFY_BACKPRESSURE_BROKEN_AFTER = 3;
 const OPTIONAL_LSP_RETRY_COOLDOWN_MS = 5 * 60_000;
 const OPTIONAL_LSP_SERVER_IDS = new Set();
 const NAV_CLIENT_WAIT_TIMEOUT_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_LSP_NAV_CLIENT_WAIT_MS ?? "1500", 10) ||
@@ -85,6 +92,17 @@ function warmupTimeoutMs() {
     const raw = Number.parseInt(process.env.PI_LENS_LSP_WARMUP_TIMEOUT_MS ?? "", 10);
     return Number.isFinite(raw) && raw > 0 ? raw : 20_000;
 }
+// #744: short pause between the first warm-up round trip and the single retry
+// `ensureWarmForSweep` gives a server that didn't warm on its first attempt.
+// Deliberately small — it's a breather for a server mid-relaunch/index (the
+// state where warmup failure is most likely, e.g. a sweep starting seconds
+// after an `lsp_service_reset`), not a second full budget. Read at call time so
+// tests can drive the retry without waiting out a real backoff. 0 disables the
+// pause entirely (retry fires immediately).
+function warmupRetryBackoffMs() {
+    const raw = Number.parseInt(process.env.PI_LENS_LSP_WARMUP_RETRY_BACKOFF_MS ?? "", 10);
+    return Number.isFinite(raw) && raw >= 0 ? raw : 500;
+}
 /**
  * Read the `PI_LENS_LSP_DIAGNOSTICS_MAX_WAIT_MS` env override at call time
  * (process.env mutations in tests stay live). Returns undefined when unset,
@@ -242,15 +260,14 @@ export async function runPerServerGroups(groups, concurrency, processGroup, sign
     let nextGroup = 0;
     const workers = Math.min(Math.max(1, concurrency), groups.length);
     await Promise.all(Array.from({ length: workers }, async () => {
-        while (true) {
-            if (signal?.aborted)
-                return;
+        while (!signal?.aborted) {
             const gi = nextGroup;
             nextGroup += 1;
             if (gi >= groups.length)
-                return;
+                break;
             await processGroup(groups[gi]);
         }
+        return true;
     }));
 }
 const WORKSPACE_DIAGNOSTICS_CONCURRENCY = 8;
@@ -332,8 +349,17 @@ function getMaxWorkspaceDiagnosticFiles() {
  * dropped user `"ignore": [...]` patterns and diverged from the canonical list
  * (#243). The walk is also hard-capped (#250).
  */
-async function collectWorkspaceDiagnosticFiles(root, maxFiles = getMaxWorkspaceDiagnosticFiles(), signal) {
+async function collectWorkspaceDiagnosticFiles(root, maxFiles = getMaxWorkspaceDiagnosticFiles(), signal, homeDir) {
     const files = [];
+    // #747/#250: the 5000-file cap alone bounds total work, but from a cwd at or
+    // above $HOME the walk still traverses (and pulls diagnostics for) 5000 files
+    // spread across every unrelated repo under home. Refuse outright — walking
+    // nothing is the honest result; the caller (runWorkspaceDiagnostics →
+    // tools/lens-diagnostics.ts) renders "unsafe root" so an empty sweep never
+    // reads as a clean project. Same ceiling as fresh-fetch.ts / the cheap-tier
+    // scanner.
+    if (isAtOrAboveHomeDir(root, homeDir))
+        return files;
     const ignoreMatcher = getProjectIgnoreMatcher(root);
     // #703: prime the tracked-files set once before the walk so a tracked file
     // matching a `.gitignore`/global pattern still gets its workspace
@@ -403,9 +429,27 @@ export class LSPService {
     lastKnownContentHash = new Map();
     lastDiagnosticsHealth = new Map();
     recentTouches = new Map();
+    /**
+     * #743: consecutive per-server notify-write timeout count, keyed by
+     * "serverId:normalizedRoot" — the SAME identity as {@link LSPState.broken}
+     * and {@link demonstratedReadyKeyFor}. A server that backpressures its stdin
+     * write {@link NOTIFY_BACKPRESSURE_BROKEN_AFTER} times in a row is demoted
+     * into the broken cooldown (see {@link recordNotifyWriteBackpressure}); any
+     * successful write clears its entry.
+     */
+    notifyWriteBackpressureStreak = new Map();
     /** True after shutdown() has been called; blocks new operations */
     isDestroyed = false;
-    constructor() {
+    /**
+     * #850: teardown completion for every singleton generation retired before
+     * this service was published. Only replacement services receive one; direct
+     * `new LSPService()` callers and the first singleton generation stay hot-path
+     * identical. Cleared after the first completed wait so warm reuse never pays
+     * a permanent promise/microtask tax.
+     */
+    generationHandoff;
+    constructor(generationHandoff) {
+        this.generationHandoff = generationHandoff;
         this.state = {
             clients: new Map(),
             servers: new Map(),
@@ -413,6 +457,7 @@ export class LSPService {
             inFlight: new Map(),
             clientSpawnedAt: new Map(),
             demonstratedReady: new Set(),
+            demonstratedCold: new Set(),
         };
     }
     /** Guard: return true if service is shutting down or shut down */
@@ -498,6 +543,46 @@ export class LSPService {
     }
     markDemonstratedReadyKey(key) {
         this.state.demonstratedReady.add(key);
+        // #799: readiness through ANY path supersedes an earlier cold verdict —
+        // a server that recovers later in the session must not stay stuck in
+        // the negative cache.
+        this.state.demonstratedCold.delete(key);
+    }
+    /**
+     * #743: record one notify-write timeout for a server and, once it has stalled
+     * {@link NOTIFY_BACKPRESSURE_BROKEN_AFTER} times in a row, demote it through
+     * the EXISTING broken-cooldown map so subsequent sweeps stop re-paying its
+     * notify budget on every file. The wedged client is also evicted: an alive
+     * client is reused before the broken check in {@link ensureClientForServer},
+     * so the cooldown only bites once the stale client is gone. `key` is
+     * "serverId:normalizedRoot" (the broken-map identity); undefined when the
+     * server's root could not be resolved, in which case there is nothing to key.
+     */
+    recordNotifyWriteBackpressure(key, entry, filePath) {
+        if (!key)
+            return;
+        const streak = (this.notifyWriteBackpressureStreak.get(key) ?? 0) + 1;
+        if (streak < NOTIFY_BACKPRESSURE_BROKEN_AFTER) {
+            this.notifyWriteBackpressureStreak.set(key, streak);
+            return;
+        }
+        this.notifyWriteBackpressureStreak.delete(key);
+        this.state.broken.set(key, Date.now() + BROKEN_BASE_COOLDOWN_MS);
+        void entry.client.shutdown().catch(() => { });
+        this.state.clients.delete(key);
+        this.state.clientSpawnedAt.delete(key);
+        this.state.demonstratedReady.delete(key);
+        logLatency({
+            type: "phase",
+            phase: "lsp_notify_backpressure_broken",
+            filePath: normalizeMapKey(filePath),
+            durationMs: 0,
+            metadata: {
+                serverId: entry.info.id,
+                cooldownMs: BROKEN_BASE_COOLDOWN_MS,
+                consecutiveTimeouts: NOTIFY_BACKPRESSURE_BROKEN_AFTER,
+            },
+        });
     }
     activeClientsForCwd(cwd, priorityServerIds = []) {
         const normalizedCwd = normalizeMapKey(cwd);
@@ -662,9 +747,38 @@ export class LSPService {
         }
         return undefined;
     }
+    /**
+     * Read-only liveness check for one server/file pair. Unlike
+     * `getClientForFile`, this never creates or warms a client; it only resolves
+     * the server's root and checks the already-connected client map.
+     */
+    async isServerAliveForFile(serverId, filePath) {
+        if (this.checkDestroyed())
+            return false;
+        for (const server of getServersForFileWithConfig(filePath)) {
+            if (server.id !== serverId)
+                continue;
+            const root = await server.root(filePath);
+            if (!root)
+                continue;
+            const key = `${server.id}:${normalizeMapKey(root)}`;
+            if (this.state.clients.get(key)?.isAlive())
+                return true;
+        }
+        return false;
+    }
     async ensureClientForServer(filePath, server) {
+        const handoff = this.generationHandoff;
+        if (handoff) {
+            await handoff;
+            if (this.generationHandoff === handoff) {
+                this.generationHandoff = undefined;
+            }
+            if (this.checkDestroyed())
+                return undefined;
+        }
         const root = await server.root(filePath);
-        if (!root)
+        if (!root || this.checkDestroyed())
             return undefined;
         const allowInstall = this.shouldAllowInstall(filePath, root);
         const normalizedRoot = normalizeMapKey(root);
@@ -755,6 +869,11 @@ export class LSPService {
         if (inFlight) {
             return inFlight;
         }
+        // `server.root()` and a dead client's shutdown above are both async. A
+        // reset during either gap may have completed without seeing this request in
+        // state.inFlight; never let that retired generation start a late spawn.
+        if (this.checkDestroyed())
+            return undefined;
         const spawnPromise = this.spawnClient(server, root, key, filePath, allowInstall);
         this.state.inFlight.set(key, spawnPromise);
         try {
@@ -986,23 +1105,70 @@ export class LSPService {
         // runner touch sequence expensive on slow TS projects.
         const notifySkipped = this.shouldSkipNotify(filePath, content, clientScope);
         const diagnosticBaselines = new Map(spawned.map((entry) => [entry.client, entry.client.diagnosticsVersion]));
-        let notifyWriteTimedOut = false;
+        // #743: PER-SERVER notify-write deadlines. Each server's didOpen/didChange
+        // write gets its OWN notifyWriteBudgetMs budget rather than one shared
+        // deadline over a single Promise.all — otherwise one backpressured server
+        // (stalled stdin) times out the write for the ENTIRE file, flipping every
+        // co-touched healthy server to inconclusive and zeroing its diagnostics.
+        // Bounded so a backpressured write can't hang the caller; on timeout we
+        // proceed — the diagnostics wait below is separately bounded and simply
+        // returns no fresh diagnostics for the server(s) that stalled.
+        //
+        // Holds the serverId of every server whose write did NOT land in time.
+        // The file-level `notifyWriteTimedOut` (logged below) means "at least one
+        // server timed out"; this list carries the per-server detail the
+        // demonstratedReady gate reads so a healthy sibling stays eligible.
+        const notifyWriteTimedOutServerIds = [];
         if (!notifySkipped) {
-            // Bounded so a backpressured write can't hang the caller (see
-            // notifyWriteBudgetMs). On timeout we proceed: the diagnostics wait below
-            // is separately bounded and simply returns no fresh diagnostics.
-            const wrote = await withDeadline(Promise.all(spawned.map((entry) => entry.client.notify.open(filePath, content, languageId, undefined, silent))), { ms: notifyWriteBudgetMs(), onTimeout: "undefined", onReject: "undefined" });
-            if (wrote === undefined) {
-                notifyWriteTimedOut = true;
+            const budget = notifyWriteBudgetMs();
+            await Promise.all(spawned.map(async (entry) => {
+                // Same identity as the broken/demonstratedReady maps.
+                const clientKey = await this.demonstratedReadyKeyFor(entry.info, filePath);
+                let wrote;
+                let rejected = false;
+                try {
+                    wrote = await withDeadline(entry.client.notify
+                        .open(filePath, content, languageId, undefined, silent)
+                        .then(() => true), { ms: budget, onTimeout: "undefined", onReject: "propagate" });
+                }
+                catch {
+                    // The write itself rejected (not backpressure): the content did
+                    // not land, so this server is inconclusive for the touch, but a
+                    // rejection is not a stdin-backpressure signal and must not count
+                    // toward the backpressure demotion streak.
+                    rejected = true;
+                }
+                if (wrote === true) {
+                    // A clean write clears any accrued backpressure streak (#743).
+                    if (clientKey)
+                        this.notifyWriteBackpressureStreak.delete(clientKey);
+                }
+                else {
+                    notifyWriteTimedOutServerIds.push(entry.info.id);
+                    if (!rejected) {
+                        this.recordNotifyWriteBackpressure(clientKey, entry, filePath);
+                    }
+                }
+                return true;
+            }));
+            if (notifyWriteTimedOutServerIds.length > 0) {
                 logLatency({
                     type: "phase",
                     phase: "lsp_notify_timeout",
                     filePath: normalizedPath,
                     durationMs: Date.now() - startedAt,
-                    metadata: { source, clientScope, serverCount: spawned.length },
+                    metadata: {
+                        source,
+                        clientScope,
+                        serverCount: spawned.length,
+                        timedOutServerIds: notifyWriteTimedOutServerIds,
+                    },
                 });
             }
         }
+        // File-level flag: at least one server's write timed out (kept for the
+        // conservative touch-wide `inconclusive` merge semantics — see below).
+        const notifyWriteTimedOut = notifyWriteTimedOutServerIds.length > 0;
         let diagnosticsTimedOut = false;
         // R8 (#714): server ids of aux-role servers whose push wait was cut off by
         // the aux grace window. Undefined when no aux was cut off (primary-only
@@ -1014,7 +1180,7 @@ export class LSPService {
         // (undefined = the race didn't produce an answer; the end-of-wait
         // fallback below may still fill it in on a timed-out empty result).
         let tsserverSyncEligible = false;
-        let tsserverSyncConfirmed = undefined;
+        let tsserverSyncConfirmed;
         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
@@ -1061,6 +1227,44 @@ export class LSPService {
                     }
                 }
             }
+            // #832: workspace-indexing servers that are classified as silent on
+            // clean do not benefit from the generic cold-indexing floor. Their
+            // configured strategy already gives the first sweep touch a bounded
+            // workspace-index budget (marksman: 1500ms), while the capability
+            // classification proves that a clean push has no affirmative signal to
+            // wait for. Keep this restricted to the workspace-indexing strategy:
+            // TypeScript is also a silent-on-clean push server, but its cold project
+            // load still needs the longer 20s floor.
+            //
+            // Build this from the live spawned client's capabilities rather than
+            // server id alone. Missing/throwing capability data fails closed, so a
+            // new or ambiguous server keeps the existing generous warm-up budget.
+            const silentCleanWarmupServers = new Set();
+            if (options.warmupOverride && (options.warmupAttempt ?? 1) <= 1) {
+                for (const entry of spawned) {
+                    const strategy = getStrategy(entry.client.serverId);
+                    if (strategy.workspaceIndexing !== true)
+                        continue;
+                    try {
+                        const snapshot = {
+                            serverId: entry.client.serverId,
+                            root: entry.client.root,
+                            operationSupport: entry.client.getOperationSupport(),
+                            workspaceDiagnosticsSupport: entry.client.getWorkspaceDiagnosticsSupport(),
+                            advertisedCommands: entry.client.getAdvertisedCommands(),
+                            rawCapabilityKeys: entry.client.getRawCapabilityKeys?.() ?? [],
+                            launchVariant: entry.client.getLaunchVariant?.(),
+                        };
+                        if (classifyServerWaitTier(entry.client.serverId, snapshot) ===
+                            "tier3-silent") {
+                            silentCleanWarmupServers.add(entry.client.serverId);
+                        }
+                    }
+                    catch {
+                        // Fail closed: capability uncertainty must retain the cold floor.
+                    }
+                }
+            }
             // Each server gets its OWN deadline, bounded by the caller cap as a
             // CEILING (never a floor) — so a clean push-silent primary (typescript
             // ~1s) can't hold the whole touch to a slow auxiliary's budget, and a
@@ -1088,6 +1292,18 @@ export class LSPService {
                     // if the strategy already wants more) rather than the normal
                     // ceiling — see `warmupOverride` doc on `LSPTouchFileOptions`.
                     if (options.warmupOverride) {
+                        // #832: a workspace-indexing server already classified as
+                        // silent-on-clean uses its strategy's bounded wait on the first
+                        // attempt; the generic cold floor is for servers whose cold work
+                        // can eventually produce a push answer (notably TypeScript).
+                        if (silentCleanWarmupServers.has(serverId)) {
+                            return Math.min(callerCap, strategyWait > 0 ? strategyWait : callerCap);
+                        }
+                        // #799: only the FIRST warm-up attempt for a cold server gets the
+                        // floor — see the `warmupAttempt` doc on `LSPTouchFileOptions`.
+                        if ((options.warmupAttempt ?? 1) > 1) {
+                            return Math.min(callerCap, strategyWait > 0 ? strategyWait : callerCap);
+                        }
                         return Math.max(callerCap, strategyWait > 0 ? strategyWait : 0);
                     }
                     return Math.min(callerCap, strategyWait > 0 ? strategyWait : callerCap);
@@ -1114,16 +1330,21 @@ export class LSPService {
             const timeoutMs = Math.max(0, ...spawned.map((e) => timeoutFor(e.client.serverId)));
             // #707: evaluate the tsserver sync clean-confirm gate BEFORE the wait
             // starts. Cheap synchronous gates first (notify succeeded, collecting,
-            // primary scope, strategy marked silentOnClean — only classic
-            // typescript-language-server carries that flag today), then the live
-            // capability-snapshot tier classification (`classifyCascadeWaitTier`,
-            // which also excludes native-ts7 via `launchVariant`). Non-typescript
-            // and pull-capable servers fail the synchronous `silentOnClean` gate and
-            // pay ZERO extra work — not even the snapshot read.
+            // primary scope, `serverId === "typescript"` — the sync commands this
+            // races are tsserver-specific protocol extensions, not a generic
+            // push-only capability, so #799 giving other servers (marksman) the
+            // SAME `silentOnClean` marker must not route them into a sync attempt
+            // that can never succeed for them), then the live capability-snapshot
+            // tier classification (`classifyCascadeWaitTier`, which also excludes
+            // native-ts7 via `launchVariant`). Every other server fails this
+            // synchronous gate and pays ZERO extra work — not even the snapshot
+            // read; a non-typescript `silentOnClean` server instead gets the
+            // generic (non-racing) clean-confirm fallback further below.
             if (!notifyWriteTimedOut &&
                 options.collectDiagnostics === true &&
                 clientScope === "primary" &&
                 spawned.length === 1 &&
+                spawned[0].client.serverId === "typescript" &&
                 getStrategy(spawned[0].client.serverId).silentOnClean === true) {
                 try {
                     const snapshots = await this.getCapabilitySnapshots(filePath);
@@ -1156,14 +1377,29 @@ export class LSPService {
                 spawned.some((e) => e.info.role === "auxiliary");
             // Per-server wait promises (each already bounded by its own
             // perServerTimeout — unchanged from before R8).
+            let pressureSnapshots = [];
+            if (shouldPreferPullOnlyDiagnostics()) {
+                try {
+                    pressureSnapshots = await this.getCapabilitySnapshots(filePath);
+                }
+                catch {
+                    // Fail-open: missing capability state keeps today's push fallback.
+                }
+            }
             const perServerWaits = spawned.map((entry) => {
                 const serverTimeout = timeoutFor(entry.client.serverId);
                 const baseline = diagnosticBaselines.get(entry.client);
+                const pullOnly = classifyServerWaitTier(entry.client.serverId, pressureSnapshots.find((snapshot) => snapshot.serverId === entry.client.serverId)) === "pull-capable";
                 const wait = !notifySkipped && Number.isFinite(baseline)
                     ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
                         minVersion: baseline,
+                        ...(pullOnly && { pullOnly: true }),
                     })
-                    : entry.client.waitForDiagnostics(filePath, serverTimeout);
+                    : pullOnly
+                        ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
+                            pullOnly: true,
+                        })
+                        : entry.client.waitForDiagnostics(filePath, serverTimeout);
                 return wait.catch(() => undefined);
             });
             // The push wait — same per-server budget composition as before #707;
@@ -1327,6 +1563,69 @@ export class LSPService {
                     },
                 });
             }
+            // #814: capability-aware AGGREGATE wait — generalize #799's
+            // single-server (`clientScope === "primary" && spawned.length === 1`)
+            // silent-clean confirm to multi-server `clientScope: "all"` touches
+            // (`lens_diagnostics` mode=full per-file sweep, `lsp_diagnostics`
+            // `serverScope: "all"`). #799's gate never fires here (it's scoped to
+            // the primary hot path), so a scope-"all" touch where every OTHER
+            // spawned server already answered but one push-only `silentOnClean`
+            // server (marksman on a clean markdown file) never publishes still
+            // reported the WHOLE touch `inconclusive`/`diagnosticsTimedOut` even
+            // though the "silence" is exactly what that server's own known
+            // clean-behavior predicts — not an unresolved question.
+            //
+            // A spawned server counts as "still outstanding" when nothing landed
+            // in its per-file diagnostics cache for THIS touch — `getAllDiagnostics`
+            // is keyed by file and `clearDiagnosticsForPath` (`client.ts`) deletes
+            // that file's entry as part of the didOpen/didChange this touch just
+            // sent, so a present entry can only be a FRESH answer (found or a real
+            // confirmed-empty push/pull), never a stale one bleeding through from
+            // an earlier touch. This is the same "did anything publish for this
+            // file since we asked" signal `cascade-tier.ts`'s Tier-3 reconcile
+            // already trusts (#240 doctrine) — reused here, not reinvented.
+            //
+            // The touch stays inconclusive unless EVERY still-outstanding server
+            // is classified `tier3-silent` (push-only + `silentOnClean`, the same
+            // `classifyServerWaitTier` rule the single-server gate below and the
+            // cascade lane use) — one ordinary push-only straggler (still
+            // genuinely analyzing) or a pull-capable server that never answered
+            // keeps the touch cautious, matching #799's "err toward caution"
+            // posture for partial timeouts. `!notifyWriteTimedOut` (touch-wide)
+            // plus the per-server re-check below are the same "the notify write
+            // must have actually landed" conservatism #799 established — a
+            // server's silence is only evidence of "clean" when we know it saw
+            // the new content.
+            if (diagnosticsTimedOut && !notifyWriteTimedOut && clientScope === "all") {
+                try {
+                    const outstanding = spawned.filter((entry) => !notifyWriteTimedOutServerIds.includes(entry.info.id) &&
+                        !entry.client.getAllDiagnostics().has(normalizedPath));
+                    if (outstanding.length > 0) {
+                        const snapshots = await this.getCapabilitySnapshots(filePath);
+                        const allSilent = outstanding.every((entry) => classifyServerWaitTier(entry.client.serverId, snapshots.find((s) => s.serverId === entry.client.serverId)) === "tier3-silent");
+                        if (allSilent) {
+                            diagnosticsTimedOut = false;
+                            logLatency({
+                                type: "phase",
+                                phase: "lsp_silent_clean_confirm",
+                                filePath: normalizedPath,
+                                durationMs: Date.now() - startedAt,
+                                metadata: {
+                                    source,
+                                    clientScope,
+                                    diagnosticsMode,
+                                    aggregate: true,
+                                    serverIds: outstanding.map((entry) => entry.client.serverId),
+                                },
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Fail-safe: leave `diagnosticsTimedOut` as-is — today's
+                    // inconclusive behavior, exactly like the single-server gate.
+                }
+            }
         }
         // #707: when the racing sync confirm won the wait, its answer IS the
         // collected result — the file's real syntactic + semantic state straight
@@ -1385,6 +1684,71 @@ export class LSPService {
                 // Any failure here falls through to today's inconclusive behavior.
             }
         }
+        // #799: generalize the "silent-clean push-only" confirm beyond
+        // typescript's active sync-command race above. That mechanism is
+        // TS-specific (`attemptTsserverSyncDiagnostics` races an actual
+        // `typescript.tsserverRequest` — no equivalent protocol exists for
+        // e.g. marksman) and is now scoped to `serverId === "typescript"`
+        // only (see the gate above), so it never fires for another
+        // `silentOnClean` server. This is the generic fallback for those
+        // servers: if the wait ran its full budget with a successful notify
+        // write and nothing published, and the live capability snapshot
+        // classifies this touch as tier3-silent (push-only + `silentOnClean`,
+        // #458's `classifyCascadeWaitTier`), that is not "still working" —
+        // `silentOnClean` means by definition this server publishes NOTHING
+        // on a clean transition, so a timeout under those conditions IS the
+        // confirmed-clean answer. `!tsserverSyncEligible` keeps this from
+        // ever double-deciding typescript's own touches — when the sync race
+        // was attempted and failed/was unavailable, typescript's existing
+        // "falls through to inconclusive, unchanged" contract (#707) is
+        // preserved exactly; typescript touches that never enter that gate
+        // (e.g. `collectDiagnostics: false`, like `ensureWarmForSweep`'s own
+        // warm-up call) are still eligible here as a genuine bonus fix. Scoped
+        // to `clientScope === "primary"`/`spawned.length === 1` exactly like
+        // the sync-eligible gate above (and like `ensureWarmForSweep`'s own
+        // `clientScope: "primary"` warm-up touch) so a multi-server
+        // with-auxiliary/all touch — where a partial timeout must stay
+        // cautious per the doc below — is never affected.
+        //
+        // #814: this is now a SPECIAL CASE of the more general per-server gate
+        // above (the `clientScope === "all"` block right before the diagnostics-
+        // wait `if` closes) — for `spawned.length === 1`, "every still-outstanding
+        // server is tier3-silent" collapses to exactly this single-server check.
+        // Left in place unchanged (rather than deleted/rewritten to delegate to
+        // the new gate) per #814's scope: a future cleanup could fold this block
+        // into the general one once both have soaked, but that's a separate,
+        // lower-risk follow-up, not bundled into this fix.
+        if (diagnosticsTimedOut &&
+            !notifyWriteTimedOut &&
+            !tsserverSyncEligible &&
+            clientScope === "primary" &&
+            spawned.length === 1 &&
+            getStrategy(spawned[0].client.serverId).silentOnClean === true) {
+            try {
+                const snapshots = await this.getCapabilitySnapshots(filePath);
+                if (classifyCascadeWaitTier(this, filePath, snapshots) === "tier3-silent") {
+                    diagnosticsTimedOut = false;
+                    if (collected !== undefined)
+                        collected = mergeLspDiagnostics([]);
+                    logLatency({
+                        type: "phase",
+                        phase: "lsp_silent_clean_confirm",
+                        filePath: normalizedPath,
+                        durationMs: Date.now() - startedAt,
+                        metadata: {
+                            source,
+                            clientScope,
+                            diagnosticsMode,
+                            serverId: spawned[0].client.serverId,
+                        },
+                    });
+                }
+            }
+            catch {
+                // Fail-safe: leave `diagnosticsTimedOut` as-is — today's inconclusive
+                // behavior.
+            }
+        }
         // A touch is inconclusive when EITHER the notify write or the
         // diagnostics wait hit their deadline for ANY of the spawned servers
         // (these flags are touch-wide, covering the whole `Promise.all` over
@@ -1399,8 +1763,17 @@ export class LSPService {
         // "actually warm" signal `ensureWarmForSweep` waits for — mark every
         // spawned server so a later sweep in this session sees the check as a
         // no-op instead of paying the warm-up round trip again.
-        if (diagnosticsMode !== "none" && !inconclusive) {
+        //
+        // #743: the diagnostics wait is a blanket (touch-wide) gate, but the
+        // notify-write timeout is now PER-SERVER — a healthy server whose sibling's
+        // write stalled must still be eligible, so only servers whose OWN write
+        // timed out are skipped here (rather than gating the whole loop on the
+        // file-level `inconclusive`).
+        const notifyTimedOutServerIds = new Set(notifyWriteTimedOutServerIds);
+        if (diagnosticsMode !== "none" && !diagnosticsTimedOut) {
             for (const entry of spawned) {
+                if (notifyTimedOutServerIds.has(entry.info.id))
+                    continue;
                 const key = await this.demonstratedReadyKeyFor(entry.info, filePath);
                 if (key)
                     this.markDemonstratedReadyKey(key);
@@ -1457,6 +1830,12 @@ export class LSPService {
                 collectedDiagnostics: collected?.length,
                 notifySkipped,
                 notifyWriteTimedOut,
+                // #743: per-server detail — which servers' writes actually timed out.
+                // Absent when none did. `notifyWriteTimedOut` is the file-level "at
+                // least one" summary.
+                ...(notifyWriteTimedOutServerIds.length > 0 && {
+                    notifyWriteTimedOutServerIds,
+                }),
                 diagnosticsTimedOut,
                 inconclusive,
                 // R8 (#714): server ids of auxiliaries whose push wait was cut off by
@@ -2030,14 +2409,45 @@ export class LSPService {
      * Returns `performedWarmup: true` only when the round trip actually ran
      * (false = already warm, no-op) — tests assert on this to guard against
      * the warm-up becoming a mandatory extra round trip on every sweep.
+     *
+     * #744: a warm-up that TIMES OUT is no longer left as a silent dead end.
+     * The old one-shot behavior left a wedged server (observed live: marksman,
+     * a `workspaceIndexing` server, burned the full 20s and stayed cold) with
+     * no re-warm and no skip — so every subsequent per-file touch in the sweep
+     * re-paid a full per-file budget against it and timed out again, dragging
+     * the whole sweep. Now: on a failed warm-up this retries exactly once (after
+     * a short `warmupRetryBackoffMs` breather — the state where warm-up fails is
+     * usually a server mid-relaunch/index that just needs a moment), and if the
+     * retry ALSO leaves the server cold it is reported in `failedServerIds`. The
+     * caller (the sweep loop) skips that server's files up front and marks them
+     * unconfirmed, so per-file touches stop paying its timeout. This is a
+     * sweep-scoped skip (the caller discards `failedServerIds` when the sweep
+     * ends), deliberately NOT the global `broken` cooldown map: a server that is
+     * merely still indexing is not broken and must not be cooldown-banned across
+     * the whole session — it just wasn't ready for THIS sweep.
+     *
+     * "Failed warm-up" is measured per non-auxiliary server via the SAME
+     * `demonstratedReady` signal `touchFile` marks on a confirmed round trip: a
+     * server whose key is still absent from `demonstratedReady` after both
+     * attempts never proved it can answer diagnostics. Warm-up stays
+     * `clientScope:"primary"` (not the sweep's `"all"`) on purpose: `"all"`
+     * would additionally spawn the sweep-EXCLUDED auxiliaries
+     * (`WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS`), and because `touchFile`'s
+     * `inconclusive` flag is touch-wide, one slow advisory auxiliary would then
+     * suppress the `demonstratedReady` marking for a perfectly healthy primary —
+     * falsely condemning it. Recording per-primary-server outcomes and skipping
+     * on those is the correct, non-regressing way to cover the servers the sweep
+     * actually gates on (the sweep groups by primary server, so the group this
+     * warms IS the one whose per-file touches would drag).
      */
     async ensureWarmForSweep(representativeFile, options = {}) {
         if (this.checkDestroyed() || options.signal?.aborted) {
-            return { performedWarmup: false };
+            return { performedWarmup: false, failedServerIds: [] };
         }
         const servers = getServersForFileWithConfig(representativeFile).filter((s) => s.role !== "auxiliary");
-        if (servers.length === 0)
-            return { performedWarmup: false };
+        if (servers.length === 0) {
+            return { performedWarmup: false, failedServerIds: [] };
+        }
         // A server with no resolvable root never spawns a client for this file
         // either way, so it can't block "already warm" — only servers that WILL
         // actually be used count toward the readiness check. Same key
@@ -2047,7 +2457,43 @@ export class LSPService {
         const keys = await Promise.all(servers.map((server) => this.demonstratedReadyKeyFor(server, representativeFile)));
         const alreadyWarm = keys.every((key) => key === undefined || this.state.demonstratedReady.has(key));
         if (alreadyWarm)
-            return { performedWarmup: false };
+            return { performedWarmup: false, failedServerIds: [] };
+        // #799: negative cache. Every server that still needs warming (not
+        // already `demonstratedReady`) was ALSO left cold by a warm-up earlier
+        // this session (`demonstratedCold`, populated below when a warm-up's
+        // initial attempt + retry both fail) — skip straight to the group-skip
+        // accounting the caller already has for `failedServerIds`, instead of
+        // re-paying the initial-attempt + retry round trip all over again. A
+        // MIXED group (one server cached cold, another never tried) still runs
+        // the real warm-up — the never-tried server deserves its fair shot, and
+        // `touchFile`'s multi-server spawn already covers both in one call.
+        const cachedColdServerIds = [];
+        let allNonWarmCached = true;
+        for (let i = 0; i < servers.length; i++) {
+            const key = keys[i];
+            if (key === undefined || this.state.demonstratedReady.has(key))
+                continue;
+            if (this.state.demonstratedCold.has(key)) {
+                cachedColdServerIds.push(servers[i].id);
+            }
+            else {
+                allNonWarmCached = false;
+            }
+        }
+        if (allNonWarmCached && cachedColdServerIds.length > 0) {
+            logLatency({
+                type: "phase",
+                phase: "lsp_sweep_warmup_cached_cold",
+                filePath: representativeFile,
+                durationMs: 0,
+                metadata: { serverIds: cachedColdServerIds },
+            });
+            return {
+                performedWarmup: false,
+                failedServerIds: cachedColdServerIds,
+                skippedFromCache: true,
+            };
+        }
         let content;
         try {
             content = await nodeFs.promises.readFile(representativeFile, "utf-8");
@@ -2055,55 +2501,129 @@ export class LSPService {
         catch {
             // Nothing to warm up with — the real sweep's own read will surface
             // the file error.
-            return { performedWarmup: false };
+            return { performedWarmup: false, failedServerIds: [] };
+        }
+        if (options.signal?.aborted) {
+            return { performedWarmup: false, failedServerIds: [] };
         }
-        if (options.signal?.aborted)
-            return { performedWarmup: false };
         const timeoutMs = options.timeoutMs ?? warmupTimeoutMs();
-        const startedAt = Date.now();
-        logLatency({
-            type: "phase",
-            phase: "lsp_sweep_warmup_start",
-            filePath: representativeFile,
-            durationMs: 0,
-            metadata: { serverIds: servers.map((s) => s.id), timeoutMs },
-        });
-        const warmupAttempt = this.touchFile(representativeFile, content, {
-            diagnostics: "document",
-            collectDiagnostics: false,
-            clientScope: "primary",
-            source: "lsp_sweep_warmup",
-            maxClientWaitMs: timeoutMs,
-            maxDiagnosticsWaitMs: timeoutMs,
-            // #669: the caller's cap here is the warm-up budget for a genuinely
-            // COLD server — it must act as a floor, not the usual ceiling, or
-            // `perServerTimeout` silently shrinks it to the strategy's normal
-            // warm-state `aggregateWaitMs` (e.g. 1000ms for typescript) instead
-            // of the requested 20000ms.
-            warmupOverride: true,
-        });
-        await (options.signal
-            ? Promise.race([
-                withDeadline(warmupAttempt, { ms: timeoutMs, onTimeout: "undefined" }),
-                new Promise((resolve) => {
-                    if (options.signal.aborted) {
-                        resolve();
-                        return;
-                    }
-                    options.signal.addEventListener("abort", () => resolve(), {
+        // A non-auxiliary server that WILL spawn for this file (resolvable key)
+        // but whose key is still absent from `demonstratedReady` after an attempt
+        // never proved it can answer diagnostics — that's a failed warm-up. A
+        // server with an unresolvable key never spawns here, so it can't fail this
+        // way and is excluded (never skipped by the caller for this file).
+        const stillColdServerIds = () => {
+            const cold = [];
+            for (let i = 0; i < servers.length; i++) {
+                const key = keys[i];
+                if (key !== undefined && !this.state.demonstratedReady.has(key)) {
+                    cold.push(servers[i].id);
+                }
+            }
+            return cold;
+        };
+        const runWarmupTouch = async (attempt) => {
+            if (options.signal?.aborted)
+                return;
+            const startedAt = Date.now();
+            logLatency({
+                type: "phase",
+                phase: "lsp_sweep_warmup_start",
+                filePath: representativeFile,
+                durationMs: 0,
+                metadata: { serverIds: servers.map((s) => s.id), timeoutMs, attempt },
+            });
+            const warmupAttempt = this.touchFile(representativeFile, content, {
+                diagnostics: "document",
+                collectDiagnostics: false,
+                clientScope: "primary",
+                source: "lsp_sweep_warmup",
+                maxClientWaitMs: timeoutMs,
+                maxDiagnosticsWaitMs: timeoutMs,
+                // #669: the caller's cap here is the warm-up budget for a genuinely
+                // COLD server — it must act as a floor, not the usual ceiling, or
+                // `perServerTimeout` silently shrinks it to the strategy's normal
+                // warm-state `aggregateWaitMs` (e.g. 1000ms for typescript) instead
+                // of the requested 20000ms.
+                warmupOverride: true,
+                // #799: only attempt 1 gets the cold-start floor — see the
+                // `warmupAttempt` doc on `LSPTouchFileOptions`.
+                warmupAttempt: attempt,
+            });
+            await (options.signal
+                ? Promise.race([
+                    withDeadline(warmupAttempt, {
+                        ms: timeoutMs,
+                        onTimeout: "undefined",
+                    }),
+                    new Promise((resolve) => {
+                        if (options.signal.aborted) {
+                            resolve();
+                            return;
+                        }
+                        options.signal.addEventListener("abort", () => resolve(), {
+                            once: true,
+                        });
+                    }),
+                ])
+                : withDeadline(warmupAttempt, {
+                    ms: timeoutMs,
+                    onTimeout: "undefined",
+                }));
+            logLatency({
+                type: "phase",
+                phase: "lsp_sweep_warmup_done",
+                filePath: representativeFile,
+                durationMs: Date.now() - startedAt,
+                metadata: {
+                    serverIds: servers.map((s) => s.id),
+                    timeoutMs,
+                    attempt,
+                    coldServerIds: stillColdServerIds(),
+                },
+            });
+        };
+        await runWarmupTouch(1);
+        let failedServerIds = stillColdServerIds();
+        // One retry, and only when the first attempt actually left a server cold —
+        // a short backoff first so a server mid-relaunch/index gets a breather
+        // rather than an immediate second hammer.
+        if (failedServerIds.length > 0 && !options.signal?.aborted) {
+            const backoffMs = warmupRetryBackoffMs();
+            if (backoffMs > 0) {
+                await new Promise((resolve) => {
+                    const timer = setTimeout(resolve, backoffMs);
+                    timer.unref?.();
+                    options.signal?.addEventListener("abort", () => resolve(), {
                         once: true,
                     });
-                }),
-            ])
-            : withDeadline(warmupAttempt, { ms: timeoutMs, onTimeout: "undefined" }));
-        logLatency({
-            type: "phase",
-            phase: "lsp_sweep_warmup_done",
-            filePath: representativeFile,
-            durationMs: Date.now() - startedAt,
-            metadata: { serverIds: servers.map((s) => s.id), timeoutMs },
-        });
-        return { performedWarmup: true };
+                });
+            }
+            if (!options.signal?.aborted) {
+                await runWarmupTouch(2);
+                failedServerIds = stillColdServerIds();
+            }
+        }
+        if (failedServerIds.length > 0) {
+            logLatency({
+                type: "phase",
+                phase: "lsp_sweep_warmup_failed",
+                filePath: representativeFile,
+                durationMs: 0,
+                metadata: { failedServerIds, timeoutMs },
+            });
+            // #799: record the negative cache so a LATER sweep this session
+            // skips straight past re-paying this warm-up (initial + retry).
+            // Cleared automatically the moment the server demonstrates
+            // readiness through any path (`markDemonstratedReadyKey`).
+            for (let i = 0; i < servers.length; i++) {
+                const key = keys[i];
+                if (key !== undefined && failedServerIds.includes(servers[i].id)) {
+                    this.state.demonstratedCold.add(key);
+                }
+            }
+        }
+        return { performedWarmup: true, failedServerIds };
     }
     /**
      * Actively scan every LSP-supported source file under a project root.
@@ -2252,6 +2772,8 @@ export class LSPService {
         // existing group-worker pool.
         const contentCache = new Map();
         const preOpenGroupFiles = async (groupFiles) => {
+            if (isWarmAttached())
+                return;
             for (const filePath of groupFiles) {
                 if (signal?.aborted)
                     return;
@@ -2333,20 +2855,28 @@ export class LSPService {
                 // onTimeout:"undefined" so a hung file yields no diagnostics and the
                 // worker moves on; a real touchFile rejection still propagates to the
                 // catch below and is recorded as an error.
-                const diagnostics = await withDeadline(this.touchFile(filePath, content, {
-                    diagnostics: "document",
-                    collectDiagnostics: true,
-                    clientScope: "all",
-                    source: "lens_diagnostics_full",
-                    // #584: opengrep's findings for a full sweep come from the
-                    // `opengrep-client.ts` CLI extractor (one project-wide scan,
-                    // cached, read via extractors.ts) instead — see the
-                    // `excludeServerIds` doc on `LSPTouchFileOptions`.
-                    excludeServerIds: WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS,
-                    // #645: lets a workspaceIndexing server (marksman) pay its
-                    // full wait budget only once across this whole sweep.
-                    sweepIndexGate,
-                }), { ms: perFileMs, onTimeout: "undefined" });
+                const attached = isWarmAttached()
+                    ? await tryWarmAttachedDiagnostics(filePath, content, perFileMs, "sweep")
+                    : undefined;
+                if (attached && !attached.available) {
+                    await this.ensureWarmForSweep(filePath, { signal });
+                }
+                const diagnostics = attached?.available
+                    ? attached.response.diagnostics
+                    : await withDeadline(this.touchFile(filePath, content, {
+                        diagnostics: "document",
+                        collectDiagnostics: true,
+                        clientScope: "all",
+                        source: "lens_diagnostics_full",
+                        // #584: opengrep's findings for a full sweep come from the
+                        // `opengrep-client.ts` CLI extractor (one project-wide scan,
+                        // cached, read via extractors.ts) instead — see the
+                        // `excludeServerIds` doc on `LSPTouchFileOptions`.
+                        excludeServerIds: WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS,
+                        // #645: lets a workspaceIndexing server (marksman) pay its
+                        // full wait budget only once across this whole sweep.
+                        sweepIndexGate,
+                    }), { ms: perFileMs, onTimeout: "undefined" });
                 // #571: prefer #570's real per-touch inconclusive signal
                 // (`touchFile`'s non-enumerable `.inconclusive` flag — set when the
                 // notify write or the diagnostics wait itself timed out) over this
@@ -2426,7 +2956,9 @@ export class LSPService {
             if (signal?.aborted)
                 return;
             // Fast path: one project-wide pull for the whole group (opt-in).
-            if (workspacePullEnabled && !group.multiServer) {
+            if (!isWarmAttached() &&
+                workspacePullEnabled &&
+                !group.multiServer) {
                 const pulled = await this.tryWorkspacePull(group.files, perFileMs);
                 if (pulled) {
                     for (const result of pulled) {
@@ -2457,10 +2989,48 @@ export class LSPService {
             // budget in one shot — the per-file "first N files eat individual
             // timeouts" failure mode this fixes doesn't apply there.
             const first = group.files[0];
-            if (first) {
-                await this.ensureWarmForSweep(first, { signal });
+            if (first && !isWarmAttached()) {
+                const warmup = await this.ensureWarmForSweep(first, { signal });
                 if (signal?.aborted)
                     return;
+                // #744: the group's primary server failed warm-up (initial round
+                // trip + one retry both left it cold). Every per-file touch to it
+                // would re-pay its full timeout and time out again, dragging the
+                // whole sweep — the exact wedged-marksman failure mode this closes.
+                // So skip this group's files and record each as UNCONFIRMED
+                // (timedOut + skippedWarmupFailure), never as confirmed-clean `[]`:
+                // the group is keyed by its primary server, so a non-empty
+                // `failedServerIds` means that primary is the one that couldn't warm.
+                if (warmup.failedServerIds.length > 0) {
+                    logLatency({
+                        type: "phase",
+                        phase: "lsp_sweep_group_skipped_warmup",
+                        filePath: first,
+                        durationMs: 0,
+                        metadata: {
+                            failedServerIds: warmup.failedServerIds,
+                            // #799: distinguishes a fresh warm-up failure from a
+                            // negative-cache hit (this sweep never re-attempted warm-up
+                            // at all — it was already known cold from earlier this
+                            // session).
+                            skippedFromCache: warmup.skippedFromCache ?? false,
+                            skippedFiles: group.files.length,
+                        },
+                    });
+                    for (const filePath of group.files) {
+                        results.push({
+                            filePath,
+                            diagnostics: [],
+                            count: 0,
+                            timedOut: true,
+                            skippedWarmupFailure: true,
+                        });
+                        timedOutFiles += 1;
+                        completed += 1;
+                    }
+                    options.onProgress?.(completed, files.length);
+                    return;
+                }
             }
             // #608/#621: batch-open a CHUNK of this group's files before
             // waiting on diagnostics for any of them individually — see
@@ -2575,6 +3145,7 @@ export class LSPService {
                 catch {
                     /* missing → will be pruned */
                 }
+                return true;
             }));
             client.pruneDiagnostics((filePath, ts) => !existingPaths.has(filePath) ||
                 now - ts > CASCADE_DIAGNOSTICS_TTL_MS);
@@ -2658,14 +3229,13 @@ export class LSPService {
                 processExiting: !!options.processExiting,
             },
         });
-        for (const [_key, client] of this.state.clients) {
-            try {
-                await client.shutdown(options);
-            }
-            catch {
-                // pi-lens-ignore: missing-error-propagation — per-client shutdown failure, must not abort remaining shutdowns
-            }
-        }
+        // Start every client teardown before awaiting any of them. A non-fast
+        // process-tree kill can spend its grace period per client, so awaiting in
+        // map order makes the reset tail O(clientCount * grace) instead of the
+        // maximum individual teardown. allSettled preserves the per-client
+        // best-effort contract: one failure must not prevent other clients from
+        // finishing, and the caller still waits for every teardown to settle.
+        await Promise.allSettled(Array.from(this.state.clients.values(), (client) => Promise.resolve().then(() => client.shutdown(options))));
         this.state.clients.clear();
         this.state.broken.clear();
         this.workspaceProbeLogged.clear();
@@ -2717,25 +3287,53 @@ export class LSPService {
 }
 // --- Singleton Instance ---
 let globalLSPService = null;
+/**
+ * #850: all singleton generations whose teardown is still pending. A new
+ * generation may be allocated synchronously, but its first spawn waits on this
+ * handoff so two generations can never own the same server/root concurrently.
+ */
+let globalLSPGenerationHandoff;
 export function getLSPService() {
     if (!globalLSPService) {
-        globalLSPService = new LSPService();
+        globalLSPService = new LSPService(globalLSPGenerationHandoff);
     }
     return globalLSPService;
 }
+/**
+ * Cross-layer liveness seam for dispatch-side auxiliary gates. This is a
+ * liveness read only: it does not spawn, wait for initialization, or probe a
+ * binary.
+ */
+export async function isAuxiliaryLspAlive(serverId, filePath) {
+    return getLSPService().isServerAliveForFile(serverId, filePath);
+}
 export function resetLSPService(options = {}) {
-    if (globalLSPService) {
-        globalLSPService.shutdown(options).catch(() => { });
-    }
+    const retiringService = globalLSPService;
     globalLSPService = null;
+    if (!retiringService)
+        return;
+    // shutdown() marks the service destroyed synchronously before its first
+    // await. Include both that teardown and every earlier pending generation:
+    // repeated resets may retire a replacement that is itself still waiting on
+    // its predecessor. allSettled keeps teardown best-effort without ever
+    // rejecting (and therefore permanently poisoning) the next generation.
+    const teardown = retiringService.shutdown(options);
+    const pending = globalLSPGenerationHandoff
+        ? [globalLSPGenerationHandoff, teardown]
+        : [teardown];
+    const handoff = Promise.allSettled(pending).then(() => undefined);
+    globalLSPGenerationHandoff = handoff;
+    void handoff.then(() => {
+        if (globalLSPGenerationHandoff === handoff) {
+            globalLSPGenerationHandoff = undefined;
+        }
+    });
 }
 /**
  * Test-only: exposes the async workspace-diagnostics file walk so its
  * event-loop occupancy can be guarded (see workspace-diagnostics-occupancy
  * test). Not part of the public API.
  */
-export function __collectWorkspaceDiagnosticFilesForTest(root, maxFiles, signal) {
-    return maxFiles === undefined
-        ? collectWorkspaceDiagnosticFiles(path.resolve(root), undefined, signal)
-        : collectWorkspaceDiagnosticFiles(path.resolve(root), maxFiles, signal);
+export function __collectWorkspaceDiagnosticFilesForTest(root, maxFiles, signal, homeDir) {
+    return collectWorkspaceDiagnosticFiles(path.resolve(root), maxFiles ?? getMaxWorkspaceDiagnosticFiles(), signal, homeDir);
 }