oh-my-opencode 5.0.0-beta.7 → 5.0.0-beta.70

package/packages/lsp-core/src/lsp/client-diagnostics-freshness.integration.test.ts

@@ -2,11 +2,14 @@ import { writeFileSync } from "node:fs";
 
 import { afterEach, describe, expect, it } from "bun:test";
 
+import { ControlledClock } from "./controlled-clock-test-support.js";
+
 import {
 	createWorkspaceEditTestHarness,
 	diagnostic,
 	readEvents,
 	waitForEventCount,
+	waitForEventCountBySubscription,
 } from "./workspace-apply-edit-test-support.js";
 
 const harness = createWorkspaceEditTestHarness();
@@ -15,36 +18,30 @@ afterEach(async () => {
 	await harness.cleanup();
 });
 
-describe("LspClient diagnostics freshness", () => {
-	it("#given concurrent diagnostics on a cold file and an exact didOpen publish #when pull is not advertised #then one didOpen opens the file and both requests receive the current diagnostics", async () => {
-		const context = await harness.makeClient(
-			{
-				publishDiagnostics: [
-					{
-						trigger: "didOpen",
-						version: 1,
-						diagnostics: [diagnostic("exact-current")],
-					},
-				],
-			},
-			{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
-		);
-
-		const [first, second] = await Promise.all([
-			context.client.diagnostics(context.source),
-			context.client.diagnostics(context.source),
-		]);
-
-		expect(first.items).toEqual([diagnostic("exact-current")]);
-		expect(second.items).toEqual([diagnostic("exact-current")]);
-		expect(
-			readEvents(context.events).filter(
-				(event) => event.type === "clientNotification" && event.method === "textDocument/didOpen",
-			),
-		).toHaveLength(1);
-	});
+/**
+ * Drives one `diagnostics()` call whose ONLY exit is the freshness window closing: an advertised
+ * pull that comes back "method not found" with no publish behind it.
+ *
+ * That call arms exactly two timers in order - the pull request's own timeout, then the push
+ * fallback wait - and the second can only be armed once the first was cleared by the server's
+ * reply. Waiting on the second SCHEDULE (not on a delay value, which both share) is therefore the
+ * exact signal that the fallback, and not a request timeout, is what the advance closes. On a real
+ * clock the same case resolved from whichever of the two real deadlines a starved Windows shard
+ * happened to reach first (#8323).
+ */
+async function resolveThroughFreshnessWindow<T>(clock: ControlledClock, start: () => Promise<T>): Promise<T> {
+	const scheduledBefore = clock.scheduledDelays.length;
+	const pending = start();
+	await clock.waitForScheduled(scheduledBefore + 2);
+	clock.advanceBy(FRESHNESS_WINDOW_MS);
+	return pending;
+}
+
+const FRESHNESS_WINDOW_MS = 500;
 
+describe("LspClient diagnostics freshness", () => {
 	it("#given a versionless publish that arrives after the current change #when no newer eligible publish arrives before quiescence #then diagnostics wait for that quiescence window and return the versionless payload", async () => {
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				publishDiagnostics: [
@@ -55,7 +52,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 20 },
+			{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 20, timerProvider: clock },
 		);
 		await context.client.openFile(context.source);
 		const versionlessDelivery = waitForEventCount(
@@ -63,42 +60,59 @@ describe("LspClient diagnostics freshness", () => {
 			(event) => event.type === "clientResponse" && event.method === "workspace/configuration",
 			1,
 		);
-		const startedAt = Date.now();
 		writeFileSync(context.source, "const after = 1;\n", "utf-8");
 		await context.client.openFile(context.source);
 		expect(await versionlessDelivery).toHaveLength(1);
 
-		const result = await context.client.diagnostics(context.source);
-		const elapsedMs = Date.now() - startedAt;
+		const pending = context.client.diagnostics(context.source);
+		await clock.waitForTimer(20);
+		expect(clock.scheduledDelays.at(-1)).toBe(20);
+		clock.advanceBy(20);
+		const result = await pending;
 
 		expect(result.items).toEqual([diagnostic("post-generation-versionless")]);
-		expect(elapsedMs).toBeGreaterThanOrEqual(15);
 	});
 
 	it("#given only a pre-generation versionless publish #when a newer local version asks for diagnostics #then the stale versionless publish is ignored and the request does not resolve clean", async () => {
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				publishDiagnostics: [
 					{
 						trigger: "didOpen",
 						diagnostics: [diagnostic("pre-generation-versionless")],
+						awaitClientDelivery: true,
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 300, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 300, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 		await context.client.openFile(context.source);
-		expect((await context.client.diagnostics(context.source)).items).toEqual([diagnostic("pre-generation-versionless")]);
+		await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientResponse" && event.method === "workspace/configuration",
+			1,
+		);
+		const initial = context.client.diagnostics(context.source);
+		await clock.waitForTimer(5);
+		expect(clock.scheduledDelays.at(-1)).toBe(5);
+		clock.advanceBy(5);
+		expect((await initial).items).toEqual([diagnostic("pre-generation-versionless")]);
 		writeFileSync(context.source, "const after = 1;\n", "utf-8");
 		await context.client.openFile(context.source);
 
-		const result = await context.client.diagnostics(context.source);
+		const pending = context.client.diagnostics(context.source);
+		await clock.waitForTimer(300);
+		expect(clock.scheduledDelays.at(-1)).toBe(300);
+		clock.advanceBy(300);
+		const result = await pending;
 
 		expect(result.items).toEqual([]);
 		expect(result.transientError?.kind).toBe("freshness_timeout");
 	});
 
 	it("#given stale and future publish versions #when diagnostics target the current version #then neither stale nor future diagnostics satisfy the request", async () => {
+		const staleClock = new ControlledClock();
 		const stale = await harness.makeClient(
 			{
 				publishDiagnostics: [
@@ -110,7 +124,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5, timerProvider: staleClock },
 		);
 		await stale.client.openFile(stale.source);
 		const staleDelivery = waitForEventCount(
@@ -122,13 +136,17 @@ describe("LspClient diagnostics freshness", () => {
 		await stale.client.openFile(stale.source);
 		expect(await staleDelivery).toHaveLength(1);
 
-		const staleResult = await stale.client.diagnostics(stale.source);
+		const stalePending = stale.client.diagnostics(stale.source);
+		await staleClock.waitForTimer(100);
+		staleClock.advanceBy(100);
+		const staleResult = await stalePending;
 
 		expect(staleResult.items).toEqual([]);
 		expect(staleResult.transientError?.kind).toBe("freshness_timeout");
 
 		await harness.cleanup();
 
+		const futureClock = new ControlledClock();
 		const future = await harness.makeClient(
 			{
 				publishDiagnostics: [
@@ -140,7 +158,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5, timerProvider: futureClock },
 		);
 		await future.client.openFile(future.source);
 		const futureDelivery = waitForEventCount(
@@ -152,19 +170,25 @@ describe("LspClient diagnostics freshness", () => {
 		await future.client.openFile(future.source);
 		expect(await futureDelivery).toHaveLength(1);
 
-		const futureResult = await future.client.diagnostics(future.source);
+		const futurePending = future.client.diagnostics(future.source);
+		await futureClock.waitForTimer(100);
+		futureClock.advanceBy(100);
+		const futureResult = await futurePending;
 
 		expect(futureResult.items).toEqual([]);
 		expect(futureResult.transientError?.kind).toBe("freshness_timeout");
 	});
 
 	it("#given a pull response overtaken by a later local change #when the stale full report returns first #then diagnostics restart within the same request and resolve from the current version", async () => {
+		// Both pull reports answer this request, so no freshness deadline may fire: a controlled clock
+		// removes the 800ms wall-clock race that a starved shard otherwise wins (#8323).
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
 				diagnosticResponses: [
 					{
-						delayMs: 200,
+						releaseOnDidChange: true,
 						report: { kind: "full", resultId: "v1", items: [diagnostic("pull-stale")] },
 					},
 					{
@@ -172,12 +196,12 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 800, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 800, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 		await context.client.openFile(context.source);
 
 		const pending = context.client.diagnostics(context.source);
-		await waitForEventCount(
+		await waitForEventCountBySubscription(
 			context.events,
 			(event) => event.type === "clientRequest" && event.method === "textDocument/diagnostic",
 			1,
@@ -196,6 +220,9 @@ describe("LspClient diagnostics freshness", () => {
 	});
 
 	it("#given a full pull report followed by an unchanged report for the same version and resultId #when diagnostics repeat without a local change #then the cached full items are reused", async () => {
+		// Both requests are answered by the server, so a controlled clock keeps the freshness window
+		// from becoming a second deadline the shard can starve (#8323).
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
@@ -208,7 +235,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 		await context.client.openFile(context.source);
 
@@ -220,6 +247,9 @@ describe("LspClient diagnostics freshness", () => {
 	});
 
 	it("#given a server that claims pull support but closes instead of answering #when diagnostics run #then the transport failure is not labeled clean", async () => {
+		// Deliberately left on the real clock: the client only notices the dead server when the
+		// in-flight pull request's own timeout aborts it, so a timer must actually fire here. Making
+		// the transport reject pending requests from the child's exit event is a separate change.
 		const context = await harness.makeClient(
 			{
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
@@ -233,6 +263,9 @@ describe("LspClient diagnostics freshness", () => {
 	});
 
 	it("#given an advertised pull method that is explicitly unsupported and a matching push publish #when diagnostics run #then the client falls back to push diagnostics", async () => {
+		// The exact-version publish wakes the push-fallback wait, so no deadline may fire; a controlled
+		// clock keeps the 500ms window from winning that race on a starved shard (#8323).
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
@@ -241,14 +274,22 @@ describe("LspClient diagnostics freshness", () => {
 						trigger: "didOpen",
 						version: 1,
 						diagnostics: [diagnostic("push-fallback")],
+						awaitClientDelivery: true,
 					},
 				],
 				diagnosticResponses: [{ error: { code: -32601, message: "Method not found" } }],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 
-		const result = await context.client.diagnostics(context.source);
+		const pending = context.client.diagnostics(context.source);
+		const [delivery] = await waitForEventCountBySubscription(
+			context.events,
+			(event) => event.type === "clientResponse" && event.method === "workspace/configuration",
+			1,
+		);
+		expect(delivery).toBeDefined();
+		const result = await pending;
 
 		expect(result.items).toEqual([diagnostic("push-fallback")]);
 	});
@@ -276,22 +317,24 @@ describe("LspClient diagnostics freshness", () => {
 	});
 
 	it("#given a server without pull support that never publishes diagnostics #when diagnostics run on a clean file #then the request resolves clean after the freshness window instead of reporting a timeout", async () => {
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{},
-			{ diagnosticsFreshnessTimeoutMs: 60, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 60, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 
-		const startedAt = Date.now();
-		const result = await context.client.diagnostics(context.source);
-		const elapsedMs = Date.now() - startedAt;
+		const pending = context.client.diagnostics(context.source);
+		await clock.waitForTimer(60);
+		expect(clock.scheduledDelays.at(-1)).toBe(60);
+		clock.advanceBy(60);
+		const result = await pending;
 
 		expect(result.transientError).toBeUndefined();
 		expect(result.items).toEqual([]);
-		// The full freshness window is still honored so a slow publisher can win.
-		expect(elapsedMs).toBeGreaterThanOrEqual(45);
 	});
 
 	it("#given a pull-supported server that cached diagnostics for an older document version #when the file changes and a later pull is rejected as unsupported without any publish #then the fallback resolves empty instead of returning the stale cached diagnostics", async () => {
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
@@ -300,7 +343,7 @@ describe("LspClient diagnostics freshness", () => {
 					{ error: { code: -32601, message: "Method not found" } },
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 
 		const first = await context.client.diagnostics(context.source);
@@ -309,12 +352,13 @@ describe("LspClient diagnostics freshness", () => {
 		writeFileSync(context.source, "const changed = 1;\n");
 		await context.client.openFile(context.source);
 
-		const second = await context.client.diagnostics(context.source);
+		const second = await resolveThroughFreshnessWindow(clock, () => context.client.diagnostics(context.source));
 		expect(second.transientError).toBeUndefined();
 		expect(second.items).toEqual([]);
 	});
 
 	it("#given a pull-supported server with a current cached pull report #when a later pull is rejected as unsupported without any publish and the document is unchanged #then the fallback resolves with the current cached diagnostics", async () => {
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
@@ -323,13 +367,13 @@ describe("LspClient diagnostics freshness", () => {
 					{ error: { code: -32601, message: "Method not found" } },
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 
 		const first = await context.client.diagnostics(context.source);
 		expect(first.items).toEqual([diagnostic("cached-full")]);
 
-		const second = await context.client.diagnostics(context.source);
+		const second = await resolveThroughFreshnessWindow(clock, () => context.client.diagnostics(context.source));
 		expect(second.transientError).toBeUndefined();
 		expect(second.items).toEqual([diagnostic("cached-full")]);
 	});

package/packages/lsp-core/src/lsp/client-diagnostics-pull-timeout.test.ts

@@ -0,0 +1,64 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { ControlledClock } from "./controlled-clock-test-support.js";
+import { LspClient } from "./client.js";
+import { LspRequestTimeoutError } from "./errors.js";
+import type { ResolvedServer } from "./types.js";
+
+const fakeServer: ResolvedServer = {
+	id: "pull-timeout-fake",
+	command: ["pull-timeout-fake"],
+	extensions: [".ts"],
+	priority: 0,
+};
+
+class HangingPullClient extends LspClient {
+	readonly grantedPullTimeouts: number[] = [];
+
+	constructor(root: string, private readonly clock: ControlledClock) {
+		super(root, fakeServer, { diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5, timerProvider: clock });
+		this.setDiagnosticPullSupported(true);
+	}
+
+	protected override async sendNotification(): Promise<void> {}
+
+	protected override async sendRequest<T>(
+		method: string,
+		...args: [] | [unknown] | [unknown, { timeoutMs?: number; signal?: AbortSignal }]
+	): Promise<T> {
+		if (method !== "textDocument/diagnostic") {
+			throw new Error(`unexpected request in hanging-pull fixture: ${method}`);
+		}
+		const timeoutMs = args[1]?.timeoutMs ?? 0;
+		this.grantedPullTimeouts.push(timeoutMs);
+		this.clock.advanceBy(timeoutMs);
+		throw new LspRequestTimeoutError(method);
+	}
+}
+
+describe("LspClient diagnostics pull timeout conversion", () => {
+	let root: string | null = null;
+
+	afterEach(() => {
+		if (root !== null) rmSync(root, { recursive: true, force: true });
+		root = null;
+	});
+
+	it("#given a pull that exhausts the freshness window #when diagnostics settle #then the timeout converts to freshness_timeout instead of rejecting", async () => {
+		root = mkdtempSync(join(tmpdir(), "lsp-pull-timeout-"));
+		const source = join(root, "sample.ts");
+		writeFileSync(source, "const value = 1;\n", "utf-8");
+		const clock = new ControlledClock();
+		const client = new HangingPullClient(root, clock);
+
+		const result = await client.diagnostics(source);
+
+		expect(client.grantedPullTimeouts).toEqual([50]);
+		expect(result.items).toEqual([]);
+		expect(result.transientError?.kind).toBe("freshness_timeout");
+	});
+});

package/packages/lsp-core/src/lsp/client-wrapper-outside-cwd.test.ts

@@ -0,0 +1,78 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "../request-context.js";
+import { findWorkspaceRoot, resolveReadablePathInsideContext, resolvePathInsideContext } from "./client-wrapper.js";
+import { LspInvalidPathError } from "./errors.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function tempRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+describe("LSP read-only access outside request cwd", () => {
+	it("#given an absolute file outside cwd #when resolving a read path #then returns the canonical path", () => {
+		const root = tempRoot("lsp-outcwd-root-");
+		const outside = tempRoot("lsp-outcwd-outside-");
+		const outsideFile = join(outside, "probe.ts");
+		writeFileSync(outsideFile, "export const value = 1;\n");
+
+		const resolved = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			resolveReadablePathInsideContext(outsideFile),
+		);
+
+		expect(resolved).toBe(realpathSync(outsideFile));
+	});
+
+	it("#given an outside file inside its own marked project #when inferring workspace #then uses that project root", () => {
+		const root = tempRoot("lsp-outcwd-marker-root-");
+		const outside = tempRoot("lsp-outcwd-marker-outside-");
+		mkdirSync(join(outside, ".git"), { recursive: true });
+		mkdirSync(join(outside, "src"), { recursive: true });
+		const outsideFile = join(outside, "src", "probe.ts");
+		writeFileSync(outsideFile, "export const value = 1;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(outsideFile),
+		);
+
+		expect(workspace).toBe(realpathSync(outside));
+	});
+
+	it("#given an outside file without any marker #when inferring workspace #then falls back to its own directory", () => {
+		const root = tempRoot("lsp-outcwd-nomarker-root-");
+		const outside = tempRoot("lsp-outcwd-nomarker-outside-");
+		const outsideFile = join(outside, "probe.ts");
+		writeFileSync(outsideFile, "export const value = 1;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(outsideFile),
+		);
+
+		expect(workspace).toBe(realpathSync(outside));
+	});
+
+	it("#given an outside file #when resolving a mutating path #then still rejects to keep writes confined", () => {
+		const root = tempRoot("lsp-outcwd-write-root-");
+		const outside = tempRoot("lsp-outcwd-write-outside-");
+		const outsideFile = join(outside, "probe.ts");
+		writeFileSync(outsideFile, "export const value = 1;\n");
+
+		expect(() =>
+			runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+				resolvePathInsideContext(outsideFile),
+			),
+		).toThrow(LspInvalidPathError);
+	});
+});

package/packages/lsp-core/src/lsp/client-wrapper.test.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { afterEach, describe, expect, it } from "bun:test";
 
 import { createStandaloneMcpRequestContext, runWithRequestContext } from "../request-context.js";
+import type { LspClient } from "./client.js";
 import { findWorkspaceRoot, resolveReadablePathInsideContext, withLspClient } from "./client-wrapper.js";
 import { LspInvalidPathError } from "./errors.js";
 import { LspManager } from "./manager.js";
@@ -22,6 +23,102 @@ function tempRoot(prefix: string): string {
 	return root;
 }
 
+describe("LSP workspace root collapse in monorepos", () => {
+	it("#given a git repository containing four package.json packages #when resolving workspace roots for files in each package #then all collapse to the repository root", () => {
+		const root = tempRoot("lsp-client-wrapper-monorepo-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		const packageDirs = ["alpha", "beta", "gamma", "delta"].map((name) => join(root, "packages", name));
+		for (const packageDir of packageDirs) {
+			mkdirSync(join(packageDir, "src"), { recursive: true });
+			writeFileSync(join(packageDir, "package.json"), "{}\n");
+			writeFileSync(join(packageDir, "src", "file.ts"), "export const value = 1;\n");
+		}
+		const context = createStandaloneMcpRequestContext({ cwd: root });
+
+		const roots = packageDirs.map((packageDir) =>
+			runWithRequestContext(context, () => findWorkspaceRoot(join(packageDir, "src", "file.ts"))),
+		);
+
+		expect(new Set(roots).size).toBe(1);
+		expect(roots[0]).toBe(realpathSync(root));
+	});
+
+	it("#given nested package.json markers without any .git #when resolving workspace #then keeps the nearest package root", () => {
+		const root = tempRoot("lsp-client-wrapper-nested-");
+		const nested = join(root, "parent", "nested");
+		mkdirSync(join(nested, "src"), { recursive: true });
+		writeFileSync(join(root, "parent", "package.json"), "{}\n");
+		writeFileSync(join(nested, "package.json"), "{}\n");
+		writeFileSync(join(nested, "src", "file.ts"), "export const value = 1;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(join(nested, "src", "file.ts")),
+		);
+
+		expect(workspace).toBe(realpathSync(nested));
+	});
+
+	it("#given four monorepo package files under one .git root #when acquiring clients #then one client serves the whole repository", async () => {
+		const root = tempRoot("lsp-client-wrapper-oneclient-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		const userConfig = join(root, "user-lsp.json");
+		writeFileSync(
+			userConfig,
+			JSON.stringify({ lsp: { monorepoProbe: { command: [process.execPath], extensions: [".monoroot"] } } }),
+		);
+		const filePaths = ["alpha", "beta", "gamma", "delta"].map((name) => {
+			const packageDir = join(root, "packages", name);
+			mkdirSync(join(packageDir, "src"), { recursive: true });
+			writeFileSync(join(packageDir, "package.json"), "{}\n");
+			const filePath = join(packageDir, "src", "probe.monoroot");
+			writeFileSync(filePath, "const value = 1;\n");
+			return filePath;
+		});
+		const factoryRoots: string[] = [];
+		const manager = new LspManager({
+			clientFactory: (workspaceRoot) => {
+				factoryRoots.push(workspaceRoot);
+				return new StubLspClient() as unknown as LspClient;
+			},
+		});
+
+		try {
+			const context = createStandaloneMcpRequestContext({
+			cwd: root,
+			env: { LSP_TOOLS_MCP_USER_CONFIG: userConfig },
+		});
+			await Promise.all(
+				filePaths.map((filePath) =>
+					runWithRequestContext(context, () =>
+						withLspClient(filePath, async () => undefined, "diagnostics", { manager }),
+				),
+			),
+			);
+
+			expect(factoryRoots).toEqual([realpathSync(root)]);
+			expect(manager.clientCount()).toBe(1);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});
+
+class StubLspClient {
+	async start(): Promise<void> {}
+
+	async initialize(): Promise<void> {}
+
+	isAlive(): boolean {
+		return true;
+	}
+
+	command(): string[] {
+		return [process.execPath];
+	}
+
+	async stop(): Promise<void> {}
+}
+
 describe("LSP client path confinement", () => {
 	it("#given a relative file inside context cwd #when resolving workspace #then marker search stays inside cwd", () => {
 		const root = tempRoot("lsp-client-wrapper-root-");
@@ -36,17 +133,17 @@ describe("LSP client path confinement", () => {
 		expect(workspace).toBe(realpathSync(root));
 	});
 
-	it("#given an absolute file outside context cwd #when resolving #then rejects before workspace inference", () => {
+	it("#given an absolute file outside context cwd #when resolving #then infers the file's own project root", () => {
 		const root = tempRoot("lsp-client-wrapper-cwd-");
 		const outside = tempRoot("lsp-client-wrapper-outside-");
 		mkdirSync(join(outside, ".git"), { recursive: true });
 		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
 
-		expect(() =>
-			runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
-				findWorkspaceRoot(join(outside, "file.ts")),
-			),
-		).toThrow(LspInvalidPathError);
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(join(outside, "file.ts")),
+		);
+
+		expect(workspace).toBe(realpathSync(outside));
 	});
 
 	it("#given a symlink inside cwd that points outside #when resolving read path #then keeps lexical path and cwd root", () => {