oh-my-opencode 4.18.0 → 4.18.2

package/packages/lsp-core/src/lsp/directory-diagnostics.test.ts

@@ -0,0 +1,221 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { aggregateDiagnosticsForDirectory } from "./directory-diagnostics.js";
+import { LspClient } from "./client.js";
+import { LspManager } from "./manager.js";
+import type { Diagnostic, ResolvedServer } from "./types.js";
+
+describe("directory diagnostics", () => {
+	it("#given multiple files and one per-file failure #when directory diagnostics run #then work stays bounded and file failures stay structured", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-"));
+		const active: string[] = [];
+		let maxActive = 0;
+		const diagnosticsByFile = new Map<string, Diagnostic[] | Error>([
+			[join(workspace, "a.ts"), [diagnostic("a")]],
+			[join(workspace, "b.ts"), new Error("b failed")],
+			[join(workspace, "c.ts"), [diagnostic("c")]],
+			[join(workspace, "d.ts"), [diagnostic("d")]],
+			[join(workspace, "e.ts"), [diagnostic("e")]],
+		]);
+		const client = {
+			async diagnostics(filePath: string) {
+				active.push(filePath);
+				maxActive = Math.max(maxActive, active.length);
+				await Promise.resolve();
+				active.splice(active.indexOf(filePath), 1);
+				const entry = diagnosticsByFile.get(filePath);
+				if (entry instanceof Error) throw entry;
+				return { items: entry ?? [] };
+			},
+		} as Pick<LspClient, "diagnostics"> as LspClient;
+		const server: ResolvedServer = { id: "typescript", command: ["typescript-language-server"], extensions: [".ts"], priority: 1 };
+		const manager = {
+			async getClient() {
+				return client;
+			},
+			releaseClient() {},
+		};
+
+		try {
+			const result = await aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 4, {
+				manager: manager as never,
+				listFiles: () => [...diagnosticsByFile.keys()],
+				workspaceRoot: workspace,
+				server,
+				maxConcurrency: 2,
+			});
+
+			expect(maxActive).toBeLessThanOrEqual(2);
+			expect(result.fileFailures).toEqual([{ file: join(workspace, "b.ts"), error: "b failed" }]);
+			expect(result.totalDiagnostics).toBe(3);
+			expect(result.output).toContain("File processing errors:");
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("#given directory diagnostics are aborted after one file #when the worker loops #then no later file is scheduled", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-cancel-"));
+		const controller = new AbortController();
+		const visited: string[] = [];
+		const firstFile = join(workspace, "a.ts");
+		const files = [firstFile, join(workspace, "b.ts"), join(workspace, "c.ts")];
+		const client = {
+			async diagnostics(filePath: string) {
+				visited.push(filePath);
+				controller.abort();
+				return { items: [] };
+			},
+		} as Pick<LspClient, "diagnostics"> as LspClient;
+		const server: ResolvedServer = { id: "typescript", command: ["typescript-language-server"], extensions: [".ts"], priority: 1 };
+		const manager = {
+			async getClient() {
+				return client;
+			},
+			releaseClient() {},
+		};
+
+		try {
+			const result = await aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 3, {
+				manager: manager as never,
+				listFiles: () => files,
+				workspaceRoot: workspace,
+				server,
+				maxConcurrency: 1,
+				signal: controller.signal,
+			});
+
+			expect(result.totalDiagnostics).toBe(0);
+			expect(visited).toEqual([firstFile]);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("#given cold client acquisition is pending #when directory diagnostics are aborted #then acquisition settles and cleans up before startup releases", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-cold-cancel-"));
+		const controller = new AbortController();
+		const startupStarted = deferred();
+		const startupRelease = deferred();
+		const server: ResolvedServer = {
+			id: "typescript",
+			command: ["typescript-language-server"],
+			extensions: [".ts"],
+			priority: 1,
+		};
+		const client = new PendingStartLspClient({
+			root: workspace,
+			server,
+			startupStarted,
+			startupRelease,
+		});
+		const manager = new LspManager({
+			clientFactory: () => client,
+			reaperIntervalMs: 60_000,
+		});
+		const aggregation = aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 1, {
+			manager,
+			listFiles: () => [join(workspace, "a.ts")],
+			workspaceRoot: workspace,
+			server,
+			signal: controller.signal,
+		});
+
+		try {
+			await startupStarted.promise;
+			controller.abort();
+
+			const settledBeforeStartupRelease = await settlesWithin(aggregation, 100);
+
+			expect(settledBeforeStartupRelease).toBe(true);
+			await expect(aggregation).rejects.toHaveProperty("name", "AbortError");
+			expect(manager.clientCount()).toBe(0);
+			expect(client.stopCallCount).toBe(1);
+		} finally {
+			startupRelease.resolve();
+			await aggregation.catch(() => undefined);
+			await manager.stopAll();
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+});
+
+class PendingStartLspClient extends LspClient {
+	stopCallCount = 0;
+	private readonly startupStarted: Deferred;
+	private readonly startupRelease: Deferred;
+
+	constructor(options: PendingStartLspClientOptions) {
+		super(options.root, options.server);
+		this.startupStarted = options.startupStarted;
+		this.startupRelease = options.startupRelease;
+	}
+
+	override async start(): Promise<void> {
+		this.startupStarted.resolve();
+		await this.startupRelease.promise;
+	}
+
+	override async initialize(): Promise<void> {}
+
+	override async stop(): Promise<void> {
+		this.stopCallCount += 1;
+	}
+
+	override isAlive(): boolean {
+		return true;
+	}
+
+	override async diagnostics(): Promise<{ readonly items: Diagnostic[] }> {
+		return { items: [] };
+	}
+}
+
+interface PendingStartLspClientOptions {
+	readonly root: string;
+	readonly server: ResolvedServer;
+	readonly startupStarted: Deferred;
+	readonly startupRelease: Deferred;
+}
+
+interface Deferred {
+	readonly promise: Promise<void>;
+	resolve(): void;
+}
+
+function deferred(): Deferred {
+	let resolvePromise: (() => void) | undefined;
+	const promise = new Promise<void>((resolve) => {
+		resolvePromise = resolve;
+	});
+	return { promise, resolve: () => resolvePromise?.() };
+}
+
+async function settlesWithin(promise: Promise<unknown>, timeoutMs: number): Promise<boolean> {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	try {
+		return await Promise.race([
+			promise.then(
+				() => true,
+				() => true,
+			),
+			new Promise<boolean>((resolve) => {
+				timer = setTimeout(() => resolve(false), timeoutMs);
+				timer.unref();
+			}),
+		]);
+	} finally {
+		if (timer !== undefined) clearTimeout(timer);
+	}
+}
+
+function diagnostic(message: string): Diagnostic {
+	return {
+		range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+		message,
+	};
+}

package/packages/lsp-core/src/lsp/directory-diagnostics.ts

@@ -6,17 +6,38 @@ import { DEFAULT_MAX_DIAGNOSTICS, DEFAULT_MAX_DIRECTORY_FILES } from "./constant
 import { effectiveExtension } from "./effective-extension.js";
 import { LspInvalidPathError, LspServerLookupError } from "./errors.js";
 import { filterDiagnosticsBySeverity, formatDiagnostic } from "./formatters.js";
-import { getLspManager } from "./manager.js";
+import { getLspManager, type LspManager } from "./manager.js";
 import { findServerForExtension } from "./server-resolution.js";
-import type { Diagnostic, SeverityFilter } from "./types.js";
+import type { Diagnostic, ResolvedServer, SeverityFilter } from "./types.js";
 
 const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
+const DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY = 4;
 
 interface FileDiagnostic {
 	filePath: string;
 	diagnostic: Diagnostic;
 }
 
+export interface DirectoryDiagnosticsFileFailure {
+	readonly file: string;
+	readonly error: string;
+}
+
+export interface DirectoryDiagnosticsResult {
+	readonly output: string;
+	readonly totalDiagnostics: number;
+	readonly fileFailures: readonly DirectoryDiagnosticsFileFailure[];
+}
+
+export interface DirectoryDiagnosticsOptions {
+	readonly listFiles?: (directory: string, extension: string, maxFiles: number) => string[];
+	readonly manager?: LspManager;
+	readonly maxConcurrency?: number;
+	readonly workspaceRoot?: string;
+	readonly server?: ResolvedServer;
+	readonly signal?: AbortSignal;
+}
+
 export function collectFilesWithExtension(dir: string, extension: string, maxFiles: number): string[] {
 	const files: string[] = [];
 
@@ -63,61 +84,73 @@ export async function aggregateDiagnosticsForDirectory(
 	extension: string,
 	severity?: SeverityFilter,
 	maxFiles: number = DEFAULT_MAX_DIRECTORY_FILES,
-): Promise<string> {
+	options: DirectoryDiagnosticsOptions = {},
+): Promise<DirectoryDiagnosticsResult> {
 	if (!extension.startsWith(".")) {
 		throw new LspInvalidPathError(
 			`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`,
 		);
 	}
 
-	const absDir = resolve(contextCwd(), directory);
+	const absDir = resolve(options.workspaceRoot ?? contextCwd(), directory);
 	if (!existsSync(absDir)) {
 		throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
 	}
 
-	const serverResult = findServerForExtension(extension);
+	const serverResult = options.server === undefined ? findServerForExtension(extension) : { status: "found" as const, server: options.server };
 	if (serverResult.status !== "found") {
 		throw new LspServerLookupError(formatServerLookupError(serverResult));
 	}
 
 	const server = serverResult.server;
-	const allFiles = collectFilesWithExtension(absDir, extension, maxFiles + 1);
+	const allFiles = (options.listFiles ?? collectFilesWithExtension)(absDir, extension, maxFiles + 1);
 	const wasCapped = allFiles.length > maxFiles;
 	const filesToProcess = allFiles.slice(0, maxFiles);
 
 	if (filesToProcess.length === 0) {
-		return [
+		const output = [
 			`Directory: ${absDir}`,
 			`Extension: ${extension}`,
 			"Files scanned: 0",
 			`No files found with extension "${extension}".`,
 		].join("\n");
+		return { output, totalDiagnostics: 0, fileFailures: [] };
 	}
 
-	const root = findWorkspaceRoot(absDir);
-	const manager = getLspManager();
+	const root = options.workspaceRoot ?? findWorkspaceRoot(absDir);
+	const manager = options.manager ?? getLspManager();
 	const allDiagnostics: FileDiagnostic[] = [];
-	const fileErrors: { file: string; error: string }[] = [];
+	const fileErrors: DirectoryDiagnosticsFileFailure[] = [];
+	const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
 
-	const client = await manager.getClient(root, server);
+	options.signal?.throwIfAborted();
+	const client = await manager.getClient(root, server, options.signal);
 	try {
-		for (const file of filesToProcess) {
-			try {
-				const result = await client.diagnostics(file);
-				const filtered = filterDiagnosticsBySeverity(result.items, severity);
-				allDiagnostics.push(
-					...filtered.map((diagnostic) => ({
-						filePath: file,
-						diagnostic,
-					})),
-				);
-			} catch (e) {
-				fileErrors.push({
-					file,
-					error: e instanceof Error ? e.message : String(e),
-				});
+		let nextIndex = 0;
+		const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
+			for (;;) {
+				if (options.signal?.aborted) return;
+				const file = filesToProcess[nextIndex];
+				nextIndex += 1;
+				if (file === undefined) return;
+				try {
+					const result = await client.diagnostics(file, options.signal);
+					const filtered = filterDiagnosticsBySeverity(result.items, severity);
+					allDiagnostics.push(
+						...filtered.map((diagnostic) => ({
+							filePath: file,
+							diagnostic,
+						})),
+					);
+				} catch (e) {
+					fileErrors.push({
+						file,
+						error: e instanceof Error ? e.message : String(e),
+					});
+				}
 			}
-		}
+		});
+		await Promise.all(workers);
 	} finally {
 		manager.releaseClient(root, server.id);
 	}
@@ -150,5 +183,5 @@ export async function aggregateDiagnosticsForDirectory(
 		}
 	}
 
-	return lines.join("\n");
+	return { output: lines.join("\n"), totalDiagnostics: allDiagnostics.length, fileFailures: fileErrors };
 }

package/packages/lsp-core/src/lsp/errors.ts

@@ -1,3 +1,7 @@
+import type { ServerLookupResult } from "./types.js";
+
+export type FailedServerLookupResult = Exclude<ServerLookupResult, { status: "found" }>;
+
 export class LspConnectionClosedError extends Error {
 	override readonly name = "LspConnectionClosedError";
 
@@ -42,6 +46,13 @@ export class LspInvalidPathError extends Error {
 
 export class LspServerLookupError extends Error {
 	override readonly name = "LspServerLookupError";
+
+	constructor(
+		message: string,
+		readonly lookup?: FailedServerLookupResult,
+	) {
+		super(message);
+	}
 }
 
 export class LspServerInitializingError extends Error {

package/packages/lsp-core/src/lsp/fixtures/diagnostics-freshness-contract-probe.ts

@@ -0,0 +1,283 @@
+import { writeFileSync } from "node:fs";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+	waitForEventCount,
+} from "../workspace-apply-edit-test-support.js";
+
+class DiagnosticsFreshnessContractProbeError extends Error {
+	override readonly name = "DiagnosticsFreshnessContractProbeError";
+}
+
+function requireProbe(condition: boolean, message: string): asserts condition {
+	if (!condition) throw new DiagnosticsFreshnessContractProbeError(message);
+}
+
+const outputPath = process.argv[2];
+if (!outputPath) throw new DiagnosticsFreshnessContractProbeError("output path is required");
+
+const harness = createWorkspaceEditTestHarness();
+
+try {
+	const exactCurrent = await harness.makeClient(
+		{
+			publishDiagnostics: [
+				{
+					trigger: "didOpen",
+					version: 1,
+					diagnostics: [diagnostic("exact-current")],
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+	);
+	const [exactFirst, exactSecond] = await Promise.all([
+		exactCurrent.client.diagnostics(exactCurrent.source),
+		exactCurrent.client.diagnostics(exactCurrent.source),
+	]);
+	const exactDidOpenCount = readEvents(exactCurrent.events).filter(
+		(event) => event.type === "clientNotification" && event.method === "textDocument/didOpen",
+	).length;
+	const exactCurrentEvidence = {
+		outcome: "exact-current",
+		items: exactFirst.items.map((entry) => entry.message),
+		concurrentItems: exactSecond.items.map((entry) => entry.message),
+		didOpenCount: exactDidOpenCount,
+		ok:
+			exactDidOpenCount === 1
+			&& JSON.stringify(exactFirst.items) === JSON.stringify([diagnostic("exact-current")])
+			&& JSON.stringify(exactSecond.items) === JSON.stringify([diagnostic("exact-current")]),
+	};
+	requireProbe(exactCurrentEvidence.ok, "exact-current diagnostics did not resolve immediately with a single didOpen");
+
+	const postGenerationVersionless = await harness.makeClient(
+		{
+			publishDiagnostics: [
+				{
+					trigger: "didChange",
+					diagnostics: [diagnostic("post-generation-versionless")],
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 20 },
+	);
+	await postGenerationVersionless.client.openFile(postGenerationVersionless.source);
+	await waitForEventCount(
+		postGenerationVersionless.events,
+		(event) => event.type === "serverNotification" && event.method === "textDocument/publishDiagnostics",
+		1,
+	);
+	writeFileSync(postGenerationVersionless.source, "const post_generation = 1;\n", "utf-8");
+	await postGenerationVersionless.client.openFile(postGenerationVersionless.source);
+	const versionlessStartedAt = Date.now();
+	const versionlessResult = await postGenerationVersionless.client.diagnostics(postGenerationVersionless.source);
+	const versionlessElapsedMs = Date.now() - versionlessStartedAt;
+	const postGenerationVersionlessEvidence = {
+		outcome: "post-generation-versionless",
+		items: versionlessResult.items.map((entry) => entry.message),
+		elapsedMs: versionlessElapsedMs,
+		ok:
+			JSON.stringify(versionlessResult.items) === JSON.stringify([diagnostic("post-generation-versionless")])
+			&& versionlessElapsedMs >= 15,
+	};
+	requireProbe(
+		postGenerationVersionlessEvidence.ok,
+		"post-generation versionless diagnostics did not wait for quiescence before resolving",
+	);
+
+	const stale = await harness.makeClient(
+		{
+			publishDiagnostics: [
+				{
+					trigger: "didChange",
+					version: 1,
+					diagnostics: [diagnostic("stale")],
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+	);
+	await stale.client.openFile(stale.source);
+	writeFileSync(stale.source, "const stale = 1;\n", "utf-8");
+	await stale.client.openFile(stale.source);
+	const staleResult = await stale.client.diagnostics(stale.source);
+	const staleEvidence = {
+		outcome: "stale",
+		items: staleResult.items.map((entry) => entry.message),
+		transientError: staleResult.transientError ?? null,
+		ok: staleResult.items.length === 0 && staleResult.transientError?.kind === "freshness_timeout",
+	};
+	requireProbe(staleEvidence.ok, "stale diagnostics unexpectedly satisfied the current request");
+
+	const future = await harness.makeClient(
+		{
+			publishDiagnostics: [
+				{
+					trigger: "didChange",
+					version: 3,
+					diagnostics: [diagnostic("future")],
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 30, versionlessPublishQuiescenceMs: 5 },
+	);
+	await future.client.openFile(future.source);
+	writeFileSync(future.source, "const future = 1;\n", "utf-8");
+	await future.client.openFile(future.source);
+	const futureResult = await future.client.diagnostics(future.source);
+	const futureEvidence = {
+		outcome: "future",
+		items: futureResult.items.map((entry) => entry.message),
+		transientError: futureResult.transientError ?? null,
+		ok: futureResult.items.length === 0 && futureResult.transientError?.kind === "freshness_timeout",
+	};
+	requireProbe(futureEvidence.ok, "future diagnostics unexpectedly satisfied the current request");
+
+	const pullOvertaken = await harness.makeClient(
+		{
+			capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+			diagnosticResponses: [
+				{
+					delayMs: 20,
+					report: { kind: "full", resultId: "v1", items: [diagnostic("pull-stale")] },
+				},
+				{
+					report: { kind: "full", resultId: "v2", items: [diagnostic("pull-fresh")] },
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 5 },
+	);
+	await pullOvertaken.client.openFile(pullOvertaken.source);
+	const pendingPull = pullOvertaken.client.diagnostics(pullOvertaken.source);
+	await waitForEventCount(
+		pullOvertaken.events,
+		(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
+		1,
+	);
+	writeFileSync(pullOvertaken.source, "const pull_fresh = 1;\n", "utf-8");
+	await pullOvertaken.client.openFile(pullOvertaken.source);
+	const pullOvertakenResult = await pendingPull;
+	const pullRequestCount = readEvents(pullOvertaken.events).filter(
+		(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
+	).length;
+	const pullOvertakenEvidence = {
+		outcome: "pull-overtaken",
+		items: pullOvertakenResult.items.map((entry) => entry.message),
+		requestCount: pullRequestCount,
+		ok:
+			JSON.stringify(pullOvertakenResult.items) === JSON.stringify([diagnostic("pull-fresh")])
+			&& pullRequestCount === 2,
+	};
+	requireProbe(
+		pullOvertakenEvidence.ok,
+		"pull diagnostics were not invalidated and retried after a local change overtook the in-flight request",
+	);
+
+	const silent = await harness.makeClient({}, { diagnosticsFreshnessTimeoutMs: 35, versionlessPublishQuiescenceMs: 5 });
+	const silentResult = await silent.client.diagnostics(silent.source);
+	const silentEvidence = {
+		outcome: "silent",
+		items: silentResult.items.map((entry) => entry.message),
+		transientError: silentResult.transientError ?? null,
+		ok: silentResult.items.length === 0 && silentResult.transientError?.kind === "freshness_timeout",
+	};
+	requireProbe(silentEvidence.ok, "silent diagnostics were labeled clean instead of timing out transiently");
+
+	const closedServer = await harness.makeClient(
+		{
+			capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+			diagnosticResponses: [{ action: "close" }],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+	);
+	await closedServer.client.openFile(closedServer.source);
+	let closedServerError = "";
+	try {
+		await closedServer.client.diagnostics(closedServer.source);
+	} catch (error) {
+		closedServerError = error instanceof Error ? error.message : String(error);
+	}
+	const closedServerEvidence = {
+		outcome: "closed-server",
+		error: closedServerError,
+		ok: /exited|closed/i.test(closedServerError),
+	};
+	requireProbe(closedServerEvidence.ok, "closed-server diagnostics failure was not surfaced as a transport error");
+
+	const unsupportedPull = await harness.makeClient(
+		{
+			capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+			publishDiagnostics: [
+				{
+					trigger: "didOpen",
+					version: 1,
+					diagnostics: [diagnostic("push-fallback")],
+				},
+			],
+			diagnosticResponses: [{ error: { code: -32601, message: "Method not found" } }],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+	);
+	const unsupportedPullResult = await unsupportedPull.client.diagnostics(unsupportedPull.source);
+	const unsupportedPullEvidence = {
+		outcome: "unsupported-pull",
+		items: unsupportedPullResult.items.map((entry) => entry.message),
+		ok: JSON.stringify(unsupportedPullResult.items) === JSON.stringify([diagnostic("push-fallback")]),
+	};
+	requireProbe(unsupportedPullEvidence.ok, "explicitly unsupported pull did not fall back to push diagnostics");
+
+	const unchanged = await harness.makeClient(
+		{
+			capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
+			diagnosticResponses: [
+				{
+					report: { kind: "full", resultId: "same-version", items: [diagnostic("cached-full")] },
+				},
+				{
+					report: { kind: "unchanged", resultId: "same-version" },
+				},
+			],
+		},
+		{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+	);
+	await unchanged.client.openFile(unchanged.source);
+	const unchangedFirst = await unchanged.client.diagnostics(unchanged.source);
+	const unchangedSecond = await unchanged.client.diagnostics(unchanged.source);
+	const unchangedEvidence = {
+		outcome: "same-version-unchanged",
+		firstItems: unchangedFirst.items.map((entry) => entry.message),
+		secondItems: unchangedSecond.items.map((entry) => entry.message),
+		ok:
+			JSON.stringify(unchangedFirst.items) === JSON.stringify([diagnostic("cached-full")])
+			&& JSON.stringify(unchangedSecond.items) === JSON.stringify([diagnostic("cached-full")]),
+	};
+	requireProbe(unchangedEvidence.ok, "unchanged pull did not reuse the cached same-version result");
+
+	writeFileSync(
+		outputPath,
+		`${JSON.stringify(
+			{
+				schemaVersion: 1,
+				outcomes: {
+					exactCurrent: exactCurrentEvidence,
+					postGenerationVersionless: postGenerationVersionlessEvidence,
+					stale: staleEvidence,
+					future: futureEvidence,
+					pullOvertaken: pullOvertakenEvidence,
+					silent: silentEvidence,
+					closedServer: closedServerEvidence,
+					unsupportedPull: unsupportedPullEvidence,
+					sameVersionUnchanged: unchangedEvidence,
+				},
+			},
+			null,
+			2,
+		)}\n`,
+		"utf-8",
+	);
+} finally {
+	await harness.cleanup();
+}