oh-my-opencode 4.18.0 → 4.18.1

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);
 
+	options.signal?.throwIfAborted();
 	const client = await manager.getClient(root, server);
 	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();
+}

package/packages/lsp-core/src/lsp/fixtures/workspace-edit-contract-probe.ts

@@ -0,0 +1,196 @@
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+	renameTextEdit,
+	waitForEventCount,
+} from "../workspace-apply-edit-test-support.js";
+import { workspaceEditContractFailureEvidence } from "../workspace-edit-contract-evidence.js";
+
+class WorkspaceEditContractProbeError extends Error {
+	override readonly name = "WorkspaceEditContractProbeError";
+}
+
+function requireProbe(condition: boolean, message: string): asserts condition {
+	if (!condition) throw new WorkspaceEditContractProbeError(message);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function applyResponses(eventsPath: string): readonly unknown[] {
+	return readEvents(eventsPath)
+		.filter((event) => event.type === "clientResponse" && event.method === "workspace/applyEdit")
+		.map((event) => event.result);
+}
+
+function isRejectedApply(value: unknown): boolean {
+	return isRecord(value) && value["applied"] === false && typeof value["failureReason"] === "string";
+}
+
+function didChangeVersions(eventsPath: string): readonly number[] {
+	const versions: number[] = [];
+	for (const event of readEvents(eventsPath)) {
+		if (event.type !== "clientNotification" || event.method !== "textDocument/didChange") continue;
+		if (!isRecord(event.params)) continue;
+		const textDocument = event.params["textDocument"];
+		if (!isRecord(textDocument) || typeof textDocument["version"] !== "number") continue;
+		versions.push(textDocument["version"]);
+	}
+	return versions;
+}
+
+const outputPath = process.argv[2];
+if (!outputPath) throw new WorkspaceEditContractProbeError("output path is required");
+
+const harness = createWorkspaceEditTestHarness();
+try {
+	const success = await harness.makeClient({
+		renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }],
+		diagnostics: [diagnostic("todo3-fresh")],
+	});
+	let successWrites = 0;
+	success.client.setWorkspaceEditIo({
+		writeFile(path, content) {
+			successWrites += 1;
+			writeFileSync(path, content, "utf-8");
+		},
+	});
+	await success.client.openFile(success.source);
+	const successResult = await success.client.rename(success.source, 1, 6, "after");
+	const successResponses = applyResponses(success.events);
+	const successVersions = didChangeVersions(success.events);
+	const successUri = pathToFileURL(realpathSync(success.source)).href;
+	const successEvidence = {
+		serverAppliedRename:
+			successResponses.length === 1 && isRecord(successResponses[0]) && successResponses[0]["applied"] === true,
+		recordedResultReused: successResult.edit !== null && successResult.apply.success && successWrites === 1,
+		writeCount: successWrites,
+		secondWritePrevented: successWrites === 1 && successVersions.length === 1,
+		synchronizedDocumentVersion: success.client.getOpenDocumentVersion(success.source) ?? null,
+		didChangeVersions: successVersions,
+		immediateDiagnostics: success.client
+			.getStoredDiagnostics(successUri)
+			.some((entry) => entry.message === "todo3-fresh"),
+		finalContent: readFileSync(success.source, "utf-8"),
+	};
+	requireProbe(successEvidence.serverAppliedRename, "successful server apply was not reported truthfully");
+	requireProbe(successEvidence.recordedResultReused, "rename did not reuse the recorded server result");
+	requireProbe(successEvidence.secondWritePrevented, "server edit was written or synchronized more than once");
+	requireProbe(successEvidence.synchronizedDocumentVersion === 2, "open document version did not advance to 2");
+	requireProbe(successEvidence.immediateDiagnostics, "fresh diagnostics were not visible immediately after applyEdit");
+	requireProbe(successEvidence.finalContent === "const after = 1;\n", "successful rename produced unexpected bytes");
+
+	const unscoped = await harness.makeClient({
+		unscopedApplyEdit: renameTextEdit("before", "after", { version: 1 }),
+	});
+	const unscopedResponses = await waitForEventCount(
+		unscoped.events,
+		(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		1,
+	);
+	const unscopedFailure = unscopedResponses[0]?.result;
+	requireProbe(isRejectedApply(unscopedFailure), "unscoped applyEdit was not rejected");
+	requireProbe(readFileSync(unscoped.source, "utf-8") === "const before = 1;\n", "unscoped failure mutated bytes");
+
+	const concurrent = await harness.makeClient({
+		renameSteps: [
+			{
+				applyEdit: renameTextEdit("before", "after", { version: 1 }),
+				applyConcurrently: true,
+				renameResult: "same",
+			},
+		],
+	});
+	let concurrentWrites = 0;
+	concurrent.client.setWorkspaceEditIo({
+		writeFile(path, content) {
+			concurrentWrites += 1;
+			writeFileSync(path, content, "utf-8");
+		},
+	});
+	await concurrent.client.openFile(concurrent.source);
+	const concurrentResult = await concurrent.client.rename(concurrent.source, 1, 6, "after");
+	const concurrentFailure = applyResponses(concurrent.events).find(isRejectedApply);
+	requireProbe(concurrentResult.apply.success, "the winning concurrent applyEdit did not complete");
+	requireProbe(concurrentWrites === 1, "concurrent applyEdit wrote more than once");
+	requireProbe(isRejectedApply(concurrentFailure), "concurrent applyEdit loser was not rejected");
+
+	const mismatched = await harness.makeClient({
+		renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 9 }), renameResult: "same" }],
+	});
+	await mismatched.client.openFile(mismatched.source);
+	const mismatchedResult = await mismatched.client.rename(mismatched.source, 1, 6, "after");
+	const mismatchedFailure = applyResponses(mismatched.events).find(isRejectedApply);
+	requireProbe(!mismatchedResult.apply.success, "mismatched document version unexpectedly succeeded");
+	requireProbe(isRejectedApply(mismatchedFailure), "mismatched version was not rejected over applyEdit");
+	requireProbe(readFileSync(mismatched.source, "utf-8") === "const before = 1;\n", "version failure mutated bytes");
+
+	const preGate = await harness.makeClient({
+		renameSteps: [
+			{
+				applyEdit: renameTextEdit("before", "after", { version: 1 }),
+				applyDelayMs: 100,
+				renameResult: "same",
+			},
+		],
+	});
+	const controller = new AbortController();
+	await preGate.client.openFile(preGate.source);
+	const pendingRename = preGate.client.rename(preGate.source, 1, 6, "after", controller.signal);
+	await waitForEventCount(
+		preGate.events,
+		(event) => event.type === "clientRequest" && event.method === "textDocument/rename",
+		1,
+		);
+		controller.abort();
+		const preGateError = await pendingRename.then(
+			() => null,
+			(error: unknown) => error,
+		);
+		const preGateMessage = preGateError instanceof Error ? preGateError.message : String(preGateError);
+		const preGateFailure = {
+			success: false,
+			filesModified: [],
+			totalEdits: 0,
+			errors: [preGateMessage],
+		};
+		requireProbe(preGateError !== null, "pre-gate cancellation unexpectedly succeeded");
+		requireProbe(
+			preGateFailure.errors.some((message) => /cancel|abort/i.test(message)),
+			"pre-gate cancellation returned the wrong failure",
+		);
+		requireProbe(readFileSync(preGate.source, "utf-8") === "const before = 1;\n", "pre-gate cancellation mutated bytes");
+
+	const failureCases = {
+			unscoped: workspaceEditContractFailureEvidence(unscopedFailure, unscoped.workspace),
+			concurrent: workspaceEditContractFailureEvidence(concurrentFailure, concurrent.workspace),
+			mismatched: workspaceEditContractFailureEvidence(mismatchedFailure, mismatched.workspace),
+			preGate: workspaceEditContractFailureEvidence(preGateFailure, preGate.workspace),
+		};
+	writeFileSync(
+		outputPath,
+		`${JSON.stringify(
+			{
+				schemaVersion: 1,
+				success: successEvidence,
+				failureCases,
+				failureHashes: {
+					unscoped: failureCases.unscoped.sha256,
+					concurrent: failureCases.concurrent.sha256,
+					mismatched: failureCases.mismatched.sha256,
+					preGate: failureCases.preGate.sha256,
+				},
+			},
+			null,
+			2,
+		)}\n`,
+		"utf-8",
+	);
+} finally {
+	await harness.cleanup();
+}