oh-my-opencode 5.0.0-beta.30 → 5.0.0-beta.32

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

@@ -1,6 +1,14 @@
 import { reportBestEffortCleanupError } from "./cleanup-errors.js";
 import { LspClient } from "./client.js";
-import { IDLE_TIMEOUT_MS, INIT_TIMEOUT_MS, MAX_RESIDENT_CLIENTS, REAPER_INTERVAL_MS } from "./constants.js";
+import {
+	CLIENT_RESPAWN_COOLDOWN_MS,
+	CLIENT_RESPAWN_RETRY_LIMIT,
+	IDLE_TIMEOUT_MS,
+	INIT_TIMEOUT_MS,
+	MAX_RESIDENT_CLIENTS,
+	REAPER_INTERVAL_MS,
+} from "./constants.js";
+import { LspClientRespawnBudgetExceededError } from "./errors.js";
 import { installProcessSignalCleanup } from "./process-signal-cleanup.js";
 import type { ResolvedServer } from "./types.js";
 
@@ -14,6 +22,11 @@ interface ManagedClient {
 	initializingSince: number | null;
 }
 
+interface RespawnBudget {
+	deadGenerations: number;
+	exhaustedAt: number | null;
+}
+
 export interface ClientSnapshot {
 	root: string;
 	serverId: string;
@@ -75,6 +88,9 @@ function awaitWithSignal<T>(promise: Promise<T>, signal: AbortSignal | undefined
 
 export class LspManager {
 	private readonly clients = new Map<string, ManagedClient>();
+	/** In-flight stops per key; getClient awaits these instead of spawning a duplicate client. */
+	private readonly pendingStops = new Map<string, Promise<void>>();
+	private readonly respawnBudgets = new Map<string, RespawnBudget>();
 	private reaperHandle: NodeJS.Timeout | null = null;
 	private signalDisposer: (() => void) | null = null;
 	private disposed = false;
@@ -112,6 +128,50 @@ export class LspManager {
 		return `${root}::${serverId}`;
 	}
 
+	/**
+	 * Deletes-then-stops with a tombstone: the pending stop is recorded so a concurrent getClient
+	 * for the same key awaits it instead of spawning a duplicate client while the old one lingers
+	 * (production stops reach ~21s). The tombstone removes itself once the stop settles.
+	 */
+	private tombstoneStop(key: string, client: LspClient): Promise<void> {
+		const stop = stopClientBestEffort(client);
+		this.pendingStops.set(key, stop);
+		void stop.finally(() => {
+			if (this.pendingStops.get(key) === stop) {
+				this.pendingStops.delete(key);
+			}
+		});
+		return stop;
+	}
+
+	private recordDeadGeneration(key: string): void {
+		let budget = this.respawnBudgets.get(key);
+		if (budget === undefined) {
+			budget = { deadGenerations: 0, exhaustedAt: null };
+			this.respawnBudgets.set(key, budget);
+		}
+		budget.deadGenerations += 1;
+	}
+
+	private markHealthyGeneration(key: string): void {
+		this.respawnBudgets.delete(key);
+	}
+
+	/** Throws while the respawn budget is spent and the cooldown has not elapsed. */
+	private ensureRespawnAllowed(key: string, root: string, serverId: string): void {
+		const budget = this.respawnBudgets.get(key);
+		if (budget === undefined || budget.deadGenerations < CLIENT_RESPAWN_RETRY_LIMIT) return;
+		if (budget.exhaustedAt === null) {
+			budget.exhaustedAt = this.now();
+			throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+		}
+		if (this.now() - budget.exhaustedAt < CLIENT_RESPAWN_COOLDOWN_MS) {
+			throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+		}
+		budget.deadGenerations = 0;
+		budget.exhaustedAt = null;
+	}
+
 	private reapStale(): void {
 		const t = this.now();
 		for (const [key, managed] of this.clients) {
@@ -120,8 +180,8 @@ export class LspManager {
 				managed.initializingSince !== null &&
 				t - managed.initializingSince > this.initTimeoutMs
 			) {
-				void stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				void this.tombstoneStop(key, managed.client);
 				continue;
 			}
 
@@ -131,8 +191,8 @@ export class LspManager {
 				managed.pendingWaiters === 0 &&
 				t - managed.lastUsedAt > this.idleTimeoutMs
 			) {
-				void stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				void this.tombstoneStop(key, managed.client);
 			}
 		}
 	}
@@ -148,7 +208,7 @@ export class LspManager {
 			const victim = this.leastRecentlyUsedIdleClient();
 			if (!victim) return;
 			this.clients.delete(victim.key);
-			void stopClientBestEffort(victim.managed.client);
+			void this.tombstoneStop(victim.key, victim.managed.client);
 		}
 	}
 
@@ -171,7 +231,7 @@ export class LspManager {
 			this.clients.get(key) === managed
 		) {
 			this.clients.delete(key);
-			await stopClientBestEffort(managed.client);
+			await this.tombstoneStop(key, managed.client);
 		}
 	}
 
@@ -182,6 +242,16 @@ export class LspManager {
 		signal?.throwIfAborted();
 
 		const key = this.getKey(root, server.id);
+		for (;;) {
+			const pendingStop = this.pendingStops.get(key);
+			if (pendingStop === undefined) break;
+			await awaitWithSignal(pendingStop, signal);
+			signal?.throwIfAborted();
+		}
+		if (this.disposed) {
+			throw new Error("LspManager has been disposed");
+		}
+
 		let managed = this.clients.get(key);
 
 		if (managed) {
@@ -191,8 +261,8 @@ export class LspManager {
 				managed.initializingSince !== null &&
 				t - managed.initializingSince > this.initTimeoutMs
 			) {
-				await stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				await this.tombstoneStop(key, managed.client);
 				managed = undefined;
 			}
 		}
@@ -216,17 +286,22 @@ export class LspManager {
 			}
 
 			if (!managed.client.isAlive()) {
-				await stopClientBestEffort(managed.client);
-				this.clients.delete(key);
+				this.recordDeadGeneration(key);
+				if (this.clients.get(key) === managed) {
+					this.clients.delete(key);
+				}
+				await this.tombstoneStop(key, managed.client);
 				return this.getClient(root, server, signal);
 			}
 
+			this.markHealthyGeneration(key);
 			managed.refCount++;
 			managed.lastUsedAt = this.now();
 			return managed.client;
 		}
 
 		this.evictForAdmission();
+		this.ensureRespawnAllowed(key, root, server.id);
 
 		const client = this.clientFactory(root, server);
 		const initStartedAt = this.now();
@@ -253,7 +328,7 @@ export class LspManager {
 			if (this.clients.get(key) === newManaged) {
 				this.clients.delete(key);
 			}
-			await stopClientBestEffort(client);
+			await this.tombstoneStop(key, client);
 			throw err;
 		}
 
@@ -267,6 +342,16 @@ export class LspManager {
 			signal.throwIfAborted();
 		}
 
+		if (!client.isAlive()) {
+			this.recordDeadGeneration(key);
+			if (this.clients.get(key) === newManaged) {
+				this.clients.delete(key);
+			}
+			await this.tombstoneStop(key, client);
+			return this.getClient(root, server, signal);
+		}
+
+		this.markHealthyGeneration(key);
 		newManaged.refCount++;
 		newManaged.lastUsedAt = this.now();
 		return client;
@@ -287,15 +372,20 @@ export class LspManager {
 		if (!managed) return;
 		if (client && managed.client !== client) return;
 		this.clients.delete(key);
-		void stopClientBestEffort(managed.client);
+		void this.tombstoneStop(key, managed.client);
 	}
 
 	warmupClient(root: string, server: ResolvedServer): void {
 		if (this.disposed) return;
 		const key = this.getKey(root, server.id);
-		if (this.clients.has(key)) return;
+		if (this.clients.has(key) || this.pendingStops.has(key)) return;
 
 		this.evictForAdmission();
+		try {
+			this.ensureRespawnAllowed(key, root, server.id);
+		} catch {
+			return;
+		}
 
 		const client = this.clientFactory(root, server);
 		const initStartedAt = this.now();
@@ -326,7 +416,7 @@ export class LspManager {
 				if (this.clients.get(key) === managed) {
 					this.clients.delete(key);
 				}
-				void stopClientBestEffort(client);
+				void this.tombstoneStop(key, client);
 			},
 		);
 	}
@@ -379,8 +469,11 @@ export class LspManager {
 		for (const managed of this.clients.values()) {
 			stopPromises.push(stopClientBestEffort(managed.client));
 		}
+		const tombstonedStops = [...this.pendingStops.values()];
 		this.clients.clear();
-		await Promise.allSettled(stopPromises);
+		this.respawnBudgets.clear();
+		await Promise.allSettled([...stopPromises, ...tombstonedStops]);
+		this.pendingStops.clear();
 	}
 }
 

package/packages/lsp-core/src/lsp/timer-provider.ts

@@ -0,0 +1,13 @@
+export type TimerHandle = ReturnType<typeof setTimeout>;
+
+export interface TimerProvider {
+	readonly now: () => number;
+	readonly setTimeout: (callback: () => void, delayMs: number) => TimerHandle;
+	readonly clearTimeout: (handle: TimerHandle) => void;
+}
+
+export const realTimerProvider: TimerProvider = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle),
+};

package/packages/lsp-core/src/lsp/transport-request-timeout.test.ts

@@ -0,0 +1,73 @@
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it } from "bun:test";
+
+import { ControlledClock } from "./controlled-clock-test-support.js";
+import { LspRequestTimeoutError } from "./errors.js";
+import { JsonRpcConnection } from "./json-rpc-connection.js";
+import { LspClientTransport } from "./transport.js";
+import type { LspClientTimeoutOptions } from "./transport.js";
+import type { ResolvedServer } from "./types.js";
+
+const fakeServer: ResolvedServer = {
+	id: "controlled-clock-fake",
+	command: ["controlled-clock-fake"],
+	extensions: [".ts"],
+	priority: 0,
+};
+
+class WiredTransport extends LspClientTransport {
+	constructor(timeouts: LspClientTimeoutOptions, connection: JsonRpcConnection) {
+		super("/tmp", fakeServer, timeouts);
+		this.connection = connection;
+	}
+
+	request<T>(method: string, params: unknown, options: { timeoutMs?: number }): Promise<T> {
+		return this.sendRequest<T>(method, params, options);
+	}
+}
+
+function encodeMessage(message: Record<string, unknown>): string {
+	const body = JSON.stringify(message);
+	return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function makeWiredTransport(clock: ControlledClock): { transport: WiredTransport; serverToClient: PassThrough } {
+	const serverToClient = new PassThrough();
+	const clientToServer = new PassThrough();
+	const connection = new JsonRpcConnection(serverToClient, clientToServer);
+	connection.listen();
+	return { transport: new WiredTransport({ timerProvider: clock }, connection), serverToClient };
+}
+
+describe("LspClientTransport request timeout via TimerProvider", () => {
+	it("#given a request the server never answers #when the injected clock passes the timeout #then the request rejects with LspRequestTimeoutError", async () => {
+		const clock = new ControlledClock();
+		const { transport } = makeWiredTransport(clock);
+
+		const pending = transport.request("textDocument/diagnostic", { textDocument: { uri: "file:///a.ts" } }, {
+			timeoutMs: 50,
+		});
+		await clock.waitForTimer(50);
+		expect(clock.scheduledDelays.at(-1)).toBe(50);
+		clock.advanceBy(50);
+
+		await expect(pending).rejects.toBeInstanceOf(LspRequestTimeoutError);
+	});
+
+	it("#given a request answered before the deadline #when the injected clock later passes the timeout #then the settled result stands", async () => {
+		const clock = new ControlledClock();
+		const { transport, serverToClient } = makeWiredTransport(clock);
+
+		const pending = transport.request<{ items: unknown[] }>(
+			"textDocument/diagnostic",
+			{ textDocument: { uri: "file:///a.ts" } },
+			{ timeoutMs: 50 },
+		);
+		await clock.waitForTimer(50);
+		serverToClient.write(encodeMessage({ jsonrpc: "2.0", id: 1, result: { items: [] } }));
+
+		await expect(pending).resolves.toEqual({ items: [] });
+		clock.advanceBy(50);
+	});
+});

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

@@ -1,4 +1,6 @@
 import { reportBestEffortCleanupError } from "./cleanup-errors.js";
+import { realTimerProvider } from "./timer-provider.js";
+import type { TimerProvider } from "./timer-provider.js";
 import { INIT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, STOP_HARD_KILL_TIMEOUT_MS, STOP_SIGKILL_GRACE_MS } from "./constants.js";
 import { LspConnectionClosedError, LspProcessExitedError, LspRequestTimeoutError } from "./errors.js";
 import { JsonRpcConnection } from "./json-rpc-connection.js";
@@ -12,6 +14,7 @@ export { createLspSpawnEnv } from "./transport-protocol.js";
 export interface LspClientTimeoutOptions {
 	requestTimeoutMs?: number;
 	initializeTimeoutMs?: number;
+	timerProvider?: TimerProvider;
 }
 
 type WorkspaceApplyEditHandler = (params: unknown) => Promise<WorkspaceApplyEditResponse>;
@@ -35,6 +38,7 @@ export class LspClientTransport {
 	protected readonly diagnosticsStore = new Map<string, Diagnostic[]>();
 	protected readonly requestTimeoutMs: number;
 	protected readonly initializeTimeoutMs: number;
+	protected readonly timerProvider: TimerProvider;
 	private workspaceApplyEditHandler: WorkspaceApplyEditHandler | null = null;
 	private diagnosticPullSupported = false;
 	private documentFormattingSupported = false;
@@ -46,6 +50,7 @@ export class LspClientTransport {
 	) {
 		this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
 		this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
+		this.timerProvider = timeouts.timerProvider ?? realTimerProvider;
 	}
 
 	pid(): number | undefined {
@@ -187,7 +192,7 @@ export class LspClientTransport {
 		const options = args[1];
 		const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
 		const timeoutController = new AbortController();
-		const timeoutHandle = setTimeout(() => {
+		const timeoutHandle = this.timerProvider.setTimeout(() => {
 			const stderrTail = this.stderrBuffer.slice(-5).join("\n");
 			timeoutController.abort(new LspRequestTimeoutError(method, stderrTail || undefined));
 		}, timeoutMs);
@@ -213,7 +218,7 @@ export class LspClientTransport {
 			}
 			throw error;
 		} finally {
-			clearTimeout(timeoutHandle);
+			this.timerProvider.clearTimeout(timeoutHandle);
 			combinedSignal.dispose();
 		}
 	}

package/packages/lsp-core/src/lsp/workspace-document-state.test.ts

@@ -1,8 +1,91 @@
-import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 
+import { afterEach, describe, expect, it } from "bun:test";
+
+import type { Diagnostic } from "./types.js";
 import { WorkspaceDocumentState } from "./workspace-document-state.js";
 import type { WorkspaceMutation } from "./workspace-edit.js";
 
+const workspaces: string[] = [];
+
+afterEach(() => {
+	while (workspaces.length > 0) {
+		const workspace = workspaces.pop();
+		if (workspace) rmSync(workspace, { recursive: true, force: true });
+	}
+});
+
+function makeDocuments(): WorkspaceDocumentState {
+	return new WorkspaceDocumentState(
+		async () => {},
+		() => {},
+		{ versionlessPublishQuiescenceMs: 0 },
+	);
+}
+
+function makeSourceFile(directorySegment: string): string {
+	const workspace = realpathSync(mkdtempSync(join(tmpdir(), "lsp-document-uri-")));
+	workspaces.push(workspace);
+	const directory = join(workspace, directorySegment);
+	mkdirSync(directory, { recursive: true });
+	const source = join(directory, "page.ts");
+	writeFileSync(source, "const value: number = 'text';\n", "utf-8");
+	return source;
+}
+
+const diagnostic: Diagnostic = {
+	range: { start: { line: 0, character: 6 }, end: { line: 0, character: 11 } },
+	severity: 1,
+	message: "Type 'string' is not assignable to type 'number'.",
+};
+
+describe("WorkspaceDocumentState published diagnostics under a re-encoded uri", () => {
+	it("#given a server that percent-encodes a path segment #when it publishes #then the diagnostics reach the open document", async () => {
+		const documents = makeDocuments();
+		const source = makeSourceFile("(marketing)");
+		await documents.openFile(source);
+		const snapshot = documents.captureDiagnosticSnapshot(source);
+		expect(snapshot).not.toBeNull();
+		const publishedUri = snapshot!.uri.replaceAll("(", "%28").replaceAll(")", "%29");
+		expect(publishedUri).not.toBe(snapshot!.uri);
+
+		documents.recordPublishedDiagnostics({ uri: publishedUri, diagnostics: [diagnostic], version: snapshot!.version });
+
+		expect(documents.getStoredDiagnostics(snapshot!.uri)).toEqual([diagnostic]);
+		expect(documents.resolvePushDiagnostics(snapshot!)).toEqual({ status: "ready", diagnostics: [diagnostic] });
+	});
+
+	it.skipIf(process.platform !== "win32")(
+		"#given a server that lowercases and percent-encodes the drive #when it publishes #then the diagnostics reach the open document",
+		async () => {
+			const documents = makeDocuments();
+			const source = makeSourceFile("routes");
+			await documents.openFile(source);
+			const snapshot = documents.captureDiagnosticSnapshot(source);
+			expect(snapshot).not.toBeNull();
+			const publishedUri = snapshot!.uri.replace(/^file:\/\/\/([A-Za-z]):/, (_match, drive: string) => `file:///${drive.toLowerCase()}%3A`);
+			expect(publishedUri).not.toBe(snapshot!.uri);
+
+			documents.recordPublishedDiagnostics({ uri: publishedUri, diagnostics: [diagnostic], version: snapshot!.version });
+
+			expect(documents.getStoredDiagnostics(snapshot!.uri)).toEqual([diagnostic]);
+			expect(documents.resolvePushDiagnostics(snapshot!)).toEqual({ status: "ready", diagnostics: [diagnostic] });
+		},
+	);
+
+	it("#given a document opened from a path the client already encodes #when the server echoes it verbatim #then the outgoing uri is unchanged", async () => {
+		const documents = makeDocuments();
+		const source = makeSourceFile("plain");
+		await documents.openFile(source);
+		const snapshot = documents.captureDiagnosticSnapshot(source);
+
+		expect(snapshot?.uri).toBe(pathToFileURL(source).href);
+	});
+});
+
 describe("WorkspaceDocumentState watched-file bounds", () => {
 	it("#given more closed-file mutations than one batch #when synchronized #then every notification stays bounded", async () => {
 		const notifications: unknown[] = [];

package/packages/lsp-core/src/lsp/workspace-document-state.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url";
 import { effectiveExtension } from "./effective-extension.js";
 import { getLanguageId } from "./language-mappings.js";
 import type { Diagnostic } from "./types.js";
+import type { TimerProvider } from "./timer-provider.js";
 import type { PlannedWorkspaceOperation, WorkspaceMutation, WorkspaceMutationDelta } from "./workspace-edit-types.js";
 
 const WATCHED_FILE_BATCH_SIZE = 128;
@@ -76,6 +77,7 @@ export type PushDiagnosticsResolution =
 
 export interface WorkspaceDocumentStateOptions {
 	readonly now?: () => number;
+	readonly timerProvider?: TimerProvider;
 	readonly versionlessPublishQuiescenceMs?: number;
 }
 
@@ -88,6 +90,17 @@ function canonicalPath(filePath: string): string {
 	}
 }
 
+function normalizeDocumentUri(uri: string): string {
+	let decoded = uri;
+	try {
+		decoded = decodeURIComponent(uri);
+	} catch {
+		decoded = uri;
+	}
+	if (process.platform !== "win32") return decoded;
+	return decoded.replace(/^(file:\/\/\/)([a-z]):/, (_match, prefix: string, drive: string) => `${prefix}${drive.toUpperCase()}:`);
+}
+
 function isSameOrDescendant(candidate: string, parent: string): boolean {
 	const suffix = relative(parent, candidate);
 	return suffix === "" || (!suffix.startsWith("..") && suffix !== "..");
@@ -103,6 +116,7 @@ export class WorkspaceDocumentState {
 	private readonly openByUri = new Map<string, OpenDocumentState>();
 	private readonly openPromises = new Map<string, Promise<void>>();
 	private readonly now: () => number;
+	private readonly timerProvider: TimerProvider;
 	private readonly versionlessPublishQuiescenceMs: number;
 
 	constructor(
@@ -110,7 +124,12 @@ export class WorkspaceDocumentState {
 		private readonly clearDiagnostics: (uri: string) => void,
 		options: WorkspaceDocumentStateOptions = {},
 	) {
-		this.now = options.now ?? (() => Date.now());
+		this.timerProvider = options.timerProvider ?? {
+			now: options.now ?? (() => Date.now()),
+			setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+			clearTimeout: (handle) => clearTimeout(handle),
+		};
+		this.now = () => this.timerProvider.now();
 		this.versionlessPublishQuiescenceMs =
 			options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
 	}
@@ -135,7 +154,7 @@ export class WorkspaceDocumentState {
 	}
 
 	getStoredDiagnostics(uri: string): readonly Diagnostic[] {
-		const state = this.openByUri.get(uri);
+		const state = this.openByUri.get(normalizeDocumentUri(uri));
 		if (!state) return [];
 		return state.lastPublish?.diagnostics ?? state.pullCache?.diagnostics ?? [];
 	}
@@ -163,13 +182,13 @@ export class WorkspaceDocumentState {
 	}
 
 	getPullCache(snapshot: DiagnosticSnapshot): PullDiagnosticsCacheHit | null {
-		const state = this.openByUri.get(snapshot.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
 		if (!state?.pullCache || state.pullCache.documentVersion !== snapshot.version) return null;
 		return state.pullCache;
 	}
 
 	recordPullDiagnostics(snapshot: DiagnosticSnapshot, report: PullDiagnosticsReport): void {
-		const state = this.openByUri.get(snapshot.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
 		if (!state) return;
 		state.pullCache = {
 			documentVersion: snapshot.version,
@@ -183,7 +202,7 @@ export class WorkspaceDocumentState {
 		readonly diagnostics: readonly Diagnostic[];
 		readonly version?: number;
 	}): void {
-		const state = this.openByUri.get(params.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(params.uri));
 		if (!state) return;
 		state.publishGeneration += 1;
 		state.lastPublish = {
@@ -197,7 +216,7 @@ export class WorkspaceDocumentState {
 	}
 
 	resolvePushDiagnostics(snapshot: DiagnosticSnapshot): PushDiagnosticsResolution {
-		const state = this.openByUri.get(snapshot.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
 		if (!state?.lastPublish) return { status: "missing" };
 		const publish = state.lastPublish;
 		if (publish.version !== undefined) {
@@ -214,18 +233,18 @@ export class WorkspaceDocumentState {
 	}
 
 	waitForDiagnosticsActivity(snapshot: DiagnosticSnapshot, timeoutMs: number): Promise<void> {
-		const state = this.openByUri.get(snapshot.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
 		if (!state || timeoutMs <= 0) return Promise.resolve();
 		return new Promise((resolveActivity) => {
 			let settled = false;
 			const finish = () => {
 				if (settled) return;
 				settled = true;
-				clearTimeout(timer);
+				this.timerProvider.clearTimeout(timer);
 				state.waiters.delete(finish);
 				resolveActivity();
 			};
-			const timer = setTimeout(finish, timeoutMs);
+			const timer = this.timerProvider.setTimeout(finish, timeoutMs);
 			if (typeof timer.unref === "function") timer.unref();
 			state.waiters.add(finish);
 		});
@@ -329,7 +348,7 @@ export class WorkspaceDocumentState {
 				waiters: new Set(),
 			};
 			this.openDocuments.set(path, state);
-			this.openByUri.set(state.uri, state);
+			this.openByUri.set(normalizeDocumentUri(state.uri), state);
 			this.notifyWaiters(state);
 			await this.sendNotification("textDocument/didOpen", {
 				textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text },
@@ -356,7 +375,7 @@ export class WorkspaceDocumentState {
 
 	private async closeDocument(state: OpenDocumentState): Promise<void> {
 		this.openDocuments.delete(state.path);
-		this.openByUri.delete(state.uri);
+		this.openByUri.delete(normalizeDocumentUri(state.uri));
 		this.clearDiagnostics(state.uri);
 		this.notifyWaiters(state);
 		await this.sendNotification("textDocument/didClose", { textDocument: { uri: state.uri } });

package/packages/lsp-core/src/lsp/workspace-markers.ts

@@ -1 +1,18 @@
-export const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"] as const;
+/** Repository marker: an ancestor containing this always wins over intermediate package markers. */
+export const GIT_WORKSPACE_MARKER = ".git" as const;
+
+/**
+ * Package/project markers. On their own they resolve to the NEAREST marked directory, but inside a
+ * request cwd they are only a fallback: a `.git` ancestor further up collapses nested package roots
+ * (one client per repository instead of one per monorepo package).
+ */
+export const PROJECT_WORKSPACE_MARKERS = [
+	"package.json",
+	"pyproject.toml",
+	"Cargo.toml",
+	"go.mod",
+	"pom.xml",
+	"build.gradle",
+] as const;
+
+export const WORKSPACE_MARKERS = [GIT_WORKSPACE_MARKER, ...PROJECT_WORKSPACE_MARKERS] as const;

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

@@ -71,6 +71,9 @@ export async function runMcpStdioServer(
 	await runJsonRpcStdioServer({
 		input,
 		output,
+		// Idle stays disabled: hosts of this CLI (legacy opencode configs and
+		// standalone lsp-tools-mcp users) have no evidenced respawn for an exited
+		// stdio server; opencode in particular marks it failed without retry.
 		idleTimeoutMs: 0,
 		parentWatchdog: options.parentWatchdog ?? {},
 		handler: (request) => runWithRequestContext(requestContext, () => handleLspMcpRequest(request)),