pi-lens 3.8.39 → 3.8.41

package/clients/lsp/aggregation.ts

@@ -0,0 +1,91 @@
+/**
+ * Diagnostic Aggregation Utilities for pi-lens LSP
+ *
+ * Provides result-aware racing for multi-client diagnostic collection.
+ * Replaces the simple Promise.race + grace window pattern with one that
+ * only fires the grace window when a client actually returned diagnostics.
+ */
+
+/**
+ * Race a set of promises to completion, resolving as soon as the
+ * `shouldComplete` predicate is satisfied by the accumulated results.
+ *
+ * Key difference from Promise.race: Promise.race resolves when ANY promise
+ * settles (even with an empty/useless result). raceToCompletion only resolves
+ * early when results meet a quality threshold, optionally with a grace window
+ * to let more results accumulate.
+ *
+ * @param promises - Array of promises producing results
+ * @param shouldComplete - Called after each settled promise with all results
+ *   accumulated so far. Return true to trigger early completion.
+ * @param options.timeoutMs - Hard deadline; after this, resolve with whatever is ready
+ * @param options.graceMs - After shouldComplete returns true, wait this many ms
+ *   for additional results before finalizing. 0 = finalize immediately.
+ */
+export async function raceToCompletion<T>(
+	promises: Promise<T>[],
+	shouldComplete: (results: T[]) => boolean,
+	options: { timeoutMs: number; graceMs?: number } = { timeoutMs: 1500 },
+): Promise<T[]> {
+	const results: (T | undefined)[] = new Array(promises.length).fill(undefined);
+	let graceTimer: ReturnType<typeof setTimeout> | undefined;
+	let completed = false;
+	let remaining = promises.length;
+
+	return new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			completed = true;
+			if (graceTimer) clearTimeout(graceTimer);
+			resolve(results.filter((r): r is T => r !== undefined));
+		}, options.timeoutMs);
+
+		const finalize = () => {
+			if (completed) return;
+			completed = true;
+			clearTimeout(timeout);
+			if (graceTimer) clearTimeout(graceTimer);
+			resolve(results.filter((r): r is T => r !== undefined));
+		};
+
+		const check = () => {
+			if (completed) return;
+
+			if (remaining === 0) {
+				finalize();
+				return;
+			}
+
+			const collected = results.filter((r): r is T => r !== undefined);
+			if (shouldComplete(collected)) {
+				if (
+					options.graceMs !== undefined &&
+					options.graceMs > 0 &&
+					!graceTimer
+				) {
+					// Start grace window — more results may arrive
+					graceTimer = setTimeout(() => finalize(), options.graceMs);
+				} else {
+					finalize();
+				}
+			}
+		};
+
+		for (let i = 0; i < promises.length; i++) {
+			const index = i;
+			promises[i]
+				.then((result) => {
+					if (!completed) {
+						results[index] = result;
+						remaining--;
+						check();
+					}
+				})
+				.catch(() => {
+					if (!completed) {
+						remaining--;
+						check();
+					}
+				});
+		}
+	});
+}

package/clients/lsp/client.ts

@@ -8,9 +8,9 @@
  * - Request/response handling
  */
 
-import { existsSync } from "node:fs";
 import { spawn as nodeSpawn } from "node:child_process";
 import { EventEmitter } from "node:events";
+import { existsSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import type { MessageConnection } from "vscode-jsonrpc";
 import {
@@ -21,6 +21,7 @@ import {
 
 import type { LSPProcess } from "./launch.js";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
+import { getStrategy } from "./server-strategies.js";
 
 // --- Types ---
 
@@ -228,10 +229,6 @@ export interface LSPClientInfo {
 
 // --- Constants ---
 
-const DIAGNOSTICS_DEBOUNCE_MS = positiveIntFromEnv(
-	"PI_LENS_LSP_DIAGNOSTICS_DEBOUNCE_MS",
-	150,
-); // ms — waits for follow-up semantic diagnostics
 const INITIALIZE_TIMEOUT_MS = positiveIntFromEnv(
 	"PI_LENS_LSP_INIT_TIMEOUT_MS",
 	15_000,
@@ -244,14 +241,14 @@ const DIAGNOSTICS_WAIT_TIMEOUT_MS = positiveIntFromEnv(
 	"PI_LENS_LSP_DIAGNOSTICS_WAIT_MS",
 	10_000,
 );
-const PULL_DIAGNOSTICS_RETRY_BUDGET_MS = positiveIntFromEnv(
-	"PI_LENS_LSP_PULL_RETRY_BUDGET_MS",
-	1200,
-);
 const PULL_DIAGNOSTICS_RETRY_INTERVAL_MS = positiveIntFromEnv(
 	"PI_LENS_LSP_PULL_RETRY_INTERVAL_MS",
 	250,
 );
+const SHUTDOWN_REQUEST_TIMEOUT_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_SHUTDOWN_TIMEOUT_MS",
+	1000,
+);
 
 const LSP_CRASH_CODES = new Set([
 	"ERR_STREAM_DESTROYED",
@@ -340,6 +337,33 @@ function disposeClientConnection(state: LSPClientState): void {
 	}
 }
 
+async function killProcessTree(
+	proc: { kill(signal?: NodeJS.Signals | number): boolean },
+	pid: number,
+): Promise<void> {
+	if (process.platform === "win32" && pid > 0) {
+		await new Promise<void>((resolve) => {
+			try {
+				// Absolute path avoids PATH-resolution: SystemRoot is set by Windows itself.
+				const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
+				const killer = nodeSpawn(taskkill, ["/F", "/T", "/PID", String(pid)], {
+					shell: false,
+					windowsHide: true,
+				});
+				killer.once("close", () => resolve());
+				killer.once("error", () => resolve());
+			} catch {
+				resolve();
+			}
+		});
+		return;
+	}
+
+	try {
+		proc.kill("SIGTERM");
+	} catch {}
+}
+
 function mergeDiagnosticLists(
 	push: LSPDiagnostic[] | undefined,
 	pull: LSPDiagnostic[] | undefined,
@@ -450,6 +474,19 @@ function setupIncomingHandlers(
 			const filePath = uriToPath(params.uri);
 			const normalizedPath = normalizeMapKey(filePath);
 			const newDiags: LSPDiagnostic[] = params.diagnostics || [];
+			const strategy = getStrategy(state.serverId);
+
+			// Seed on first push for servers whose first push is known complete.
+			// Bypasses the debounce timer entirely — resolves waiting promises immediately.
+			if (
+				strategy.seedFirstPush &&
+				!state.pushDiagnostics.has(normalizedPath)
+			) {
+				state.pushDiagnostics.set(normalizedPath, newDiags);
+				state.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
+				state.diagnosticEmitter.emit("diagnostics", normalizedPath);
+				return;
+			}
 
 			const existingTimer = state.pendingDiagnostics.get(normalizedPath);
 			if (existingTimer) clearTimeout(existingTimer);
@@ -459,7 +496,7 @@ function setupIncomingHandlers(
 				state.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
 				state.pendingDiagnostics.delete(normalizedPath);
 				state.diagnosticEmitter.emit("diagnostics", normalizedPath);
-			}, DIAGNOSTICS_DEBOUNCE_MS);
+			}, strategy.debounceMs);
 
 			state.pendingDiagnostics.set(normalizedPath, timer);
 		},
@@ -483,9 +520,7 @@ function setupIncomingHandlers(
 	);
 	state.connection.onRequest(
 		"client/unregisterCapability",
-		async (params: {
-			unregisterations?: Array<{ id: string }>;
-		}) => {
+		async (params: { unregisterations?: Array<{ id: string }> }) => {
 			for (const unreg of params?.unregisterations ?? []) {
 				if (unreg.id) {
 					state.dynamicRegistrations.delete(unreg.id);
@@ -579,7 +614,11 @@ export async function clientWaitForDiagnostics(
 		const firstPullCount = await clientRequestPullDiagnostics(state, filePath);
 		if (firstPullCount > 0) return;
 
-		const retryBudgetMs = Math.min(timeoutMs, PULL_DIAGNOSTICS_RETRY_BUDGET_MS);
+		const strategy = getStrategy(state.serverId);
+		const retryBudgetMs =
+			strategy.pullRetryBudgetMs > 0
+				? Math.min(timeoutMs, strategy.pullRetryBudgetMs)
+				: 0;
 		const startedAt = Date.now();
 		let latestCount = firstPullCount;
 
@@ -600,11 +639,19 @@ export async function clientWaitForDiagnostics(
 		const onDiagnostics = (fp: string) => {
 			if (normalizeMapKey(fp) !== normalizedPath) return;
 			if (debounceTimer) clearTimeout(debounceTimer);
+
+			// Adaptive debounce: use time since last push to compute remaining
+			// wait instead of always waiting the full debounce window.
+			const strategy = getStrategy(state.serverId);
+			const hit = state.pushDiagnosticTimestamps.get(normalizedPath);
+			const timeSincePush = hit ? Date.now() - hit : Infinity;
+			const remaining = Math.max(0, strategy.debounceMs - timeSincePush);
+
 			debounceTimer = setTimeout(() => {
 				state.diagnosticEmitter.off("diagnostics", onDiagnostics);
 				clearTimeout(timeout);
 				resolve();
-			}, DIAGNOSTICS_DEBOUNCE_MS);
+			}, remaining);
 		};
 
 		state.diagnosticEmitter.on("diagnostics", onDiagnostics);
@@ -715,9 +762,12 @@ async function clientShutdown(state: LSPClientState): Promise<void> {
 	state.openDocuments.clear();
 	state.diagnosticEmitter.removeAllListeners();
 	try {
-		await safeSendRequest(state.connection, "shutdown", {});
+		await withTimeout(
+			safeSendRequest(state.connection, "shutdown", {}),
+			SHUTDOWN_REQUEST_TIMEOUT_MS,
+		);
 	} catch {
-		/* ignore */
+		/* ignore — proceed to exit/kill so shutdown cannot hang the session */
 	}
 	try {
 		await safeSendNotification(state.connection, "exit", {});
@@ -725,7 +775,10 @@ async function clientShutdown(state: LSPClientState): Promise<void> {
 		/* ignore */
 	}
 	disposeClientConnection(state);
-	state.lspProcess.process.kill();
+	const pid = state.lspProcess.pid;
+	// On Windows, killing the direct child first can orphan grandchildren before
+	// taskkill can traverse the tree. Kill the full tree first and wait briefly.
+	await killProcessTree(state.lspProcess.process, pid);
 }
 
 async function navRequest<T>(
@@ -902,17 +955,11 @@ export async function createLSPClient(options: {
 		// Hard-kill the hung process so it doesn't become a zombie.
 		// SIGTERM alone is unreliable on Windows for cmd.exe/PowerShell trees.
 		const pid = lspProcess.pid;
-		lspProcess.process.kill("SIGTERM");
-		if (process.platform === "win32" && pid > 0) {
-			try {
-				nodeSpawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
-					shell: false,
-					windowsHide: true,
-				});
-			} catch {}
-		}
+		void killProcessTree(lspProcess.process, pid);
 		setTimeout(() => {
-			if (!lspProcess.process.killed) lspProcess.process.kill("SIGKILL");
+			if (!lspProcess.process.killed && process.platform !== "win32") {
+				lspProcess.process.kill("SIGKILL");
+			}
 		}, 2000);
 		throw err;
 	} finally {
@@ -940,7 +987,8 @@ export async function createLSPClient(options: {
 		);
 	}
 
-	state.workspaceDiagnosticsSupport = detectWorkspaceDiagnosticsSupport(initResult);
+	state.workspaceDiagnosticsSupport =
+		detectWorkspaceDiagnosticsSupport(initResult);
 	state.operationSupport = detectOperationSupport(initResult);
 	state.staticDiagnosticsMode = state.workspaceDiagnosticsSupport.mode;
 
@@ -1247,19 +1295,24 @@ async function withTimeout<T>(
 	promise: Promise<T>,
 	timeoutMs: number,
 ): Promise<T> {
+	let timeout: ReturnType<typeof setTimeout> | undefined;
 	// Suppress unhandled rejection if `promise` rejects AFTER the timeout
 	// wins the race — Promise.race settles on the first result but the
 	// losing promises still run, and any later rejection would be uncaught.
 	promise.catch(() => {});
-	return Promise.race([
-		promise,
-		new Promise<T>((_, reject) =>
-			setTimeout(
-				() => reject(new Error(`Timeout after ${timeoutMs}ms`)),
-				timeoutMs,
-			),
-		),
-	]);
+	try {
+		return await Promise.race([
+			promise,
+			new Promise<T>((_, reject) => {
+				timeout = setTimeout(
+					() => reject(new Error(`Timeout after ${timeoutMs}ms`)),
+					timeoutMs,
+				);
+			}),
+		]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
 }
 
 function positiveIntFromEnv(name: string, fallback: number): number {

package/clients/lsp/index.ts

@@ -12,6 +12,7 @@ import * as nodeFs from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { recordLsp } from "../widget-state.js";
 import { logLatency } from "../latency-logger.js";
 import { normalizeMapKey, uriToPath } from "../path-utils.js";
 import type { LSPClientInfo } from "./client.js";
@@ -19,6 +20,8 @@ import { createLSPClient } from "./client.js";
 import { getServersForFileWithConfig } from "./config.js";
 import { getLanguageId } from "./language.js";
 import type { LSPServerInfo } from "./server.js";
+import { getStrategy } from "./server-strategies.js";
+import { raceToCompletion } from "./aggregation.js";
 
 // --- Types ---
 
@@ -44,13 +47,6 @@ const TOUCH_DEBOUNCE_MS = Math.max(
 	Number.parseInt(process.env.PI_LENS_LSP_TOUCH_DEBOUNCE_MS ?? "1500", 10) ||
 		1500,
 );
-const DIAGNOSTICS_AGGREGATE_WAIT_MS = Math.max(
-	0,
-	Number.parseInt(
-		process.env.PI_LENS_LSP_DIAGNOSTICS_AGGREGATE_WAIT_MS ?? "1500",
-		10,
-	) || 1500,
-);
 const DIAGNOSTICS_SEMANTIC_SETTLE_THRESHOLD_MS = Math.max(
 	0,
 	Number.parseInt(
@@ -197,11 +193,22 @@ export class LSPService {
 		clientScope: "primary" | "all",
 	): void {
 		const key = `${normalizeMapKey(filePath)}:${clientScope}`;
+		const now = Date.now();
 		this.recentTouches.set(key, {
 			fingerprint: this.fingerprintContent(content),
-			touchedAt: Date.now(),
+			touchedAt: now,
 			clientScope,
 		});
+		// Trim entries that are already past the debounce window — shouldSkipTouch
+		// ignores them anyway, so they serve no purpose. Only sweep when the map
+		// exceeds the threshold to avoid iterating on every call.
+		if (this.recentTouches.size > 200) {
+			for (const [k, v] of this.recentTouches) {
+				if (now - v.touchedAt > TOUCH_DEBOUNCE_MS) {
+					this.recentTouches.delete(k);
+				}
+			}
+		}
 	}
 
 	/**
@@ -326,7 +333,7 @@ export class LSPService {
 
 		const normalizedRoot = normalizeMapKey(root);
 		const key = `${server.id}:${normalizedRoot}`;
-		const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id);
+		const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id); // NOSONAR: set intentionally empty — no optional servers configured yet
 
 		if (isOptionalServer && this.optionalDisabled.has(key)) {
 			return undefined;
@@ -406,17 +413,19 @@ export class LSPService {
 		filePath: string,
 		allowInstall: boolean,
 	): Promise<SpawnedServer | undefined> {
-		const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id);
+		const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id); // NOSONAR: set intentionally empty — no optional servers configured yet
 		const startedAt = Date.now();
 		logSessionStart(
 			`lsp spawn ${server.id}: start root=${root} install=${allowInstall ? "enabled" : "disabled"} file=${filePath}`,
 		);
+		recordLsp(server.id, root, "spawn_start");
 		try {
 			const spawned = await server.spawn(root, { allowInstall });
 			if (!spawned) {
 				logSessionStart(
 					`lsp spawn ${server.id}: unavailable (${Date.now() - startedAt}ms)`,
 				);
+				recordLsp(server.id, root, "spawn_failed", Date.now() - startedAt);
 				const uCount = (this.failureCounts.get(key) ?? 0) + 1;
 				this.failureCounts.set(key, uCount);
 				const uCooldown = Math.min(
@@ -457,6 +466,7 @@ export class LSPService {
 			logSessionStart(
 				`lsp spawn ${server.id}: success source=${spawned.source ?? "unknown"} (${Date.now() - startedAt}ms)`,
 			);
+			recordLsp(server.id, root, "spawn_success", Date.now() - startedAt);
 			if (!this.workspaceProbeLogged.has(key)) {
 				logSessionStart(
 					`lsp workspace-diag probe ${server.id}: advertised=${wsDiag.advertised} mode=${wsDiag.mode} provider=${wsDiag.diagnosticProviderKind}`,
@@ -465,6 +475,7 @@ export class LSPService {
 			}
 			return { client, info: server };
 		} catch (err) {
+			recordLsp(server.id, root, "spawn_failed", Date.now() - startedAt);
 			if (!isOptionalServer || !this.optionalFailureLogged.has(key)) {
 				logSessionStart(
 					`lsp spawn ${server.id}: failed (${Date.now() - startedAt}ms) error=${err instanceof Error ? err.message : String(err)}`,
@@ -651,6 +662,7 @@ export class LSPService {
 	 */
 	async getDiagnostics(
 		filePath: string,
+		diagnosticsMode: LSPDiagnosticsMode = "full",
 	): Promise<import("./client.js").LSPDiagnostic[]> {
 		if (this.checkDestroyed()) return [];
 		const startedAt = Date.now();
@@ -675,82 +687,85 @@ export class LSPService {
 			return [];
 		}
 
-		// TypeScript LSP often pushes syntactic diagnostics first (sometimes empty)
-		// and semantic diagnostics shortly after. Keep the aggregate wait short for
-		// interactive edits, then do one brief settle pass only when the first
-		// response was empty and arrived quickly.
-		//
-		// Early-unblock: each client writes into pendingResults as it finishes. The
-		// outer race exits as soon as all clients are done OR the first client finishes
-		// and the grace window elapses, whichever is sooner. Remaining slots are left
-		// undefined and filled with zero-diagnostic defaults before merging.
+		// Per-server entries produced by client waits. Each promise resolves
+		// with a PerServerEntry; raceToCompletion collects them as they finish.
 		type PerServerEntry = {
 			serverId: string;
 			waitMs: number;
 			diagnosticCount: number;
 			diagnostics: import("./client.js").LSPDiagnostic[];
 		};
-		const pendingResults: (PerServerEntry | undefined)[] = new Array(
-			spawned.length,
-		).fill(undefined);
 
-		const clientWaits = spawned.map(async (entry, index) => {
-			const waitStart = Date.now();
-			await entry.client.waitForDiagnostics(
-				filePath,
-				DIAGNOSTICS_AGGREGATE_WAIT_MS,
-			);
-			let diagnostics = entry.client.getDiagnostics(filePath);
-			const firstWaitMs = Date.now() - waitStart;
-			if (
-				diagnostics.length === 0 &&
-				firstWaitMs < DIAGNOSTICS_SEMANTIC_SETTLE_THRESHOLD_MS
-			) {
+		const clientWaits: Promise<PerServerEntry>[] = spawned.map(
+			async (entry) => {
+				const waitStart = Date.now();
+				const strategy = getStrategy(entry.info.id);
 				await entry.client.waitForDiagnostics(
 					filePath,
-					DIAGNOSTICS_SEMANTIC_SETTLE_WAIT_MS,
+					strategy.aggregateWaitMs,
 				);
-				diagnostics = entry.client.getDiagnostics(filePath);
-			}
-			pendingResults[index] = {
-				serverId: entry.info.id,
-				waitMs: Date.now() - waitStart,
-				diagnosticCount: diagnostics.length,
-				diagnostics,
-			};
-			return pendingResults[index]!;
-		});
+				let diagnostics = entry.client.getDiagnostics(filePath);
+				const firstWaitMs = Date.now() - waitStart;
+				if (
+					strategy.expectSemanticSecondPush &&
+					diagnostics.length === 0 &&
+					firstWaitMs < DIAGNOSTICS_SEMANTIC_SETTLE_THRESHOLD_MS
+				) {
+					await entry.client.waitForDiagnostics(
+						filePath,
+						DIAGNOSTICS_SEMANTIC_SETTLE_WAIT_MS,
+					);
+					diagnostics = entry.client.getDiagnostics(filePath);
+				}
+				return {
+					serverId: entry.info.id,
+					waitMs: Date.now() - waitStart,
+					diagnosticCount: diagnostics.length,
+					diagnostics,
+				};
+			},
+		);
 
-		if (EARLY_UNBLOCK_GRACE_MS > 0 && spawned.length > 1) {
-			await Promise.race([
-				Promise.all(clientWaits),
-				Promise.race(clientWaits).then(
-					() =>
-						new Promise<void>((resolve) =>
-							setTimeout(resolve, EARLY_UNBLOCK_GRACE_MS),
-						),
+		// Document mode: 0ms grace — return as soon as any client has results.
+		// Full mode: 400ms grace — wait a bit for other clients to catch up.
+		const graceMs = diagnosticsMode === "document" ? 0 : EARLY_UNBLOCK_GRACE_MS;
+
+		// Result-aware racing: trigger early-unblock when any client has results,
+		// OR when a seedFirstPush server returns (its first push is authoritative
+		// even when empty — waiting longer yields nothing more).
+		const perServer = await raceToCompletion(
+			clientWaits,
+			(results) =>
+				results.some(
+					(r) => r.diagnosticCount > 0 || getStrategy(r.serverId).seedFirstPush,
 				),
-			]);
-		} else {
-			await Promise.all(clientWaits);
-		}
+			{
+				timeoutMs: Math.max(
+					...spawned.map((entry) => getStrategy(entry.info.id).aggregateWaitMs),
+				),
+				graceMs,
+			},
+		);
 
-		const earlyUnblockedCount = pendingResults.filter(
-			(r) => r === undefined,
-		).length;
-		const perServer: PerServerEntry[] = pendingResults.map(
-			(r, i) =>
-				r ?? {
-					serverId: spawned[i].info.id,
-					waitMs: DIAGNOSTICS_AGGREGATE_WAIT_MS,
+		// Fill in any slots that timed out before producing results.
+		const earlyUnblockedCount = spawned.length - perServer.length;
+		const perServerFull: PerServerEntry[] = spawned.map((entry) => {
+			const found = perServer.find((r) => r.serverId === entry.info.id);
+			return (
+				found ?? {
+					serverId: entry.info.id,
+					waitMs: getStrategy(entry.info.id).aggregateWaitMs,
 					diagnosticCount: 0,
 					diagnostics: [],
-				},
-		);
+				}
+			);
+		});
+
+		// Deduplicate across servers (same diagnostic reported by multiple tools).
 
 		const merged: import("./client.js").LSPDiagnostic[] = [];
 		const seen = new Set<string>();
-		for (const entry of perServer) {
+		for (const entry of perServerFull) {
 			for (const diagnostic of entry.diagnostics) {
 				const key = [
 					diagnostic.range.start.line,
@@ -763,11 +778,11 @@ export class LSPService {
 			}
 		}
 
-		const rawCount = perServer.reduce(
+		const rawCount = perServerFull.reduce(
 			(sum, entry) => sum + entry.diagnosticCount,
 			0,
 		);
-		const serversWithDiagnostics = perServer.filter(
+		const serversWithDiagnostics = perServerFull.filter(
 			(entry) => entry.diagnosticCount > 0,
 		).length;
 		const failureKind = merged.length === 0 ? "ok_empty" : "success";
@@ -779,14 +794,15 @@ export class LSPService {
 			durationMs: Date.now() - startedAt,
 			metadata: {
 				serverCountAttempted: getServersForFileWithConfig(filePath).length,
-				serverCountReady: perServer.length,
+				serverCountReady: perServerFull.length,
 				serverCountWithDiagnostics: serversWithDiagnostics,
 				mergedCount: merged.length,
 				dedupDroppedCount: rawCount - merged.length,
 				earlyUnblockedCount,
+				diagnosticsMode,
 				failureKind,
 				health: failureKind === "success" ? "ok" : "ok_empty",
-				servers: perServer.map((entry) => ({
+				servers: perServerFull.map((entry) => ({
 					id: entry.serverId,
 					waitMs: entry.waitMs,
 					diagnosticCount: entry.diagnosticCount,