oh-my-opencode 5.0.0-beta.1 → 5.0.0-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.11",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -136,6 +136,7 @@
     "typecheck:script": "tsgo --noEmit -p script/tsconfig.json",
     "test": "bun test",
     "test:codex": "bun run build:codex-install && bun run build:git-bash-mcp && bun run build:lsp-tools-mcp && bun run build:lsp-daemon && npm --prefix packages/lsp-tools-mcp test && npm --prefix packages/omo-codex/plugin ci && npm --prefix packages/omo-codex/plugin/components/ulw-loop test && bun run --cwd packages/omo-codex/plugin build && npm --prefix packages/omo-codex/plugin/components/codegraph run typecheck && npm --prefix packages/omo-codex/plugin/components/codegraph test && node scripts/check-third-party-notices.mjs --ship && bun test packages/omo-opencode/src/cli/cli-installer.platform.test.ts packages/omo-codex/src/install/codex-cache.test.ts packages/omo-codex/src/install/codex-cleanup.test.ts packages/omo-codex/src/install/codex-config-agent-cleanup.test.ts packages/omo-codex/src/install/codex-config-autonomous-features.test.ts packages/omo-codex/src/install/codex-config-reasoning.test.ts packages/omo-codex/src/install/codex-config-toml.test.ts packages/omo-codex/src/install/codex-project-local-cleanup.test.ts packages/omo-codex/src/install/install-codex-project-local-cleanup.test.ts packages/omo-codex/src/install/install-codex.test.ts packages/omo-codex/src/install/install-codex-packaged.test.ts packages/omo-codex/src/install/link-cached-plugin-agents.test.ts packages/omo-codex/src/**/*.test.ts packages/utils/src/jsonc-parser.test.ts packages/utils/src/frontmatter.test.ts packages/hashline-core/src/hash-computation.test.ts packages/hashline-core/src/smoke-untested-modules.test.ts packages/rules-engine/src/index.test.ts packages/rules-engine/src/security-boundary.test.ts packages/agents-md-core/src/injector.test.ts packages/omo-codex/plugin/components/lsp/test/package-smoke.test.ts && node --test packages/omo-codex/plugin/test/*.test.mjs packages/omo-codex/scripts/install-cache-copy.test.mjs packages/omo-codex/scripts/install-cli-args.test.mjs packages/omo-codex/scripts/install-delegated-command.test.mjs packages/omo-codex/scripts/install-config-autonomous-features.test.mjs packages/omo-codex/scripts/install-config-autonomous.test.mjs packages/omo-codex/scripts/install-config-reasoning.test.mjs packages/omo-codex/scripts/install-config.test.mjs packages/omo-codex/scripts/install-hook-targets.test.mjs packages/omo-codex/scripts/install-project-local-cleanup.test.mjs packages/omo-codex/scripts/install-lazycodex-version-stamp.test.mjs packages/omo-codex/scripts/install-local-entrypoint.test.mjs packages/omo-codex/scripts/install-local-git-bash-preflight.test.mjs packages/omo-codex/scripts/install-local.test.mjs packages/omo-codex/scripts/install-marketplace-cache.test.mjs packages/omo-codex/scripts/install-mcp-context7-runtime.test.mjs packages/omo-codex/scripts/install-mcp-runtime.test.mjs packages/omo-codex/scripts/install-packaged-local.test.mjs packages/omo-codex/scripts/install-generated-bundle.test.mjs packages/omo-codex/scripts/install-agent-links.test.mjs packages/omo-codex/scripts/install-bin-links.test.mjs",
+    "test:fast": "bun run script/test-fast.ts",
     "test:senpi": "bun run build:senpi-plugin && tsgo --noEmit -p packages/omo-senpi/tsconfig.json && bun test packages/omo-senpi",
     "test:windows-codex": "bun run test:codex",
     "build:git-bash-mcp": "bun run --cwd packages/git-bash-mcp build",
@@ -180,7 +181,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@code-yeongyu/senpi": "2026.8.9-2",
+    "@code-yeongyu/senpi": "2026.8.18-3",
     "@oh-my-opencode/agents-md-core": "workspace:*",
     "@oh-my-opencode/ast-grep-mcp": "workspace:*",
     "@oh-my-opencode/boulder-state": "workspace:*",
@@ -196,6 +197,7 @@
     "@oh-my-opencode/model-core": "workspace:*",
     "@oh-my-opencode/omo-codex": "workspace:*",
     "@oh-my-opencode/omo-config-core": "workspace:*",
+    "@oh-my-opencode/omo-opencode": "workspace:*",
     "@oh-my-opencode/omo-senpi": "workspace:*",
     "@oh-my-opencode/openclaw-core": "workspace:*",
     "@oh-my-opencode/pi-goal": "workspace:*",
@@ -211,7 +213,7 @@
     "@oh-my-opencode/utils": "workspace:*",
     "@types/js-yaml": "^4.0.9",
     "@types/picomatch": "^4.0.3",
-    "@typescript/native-preview": "7.0.0-dev.20260518.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "@xterm/addon-unicode11": "^0.9.0",
     "@xterm/xterm": "^6.0.0",
     "bun-types": "1.3.14",
@@ -220,24 +222,24 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "5.0.0-beta.1",
-    "oh-my-opencode-darwin-x64": "5.0.0-beta.1",
-    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.1",
-    "oh-my-opencode-linux-arm64": "5.0.0-beta.1",
-    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.1",
-    "oh-my-opencode-linux-x64": "5.0.0-beta.1",
-    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.1",
-    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.1",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.1",
-    "oh-my-opencode-windows-arm64": "5.0.0-beta.1",
-    "oh-my-opencode-windows-x64": "5.0.0-beta.1",
-    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.1"
+    "oh-my-opencode-darwin-arm64": "5.0.0-beta.11",
+    "oh-my-opencode-darwin-x64": "5.0.0-beta.11",
+    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.11",
+    "oh-my-opencode-linux-arm64": "5.0.0-beta.11",
+    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.11",
+    "oh-my-opencode-linux-x64": "5.0.0-beta.11",
+    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.11",
+    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.11",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.11",
+    "oh-my-opencode-windows-arm64": "5.0.0-beta.11",
+    "oh-my-opencode-windows-x64": "5.0.0-beta.11",
+    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.11"
   },
   "overrides": {
-    "@earendil-works/pi-agent-core": "0.80.3",
-    "@earendil-works/pi-ai": "0.80.3",
-    "@earendil-works/pi-coding-agent": "0.80.3",
-    "@earendil-works/pi-tui": "0.80.3",
+    "@earendil-works/pi-agent-core": "0.84.2",
+    "@earendil-works/pi-ai": "0.84.2",
+    "@earendil-works/pi-coding-agent": "0.84.2",
+    "@earendil-works/pi-tui": "0.84.2",
     "hono": "^4.12.18",
     "@hono/node-server": "^1.19.13",
     "express-rate-limit": "^8.5.1",

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

@@ -0,0 +1,44 @@
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+} from "./workspace-apply-edit-test-support.js";
+
+const harness = createWorkspaceEditTestHarness();
+
+afterEach(async () => {
+	await harness.cleanup();
+});
+
+describe("LspClient diagnostics concurrency", () => {
+	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")],
+						awaitClientDelivery: true,
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 500, 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);
+	});
+});

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

@@ -16,34 +16,6 @@ afterEach(async () => {
 });
 
 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);
-	});
-
 	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 context = await harness.makeClient(
 			{

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,8 +4,9 @@ import { join } from "node:path";
 import { afterEach, describe, expect, it } from "bun:test";
 
 import { createStandaloneMcpRequestContext, runWithRequestContext } from "../request-context.js";
-import { findWorkspaceRoot, resolvePathInsideContext } from "./client-wrapper.js";
+import { findWorkspaceRoot, resolveReadablePathInsideContext, withLspClient } from "./client-wrapper.js";
 import { LspInvalidPathError } from "./errors.js";
+import { LspManager } from "./manager.js";
 
 const tempDirectories: string[] = [];
 
@@ -35,29 +36,81 @@ 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 #then rejects the escape", () => {
+	it("#given a symlink inside cwd that points outside #when resolving read path #then keeps lexical path and cwd root", () => {
 		const root = tempRoot("lsp-client-wrapper-symlink-root-");
 		const outside = tempRoot("lsp-client-wrapper-symlink-outside-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		mkdirSync(join(outside, ".git"), { recursive: true });
+		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
+		symlinkSync(outside, join(root, "linked"));
+
+		const result = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () => ({
+			filePath: resolveReadablePathInsideContext("linked/file.ts"),
+			workspaceRoot: findWorkspaceRoot("linked/file.ts"),
+		}));
+
+		expect(result.filePath).toBe(join(realpathSync(root), "linked", "file.ts"));
+		expect(result.workspaceRoot).toBe(realpathSync(root));
+	});
+
+	it("#given an absolute macOS alias path through an outside symlink #when resolving read path #then preserves the lexical suffix", () => {
+		const root = tempRoot("lsp-client-wrapper-alias-root-");
+		const outside = tempRoot("lsp-client-wrapper-alias-outside-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
+		symlinkSync(outside, join(root, "linked"));
+
+		const result = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			resolveReadablePathInsideContext(join(root, "linked", "file.ts")),
+		);
+
+		expect(result).toBe(join(realpathSync(root), "linked", "file.ts"));
+	});
+
+	it("#given missing parent directories without markers #when resolving workspace #then uses an existing directory", () => {
+		const root = tempRoot("lsp-client-wrapper-missing-root-");
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot("missing/deep/file.ts"),
+		);
+
+		expect(workspace).toBe(realpathSync(root));
+	});
+
+	it("#given a symlink inside cwd that points outside #when starting rename #then rejects before client acquisition", async () => {
+		const root = tempRoot("lsp-client-wrapper-rename-root-");
+		const outside = tempRoot("lsp-client-wrapper-rename-outside-");
 		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
 		symlinkSync(outside, join(root, "linked"));
+		let clientFactoryCalls = 0;
+		const manager = new LspManager({
+			clientFactory: () => {
+				clientFactoryCalls += 1;
+				throw new Error("client acquisition must not start");
+			},
+		});
 
-		expect(() =>
-			runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
-				resolvePathInsideContext("linked/file.ts"),
-			),
-		).toThrow(LspInvalidPathError);
+		try {
+			await expect(
+				runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+					withLspClient("linked/file.ts", async () => undefined, "rename", { manager }),
+				),
+			).rejects.toThrow(LspInvalidPathError);
+			expect(clientFactoryCalls).toBe(0);
+		} finally {
+			await manager.stopAll();
+		}
 	});
 });

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

@@ -1,5 +1,5 @@
-import { existsSync, statSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
 import {
 	canonicalizeExistingOrNearestAncestor,
 	contextCwd,
@@ -16,11 +16,11 @@ import {
 	LspServerLookupError,
 } from "./errors.js";
 import { getLspManager, type LspManager } from "./manager.js";
+import { findWorkspaceRootOutsideContext } from "./outside-context-workspace.js";
 import { loadInstallDecision } from "./server-install-state.js";
 import { findServerForExtension } from "./server-resolution.js";
 import type { ServerLookupResult } from "./types.js";
-
-const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
+import { WORKSPACE_MARKERS } from "./workspace-markers.js";
 
 export function isDirectoryPath(filePath: string): boolean {
 	try {
@@ -31,30 +31,47 @@ export function isDirectoryPath(filePath: string): boolean {
 }
 
 export function findWorkspaceRoot(filePath: string): string {
-	const abs = resolvePathInsideContext(filePath);
+	const cwd = contextCwd();
+	const abs = resolveReadablePathInsideContext(filePath);
 	let dir = abs;
 
 	if (!isDirectoryPath(dir)) {
 		dir = dirname(dir);
 	}
 
-	let prevDir = "";
-	while (dir !== prevDir) {
-		for (const marker of WORKSPACE_MARKERS) {
-			if (existsSync(join(dir, marker))) {
-				return dir;
+	if (!isPathInside(cwd, abs)) return findWorkspaceRootOutsideContext(dir);
+
+	const fallbackRoot = nearestExistingDirectoryInsideContext(dir, cwd) ?? cwd;
+	while (isPathInside(cwd, dir)) {
+		const canonicalDir = existingDirectoryInsideContext(dir, cwd);
+		if (canonicalDir !== undefined) {
+			for (const marker of WORKSPACE_MARKERS) {
+				if (existsSync(join(dir, marker))) {
+					return canonicalDir;
+				}
 			}
 		}
-		prevDir = dir;
+		if (dir === cwd) break;
 		dir = dirname(dir);
 	}
 
-	return dirname(abs);
+	return fallbackRoot;
 }
 
-export function resolvePathInsideContext(filePath: string): string {
+export function resolveReadablePathInsideContext(filePath: string): string {
 	const cwd = contextCwd();
 	const abs = resolve(cwd, filePath);
+	if (isPathInside(cwd, abs)) return abs;
+
+	const rebased = rebaseThroughCanonicalAncestor(abs, cwd);
+	if (rebased !== undefined) return rebased;
+
+	return canonicalizeExistingOrNearestAncestor(abs);
+}
+
+export function resolvePathInsideContext(filePath: string): string {
+	const cwd = contextCwd();
+	const abs = resolveReadablePathInsideContext(filePath);
 	const canonical = canonicalizeExistingOrNearestAncestor(abs);
 	if (!isPathInside(cwd, canonical)) {
 		throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
@@ -62,6 +79,39 @@ export function resolvePathInsideContext(filePath: string): string {
 	return canonical;
 }
 
+function rebaseThroughCanonicalAncestor(path: string, cwd: string): string | undefined {
+	let current = path;
+	const suffix: string[] = [];
+	while (true) {
+		if (existsSync(current)) {
+			const canonical = realpathSync(current);
+			if (isPathInside(cwd, canonical)) return suffix.length === 0 ? canonical : join(canonical, ...suffix);
+		}
+		const parent = dirname(current);
+		if (parent === current) return undefined;
+		suffix.unshift(basename(current));
+		current = parent;
+	}
+}
+
+function existingDirectoryInsideContext(directory: string, cwd: string): string | undefined {
+	if (!existsSync(directory)) return undefined;
+	const canonical = realpathSync(directory);
+	if (!statSync(canonical).isDirectory()) return undefined;
+	return isPathInside(cwd, canonical) ? canonical : undefined;
+}
+
+function nearestExistingDirectoryInsideContext(directory: string, cwd: string): string | undefined {
+	let current = directory;
+	while (isPathInside(cwd, current)) {
+		const canonical = existingDirectoryInsideContext(current, cwd);
+		if (canonical !== undefined) return canonical;
+		if (current === cwd) return undefined;
+		current = dirname(current);
+	}
+	return undefined;
+}
+
 export function formatServerLookupError(result: Exclude<ServerLookupResult, { status: "found" }>): string {
 	if (result.status === "not_installed") {
 		return formatNotInstalled(result);
@@ -143,7 +193,7 @@ export interface WithLspClientOptions {
 	manager?: LspManager;
 }
 
-const READ_ONLY_RETRY_TOOLS = new Set([
+const READ_ONLY_TOOLS = new Set([
 	"diagnostics",
 	"definition",
 	"references",
@@ -154,11 +204,13 @@ const READ_ONLY_RETRY_TOOLS = new Set([
 
 export async function withLspClient<T>(
 	filePath: string,
-	fn: (client: LspClient, workspaceRoot: string) => Promise<T>,
+	fn: (client: LspClient, workspaceRoot: string, resolvedFilePath: string) => Promise<T>,
 	toolName: string,
 	options: WithLspClientOptions = {},
 ): Promise<T> {
-	const absPath = resolvePathInsideContext(filePath);
+	const absPath = READ_ONLY_TOOLS.has(toolName)
+		? resolveReadablePathInsideContext(filePath)
+		: resolvePathInsideContext(filePath);
 
 	if (isDirectoryPath(absPath)) {
 		throw new LspInvalidPathError(
@@ -181,9 +233,9 @@ export async function withLspClient<T>(
 		const client = await manager.getClient(root, server, options.signal);
 
 		try {
-			return await fn(client, root);
+			return await fn(client, root, absPath);
 		} catch (err) {
-			if (allowRetry && READ_ONLY_RETRY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
+			if (allowRetry && READ_ONLY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
 				manager.invalidateClient(root, server.id, client);
 				return acquireAndCall(false);
 			}

package/packages/lsp-core/src/lsp/outside-context-workspace.ts

@@ -0,0 +1,33 @@
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { WORKSPACE_MARKERS } from "./workspace-markers.js";
+
+/** Read-only tools accept out-of-cwd files, so cwd cannot bound this search; the fallback keeps the server scoped to the file's own directory. */
+export function findWorkspaceRootOutsideContext(directory: string): string {
+	const marked = nearestMarkedAncestor(directory);
+	if (marked !== undefined) return marked;
+	return realpathSync(nearestExistingAncestor(directory));
+}
+
+function nearestMarkedAncestor(directory: string): string | undefined {
+	let current = directory;
+	for (;;) {
+		if (existsSync(current) && WORKSPACE_MARKERS.some((marker) => existsSync(join(current, marker)))) {
+			return realpathSync(current);
+		}
+		const parent = dirname(current);
+		if (parent === current) return undefined;
+		current = parent;
+	}
+}
+
+function nearestExistingAncestor(directory: string): string {
+	let current = directory;
+	while (!existsSync(current)) {
+		const parent = dirname(current);
+		if (parent === current) return current;
+		current = parent;
+	}
+	return current;
+}

package/packages/lsp-core/src/lsp/workspace-edit-adversarial.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -87,6 +87,25 @@ describe("workspace edit adversarial inputs", () => {
 		expect(readFileSync(outsideFile, "utf-8")).toBe("outside bytes\n");
 	});
 
+	it("#given an in-workspace symlink to an outside file #when applying an edit #then rejects without modifying target", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const outside = makeTempDirectory("lsp-outside-");
+		const outsideFile = join(outside, "outside.ts");
+		const canonicalWorkspace = realpathSync(workspace);
+		const linkedDirectory = join(canonicalWorkspace, "linked");
+		writeFileSync(outsideFile, "outside bytes\n", "utf-8");
+		symlinkSync(outside, linkedDirectory);
+
+		const result = applyWorkspaceEdit(
+			{ changes: { [pathToFileURL(join(linkedDirectory, "outside.ts")).href]: [insertion()] } },
+			{ workspaceRoot: canonicalWorkspace },
+		);
+
+		expect(result.success).toBe(false);
+		expect(result.errors.join("\n")).toContain("outside workspace");
+		expect(readFileSync(outsideFile, "utf-8")).toBe("outside bytes\n");
+	});
+
 	it("#given annotations or mixed edit representations #when planned #then unsupported claims are rejected", () => {
 		const workspace = makeTempDirectory("lsp-workspace-");
 		const unsupported = [

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

@@ -0,0 +1 @@
+export const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"] as const;

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

@@ -1,4 +1,4 @@
-import { isDirectoryPath, resolvePathInsideContext, withLspClient } from "../lsp/client-wrapper.js";
+import { isDirectoryPath, resolveReadablePathInsideContext, withLspClient } from "../lsp/client-wrapper.js";
 import { DEFAULT_MAX_DIAGNOSTICS } from "../lsp/constants.js";
 import { aggregateDiagnosticsForDirectory } from "../lsp/directory-diagnostics.js";
 import { filterDiagnosticsBySeverity, formatDiagnostic } from "../lsp/formatters.js";
@@ -23,7 +23,7 @@ export async function executeLspDiagnostics(
 	const severity = severityFilter(params);
 
 	try {
-		const absPath = resolvePathInsideContext(filePath);
+		const absPath = resolveReadablePathInsideContext(filePath);
 		if (isDirectoryPath(absPath)) {
 			const extension = inferExtensionFromDirectory(absPath);
 			if (!extension) {
@@ -62,7 +62,7 @@ export async function executeLspDiagnostics(
 
 		const result = await withLspClient(
 				filePath,
-				async (client) => client.diagnostics(filePath, signal),
+				async (client, _workspaceRoot, resolvedFilePath) => client.diagnostics(resolvedFilePath, signal),
 				"diagnostics",
 				clientOptions(signal),
 			);

package/packages/lsp-core/src/tools/navigation.ts

@@ -17,7 +17,8 @@ export async function executeLspGotoDefinition(
 	try {
 			const result = await withLspClient(
 				filePath,
-				async (client) => client.definition(filePath, line, character, signal),
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.definition(resolvedFilePath, line, character, signal),
 				"definition",
 				clientOptions(signal),
 			);
@@ -49,7 +50,8 @@ export async function executeLspFindReferences(
 	try {
 			const result = await withLspClient(
 				filePath,
-				async (client) => client.references(filePath, line, character, includeDeclaration, signal),
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.references(resolvedFilePath, line, character, includeDeclaration, signal),
 				"references",
 				clientOptions(signal),
 			);

package/packages/lsp-core/src/tools/rename.ts

@@ -16,7 +16,8 @@ export async function executeLspPrepareRename(
 	try {
 			const result = await withLspClient(
 				filePath,
-				async (client) => client.prepareRename(filePath, line, character, signal),
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.prepareRename(resolvedFilePath, line, character, signal),
 				"prepareRename",
 				clientOptions(signal),
 			);
@@ -46,7 +47,8 @@ export async function executeLspRename(
 	try {
 		const result = await withLspClient(
 			filePath,
-			async (client) => client.rename(filePath, line, character, newName, signal),
+			async (client, _workspaceRoot, resolvedFilePath) =>
+				client.rename(resolvedFilePath, line, character, newName, signal),
 			"rename",
 			clientOptions(signal),
 		);

package/packages/lsp-core/src/tools/symbols.ts

@@ -47,7 +47,7 @@ export async function executeLspSymbols(
 
 			const symbols = await withLspClient(
 				filePath,
-				async (client) => client.documentSymbols(filePath, signal),
+				async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal),
 				"documentSymbols",
 				clientOptions(signal),
 			);