oh-my-opencode 4.14.0 → 4.14.1

package/packages/omo-codex/plugin/components/codegraph/src/mcp-bridge.ts

@@ -20,6 +20,21 @@ class CodegraphBridgeStdioError extends Error {
 	}
 }
 
+interface PendingClientResponse {
+	readonly method: string | null;
+	readonly responseMode: StdioJsonRpcResponseMode;
+	readonly toolName: string | null;
+}
+
+const CODEGRAPH_NODE_DESCRIPTION =
+	"Inspect one named symbol or file. In symbol mode, includeCode=true includes leaf-symbol source when available. Container symbols such as classes, interfaces, structs, enums, modules, and namespaces return structural outlines with member lists by design. For container source, request a specific member symbol or use file mode with symbolsOnly=false plus offset/limit.";
+
+const CODEGRAPH_NODE_INCLUDE_CODE_DESCRIPTION =
+	"Symbol mode: include leaf-symbol source when available. Container symbols such as classes, interfaces, structs, enums, modules, and namespaces intentionally return structural outlines with members; request a specific member symbol or use file mode with symbolsOnly=false plus offset/limit for source.";
+
+const CODEGRAPH_CONTAINER_OUTLINE_GUIDANCE =
+	"Container symbols intentionally return structural outlines with members. For source, request a specific member symbol or call codegraph_node in file mode with symbolsOnly=false plus offset/limit around the symbol location.";
+
 export async function runBridgedCodegraphProcess(
 	command: string,
 	args: readonly string[],
@@ -36,7 +51,7 @@ export async function runBridgedCodegraphProcess(
 	if (childInput === null) throw new CodegraphBridgeStdioError("stdin");
 	if (childOutput === null) throw new CodegraphBridgeStdioError("stdout");
 
-	const responseModes = new Map<string, StdioJsonRpcResponseMode>();
+	const pendingResponses = new Map<string, PendingClientResponse>();
 	let defaultResponseMode: StdioJsonRpcResponseMode = "framed";
 	const childExit = new Promise<number>((resolveExit, reject) => {
 		child.once("error", reject);
@@ -49,10 +64,10 @@ export async function runBridgedCodegraphProcess(
 		});
 	});
 	const bridgeDone = Promise.all([
-		forwardClientToCodegraph(options.input, childInput, responseModes, (mode) => {
+		forwardClientToCodegraph(options.input, childInput, pendingResponses, (mode) => {
 			defaultResponseMode = mode;
 		}),
-		forwardCodegraphToClient(childOutput, options.output, responseModes, () => defaultResponseMode),
+		forwardCodegraphToClient(childOutput, options.output, pendingResponses, () => defaultResponseMode),
 	]);
 	const destroyChildPipes = (): void => {
 		childInput.destroy();
@@ -65,7 +80,7 @@ export async function runBridgedCodegraphProcess(
 async function forwardClientToCodegraph(
 	input: Readable,
 	childInput: Writable,
-	responseModes: Map<string, StdioJsonRpcResponseMode>,
+	pendingResponses: Map<string, PendingClientResponse>,
 	setDefaultResponseMode: (mode: StdioJsonRpcResponseMode) => void,
 ): Promise<void> {
 	for await (const message of readStdioJsonRpcMessages(input)) {
@@ -75,7 +90,13 @@ async function forwardClientToCodegraph(
 		const responseMode = message.responseMode;
 		setDefaultResponseMode(responseMode);
 		const key = responseModeKey(message.payload);
-		if (key !== null) responseModes.set(key, responseMode);
+		if (key !== null) {
+			pendingResponses.set(key, {
+				method: jsonRpcMethod(message.payload),
+				responseMode,
+				toolName: jsonRpcToolName(message.payload),
+			});
+		}
 		await writeLine(childInput, JSON.stringify(message.payload));
 	}
 	childInput.end();
@@ -84,7 +105,7 @@ async function forwardClientToCodegraph(
 async function forwardCodegraphToClient(
 	childOutput: Readable,
 	output: Writable,
-	responseModes: Map<string, StdioJsonRpcResponseMode>,
+	pendingResponses: Map<string, PendingClientResponse>,
 	defaultResponseMode: () => StdioJsonRpcResponseMode,
 ): Promise<void> {
 	for await (const message of readStdioJsonRpcMessages(childOutput)) {
@@ -93,9 +114,10 @@ async function forwardCodegraphToClient(
 			continue;
 		}
 		const key = responseModeKey(message.payload);
-		const responseMode = key === null ? defaultResponseMode() : (responseModes.get(key) ?? defaultResponseMode());
-		if (key !== null) responseModes.delete(key);
-		writeStdioJsonRpcResponse(output, message.payload, responseMode);
+		const pendingResponse = key === null ? undefined : pendingResponses.get(key);
+		const responseMode = pendingResponse?.responseMode ?? defaultResponseMode();
+		if (key !== null) pendingResponses.delete(key);
+		writeStdioJsonRpcResponse(output, clarifyCodegraphResponse(message.payload, pendingResponse), responseMode);
 	}
 }
 
@@ -105,6 +127,101 @@ function responseModeKey(payload: unknown): string | null {
 	return `${typeof id}:${String(id)}`;
 }
 
+function jsonRpcMethod(payload: unknown): string | null {
+	if (!isPlainRecord(payload)) return null;
+	const method = payload["method"];
+	return typeof method === "string" ? method : null;
+}
+
+function jsonRpcToolName(payload: unknown): string | null {
+	if (jsonRpcMethod(payload) !== "tools/call" || !isPlainRecord(payload)) return null;
+	const params = payload["params"];
+	if (!isPlainRecord(params)) return null;
+	const name = params["name"];
+	return typeof name === "string" ? name : null;
+}
+
+function clarifyCodegraphResponse(payload: unknown, pendingResponse: PendingClientResponse | undefined): unknown {
+	if (pendingResponse?.method === "tools/list") return clarifyCodegraphToolsList(payload);
+	if (pendingResponse?.method === "tools/call" && pendingResponse.toolName === "codegraph_node") {
+		return clarifyCodegraphNodeCallResult(payload);
+	}
+	return payload;
+}
+
+function clarifyCodegraphToolsList(payload: unknown): unknown {
+	if (!isPlainRecord(payload)) return payload;
+	const result = payload["result"];
+	if (!isPlainRecord(result) || !Array.isArray(result["tools"])) return payload;
+
+	let changed = false;
+	const tools = result["tools"].map((tool) => {
+		if (!isPlainRecord(tool) || tool["name"] !== "codegraph_node") return tool;
+		if (!hasCodegraphNodeContractMetadata(tool)) return tool;
+		changed = true;
+		return clarifyCodegraphNodeTool(tool);
+	});
+	if (!changed) return payload;
+	return { ...payload, result: { ...result, tools } };
+}
+
+function clarifyCodegraphNodeTool(tool: Record<string, unknown>): Record<string, unknown> {
+	const clarified: Record<string, unknown> = {
+		...tool,
+		description: CODEGRAPH_NODE_DESCRIPTION,
+	};
+	const inputSchema = tool["inputSchema"];
+	if (isPlainRecord(inputSchema)) clarified["inputSchema"] = clarifyCodegraphNodeInputSchema(inputSchema);
+	return clarified;
+}
+
+function hasCodegraphNodeContractMetadata(tool: Record<string, unknown>): boolean {
+	if (typeof tool["description"] === "string") return true;
+	const inputSchema = tool["inputSchema"];
+	if (!isPlainRecord(inputSchema)) return false;
+	const properties = inputSchema["properties"];
+	return isPlainRecord(properties) && isPlainRecord(properties["includeCode"]);
+}
+
+function clarifyCodegraphNodeInputSchema(inputSchema: Record<string, unknown>): Record<string, unknown> {
+	const properties = inputSchema["properties"];
+	if (!isPlainRecord(properties)) return inputSchema;
+	const includeCode = properties["includeCode"];
+	if (!isPlainRecord(includeCode)) return inputSchema;
+	return {
+		...inputSchema,
+		properties: {
+			...properties,
+			includeCode: {
+				...includeCode,
+				description: CODEGRAPH_NODE_INCLUDE_CODE_DESCRIPTION,
+			},
+		},
+	};
+}
+
+function clarifyCodegraphNodeCallResult(payload: unknown): unknown {
+	if (!isPlainRecord(payload)) return payload;
+	const result = payload["result"];
+	if (!isPlainRecord(result) || !Array.isArray(result["content"])) return payload;
+
+	let changed = false;
+	const content = result["content"].map((item) => {
+		if (!isPlainRecord(item) || item["type"] !== "text" || typeof item["text"] !== "string") return item;
+		const text = clarifyContainerOutlineGuidance(item["text"]);
+		if (text === item["text"]) return item;
+		changed = true;
+		return { ...item, text };
+	});
+	if (!changed) return payload;
+	return { ...payload, result: { ...result, content } };
+}
+
+function clarifyContainerOutlineGuidance(text: string): string {
+	if (!text.includes("Structural outline only")) return text;
+	return text.replace(/Structural outline only[^\n]*(?:\n[^\n]*(?:Read|read)[^\n]*)?/g, CODEGRAPH_CONTAINER_OUTLINE_GUIDANCE);
+}
+
 async function writeLine(output: Writable, line: string): Promise<void> {
 	if (output.write(`${line}\n`)) return;
 	await new Promise<void>((resolveDrain, reject) => {

package/packages/omo-codex/plugin/components/codegraph/test/serve-mcp-bridge.test.ts

@@ -93,6 +93,90 @@ describe("runCodegraphServe MCP protocol bridge", () => {
 			rmSync(tempRoot, { recursive: true, force: true });
 		}
 	});
+
+	it("#given old upstream codegraph_node metadata and container outline guidance #when bridging #then it exposes the corrected LazyCodex contract", async () => {
+		// given
+		const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-contract-"));
+		const projectRoot = join(tempRoot, "project");
+		const fakeCodegraph = join(tempRoot, "codegraph-contract-fake.cjs");
+		const childLog = join(tempRoot, "child.log");
+		const input = new PassThrough();
+		const output = new PassThrough();
+		let stdout = "";
+		output.on("data", (chunk: Buffer) => {
+			stdout += chunk.toString("utf8");
+		});
+
+		try {
+			mkdirSync(projectRoot, { recursive: true });
+			writeFakeContractCodegraph(fakeCodegraph);
+
+			const run = runCodegraphServe({
+				cwd: tempRoot,
+				env: {
+					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
+					CODEGRAPH_FAKE_LOG: childLog,
+					OMO_CODEGRAPH_BIN: fakeCodegraph,
+					OMO_CODEGRAPH_PROJECT_CWD: projectRoot,
+					PATH: process.env["PATH"],
+				},
+				nodeVersion: "22.14.0",
+				buildEnv: () => ({}),
+				resolve: () => ({ argsPrefix: [], command: fakeCodegraph, exists: true, source: "env" }),
+				stderr: { write: () => undefined },
+				stdin: input,
+				stdout: output,
+			});
+
+			// when
+			input.end([
+				frameMcpRequest({
+					id: 1,
+					method: "tools/list",
+					params: {},
+				}),
+				frameMcpRequest({
+					id: 2,
+					method: "tools/call",
+					params: {
+						arguments: { includeCode: true, symbol: "JsonlMCP" },
+						name: "codegraph_node",
+					},
+				}),
+			].join(""));
+			const exitCode = await run;
+
+			// then
+			expect(exitCode).toBe(0);
+			const bodies = parseMcpBodies(stdout);
+			const tools = arrayProperty(recordProperty(recordValue(bodies[0]), "result"), "tools");
+			const nodeTool = findTool(tools, "codegraph_node");
+			const searchTool = findTool(tools, "codegraph_search");
+			expect(stringProperty(nodeTool, "description")).toContain("Container symbols");
+			expect(stringProperty(nodeTool, "description")).toContain("file mode");
+			expect(stringProperty(nodeTool, "description")).not.toContain("verbatim source");
+			expect(stringProperty(nodeTool, "description")).not.toContain("full body");
+			expect(
+				stringProperty(
+					recordProperty(recordProperty(recordProperty(nodeTool, "inputSchema"), "properties"), "includeCode"),
+					"description",
+				),
+			).toBe(
+				"Symbol mode: include leaf-symbol source when available. Container symbols such as classes, interfaces, structs, enums, modules, and namespaces intentionally return structural outlines with members; request a specific member symbol or use file mode with symbolsOnly=false plus offset/limit for source.",
+			);
+			expect(searchTool).toEqual({ description: "search stays unchanged", name: "codegraph_search" });
+
+			const callResult = recordProperty(recordValue(bodies[1]), "result");
+			const text = stringProperty(recordValue(arrayProperty(callResult, "content")[0]), "text");
+			expect(text).toContain("Container symbols intentionally return structural outlines");
+			expect(text).toContain("specific member symbol");
+			expect(text).toContain("file mode");
+			expect(text).toContain("symbolsOnly=false");
+			expect(text).not.toContain("Read tool");
+		} finally {
+			rmSync(tempRoot, { recursive: true, force: true });
+		}
+	});
 });
 
 function writeFakeNewlineCodegraph(filePath: string): void {
@@ -118,6 +202,32 @@ function writeFakeNewlineCodegraph(filePath: string): void {
 	chmodSync(filePath, 0o755);
 }
 
+function writeFakeContractCodegraph(filePath: string): void {
+	writeFileSync(
+		filePath,
+		[
+			"#!/usr/bin/env node",
+			"const fs = require('node:fs');",
+			"const readline = require('node:readline');",
+			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, `cwd=${process.cwd()}\\n`);",
+			"const rl = readline.createInterface({ input: process.stdin });",
+			"rl.on('line', (line) => {",
+			"  const request = JSON.parse(line);",
+			"  if (request.method === 'tools/list') {",
+			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: [",
+			"      { name: 'codegraph_search', description: 'search stays unchanged' },",
+			"      { name: 'codegraph_node', description: 'ONE SYMBOL you can name - its location, signature, verbatim source (includeCode=true) and caller/callee trail in one call', inputSchema: { type: 'object', properties: { includeCode: { type: 'boolean', description: \"Symbol mode: include the symbol's full body (default: false).\" }, symbol: { type: 'string' } } } }",
+			"    ] } }) + '\\n');",
+			"  }",
+			"  if (request.method === 'tools/call') {",
+			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { content: [{ type: 'text', text: 'JsonlMCP\\nMembers (7)\\nStructural outline only. For full source, use the Read tool on this file or request a member.' }] } }) + '\\n');",
+			"  }",
+			"});",
+		].join("\n"),
+	);
+	chmodSync(filePath, 0o755);
+}
+
 function frameMcpRequest(request: {
 	readonly id: number;
 	readonly method: string;
@@ -144,3 +254,34 @@ function parseMcpBodies(transcript: string): readonly unknown[] {
 	}
 	return bodies;
 }
+
+function findTool(tools: readonly unknown[], name: string): Record<string, unknown> {
+	for (const tool of tools) {
+		const record = recordValue(tool);
+		if (record["name"] === name) return record;
+	}
+	throw new Error(`Missing tool ${name}`);
+}
+
+function arrayProperty(record: Record<string, unknown>, key: string): readonly unknown[] {
+	const value = record[key];
+	if (!Array.isArray(value)) throw new Error(`Expected ${key} to be an array`);
+	return value;
+}
+
+function recordProperty(record: Record<string, unknown>, key: string): Record<string, unknown> {
+	return recordValue(record[key]);
+}
+
+function stringProperty(record: Record<string, unknown>, key: string): string {
+	const value = record[key];
+	if (typeof value !== "string") throw new Error(`Expected ${key} to be a string`);
+	return value;
+}
+
+function recordValue(value: unknown): Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		throw new Error("Expected record value");
+	}
+	return value as Record<string, unknown>;
+}

package/packages/omo-codex/plugin/components/comment-checker/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "4.14.0",
+	"version": "4.14.1",
 	"description": "Codex plugin that runs comment-checker after edit-like PostToolUse hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/git-bash/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-git-bash-hook",
-	"version": "4.14.0",
+	"version": "4.14.1",
 	"description": "Codex hook component that reminds Windows sessions to prefer the OMO git_bash MCP.",
 	"type": "module",
 	"private": true,

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lazycodex-executor-verify",
-	"version": "4.14.0",
+	"version": "4.14.1",
 	"description": "Codex SubagentStop evidence verifier for LazyCodex executor completions.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/lsp/dist/cli.js

@@ -2,7 +2,6 @@
 
 // components/lsp/src/cli.ts
 import { spawn as spawn3 } from "node:child_process";
-import { createRequire as createRequire2 } from "node:module";
 import { argv, execPath as execPath2, stderr } from "node:process";
 
 // components/lsp/src/codex-hook-cli.ts
@@ -1481,6 +1480,7 @@ function unlinkQuietly(path) {
 var PROBE_TIMEOUT_MS = 500;
 var DEFAULT_READY_TIMEOUT_MS = 5000;
 var DEFAULT_POLL_INTERVAL_MS = 100;
+var CODEX_LSP_DAEMON_CLI_ENV = "CODEX_LSP_DAEMON_CLI";
 
 class DaemonUnreachableError extends Error {
   constructor(socketPath) {
@@ -1541,7 +1541,7 @@ function spawnDaemonProcess(paths) {
   mkdirSync2(dirname2(paths.log), { recursive: true });
   const logFd = openSync2(paths.log, "a");
   try {
-    const cliPath = fileURLToPath(new URL("./cli.js", import.meta.url));
+    const cliPath = resolveDaemonCliPath();
     const child = spawn2(execPath, [cliPath, "daemon"], {
       detached: true,
       stdio: ["ignore", logFd, logFd]
@@ -1551,6 +1551,12 @@ function spawnDaemonProcess(paths) {
     closeSync2(logFd);
   }
 }
+function resolveDaemonCliPath(env = process.env) {
+  const override = env[CODEX_LSP_DAEMON_CLI_ENV]?.trim();
+  if (override)
+    return override;
+  return fileURLToPath(new URL("./cli.js", import.meta.url));
+}
 function defaultEnsureDaemonDeps() {
   return {
     probe: (socketPath) => probeSocket(socketPath),
@@ -1561,14 +1567,14 @@ function defaultEnsureDaemonDeps() {
     },
     spawnDaemon: (paths) => spawnDaemonProcess(paths),
     sleep: (ms) => new Promise((resolve22) => {
-      const timer = setTimeout(resolve22, ms);
-      timer.unref?.();
+      setTimeout(resolve22, ms);
     }),
     now: () => Date.now()
   };
 }
 var requireFromHere = createRequire(import.meta.url);
 var MAX_SOCKET_PATH_LENGTH = 100;
+var CODEX_LSP_DAEMON_VERSION_ENV = "CODEX_LSP_DAEMON_VERSION";
 function resolveDaemonVersion(requireFn = requireFromHere) {
   for (const candidate of ["./package.json", "../package.json"]) {
     try {
@@ -1590,7 +1596,7 @@ function daemonBaseDir(env = process.env) {
   const home = codexHome && codexHome.length > 0 ? codexHome : join2(homedir(), ".codex");
   return join2(home, "codex-lsp", "daemon");
 }
-function daemonPaths(env = process.env, version = resolveDaemonVersion()) {
+function daemonPaths(env = process.env, version = resolveDaemonVersionFromEnv(env) ?? resolveDaemonVersion()) {
   const dir = join2(daemonBaseDir(env), `v${version}`);
   return {
     version,
@@ -1601,6 +1607,10 @@ function daemonPaths(env = process.env, version = resolveDaemonVersion()) {
     log: join2(dir, "daemon.log")
   };
 }
+function resolveDaemonVersionFromEnv(env = process.env) {
+  const version = env[CODEX_LSP_DAEMON_VERSION_ENV]?.trim();
+  return version && version.length > 0 ? version : null;
+}
 function resolveSocketPath(dir, version) {
   const digest = createHash("sha256").update(dir).digest("hex").slice(0, 16);
   if (process.platform === "win32") {
@@ -3322,12 +3332,68 @@ function errorText(error) {
 }
 
 // components/lsp/src/codex-hook.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
+
+// components/lsp/src/daemon-cli-path.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname6, join as join9 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+var requireFromHere2 = createRequire2(import.meta.url);
+var PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
+var CODEX_LSP_DAEMON_CLI_ENV2 = "CODEX_LSP_DAEMON_CLI";
+var CODEX_LSP_DAEMON_VERSION_ENV2 = "CODEX_LSP_DAEMON_VERSION";
+function ensureLspDaemonCliEnv(env = process.env) {
+  const configuredCli = env[CODEX_LSP_DAEMON_CLI_ENV2]?.trim();
+  const resolution = configuredCli ? resolveConfiguredLspDaemonCli(configuredCli) : resolveLspDaemonCli();
+  if (!configuredCli)
+    env[CODEX_LSP_DAEMON_CLI_ENV2] = resolution.cliPath;
+  if (!env[CODEX_LSP_DAEMON_VERSION_ENV2]?.trim() && resolution.version !== null) {
+    env[CODEX_LSP_DAEMON_VERSION_ENV2] = resolution.version;
+  }
+}
+function resolveLspDaemonCliPath() {
+  return resolveLspDaemonCli().cliPath;
+}
+function resolveLspDaemonCli() {
+  const packageCli = resolvePackageLspDaemonCliPath();
+  if (packageCli !== null)
+    return resolveConfiguredLspDaemonCli(packageCli);
+  const bundledCli = fileURLToPath4(new URL("../../lsp-daemon/dist/cli.js", import.meta.url));
+  if (existsSync9(bundledCli))
+    return resolveConfiguredLspDaemonCli(bundledCli);
+  return resolveConfiguredLspDaemonCli(bundledCli);
+}
+function resolvePackageLspDaemonCliPath() {
+  try {
+    return requireFromHere2.resolve(PACKAGE_LSP_DAEMON_CLI);
+  } catch {
+    return null;
+  }
+}
+function resolveConfiguredLspDaemonCli(cliPath) {
+  return {
+    cliPath,
+    version: readDaemonPackageVersion(cliPath)
+  };
+}
+function readDaemonPackageVersion(cliPath) {
+  try {
+    const parsed = JSON.parse(readFileSync6(join9(dirname6(cliPath), "package.json"), "utf8"));
+    if (isRecord4(parsed) && typeof parsed["version"] === "string" && parsed["version"].length > 0) {
+      return parsed["version"];
+    }
+  } catch {}
+  return null;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // components/lsp/src/lsp-session-state.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname6, extname as extname2, join as join9 } from "node:path";
+import { dirname as dirname8, extname as extname2, join as join11 } from "node:path";
 function sessionIdFrom(input) {
   return typeof input.session_id === "string" && input.session_id.length > 0 ? input.session_id : undefined;
 }
@@ -3374,23 +3440,23 @@ function isLspDaemonUnreachableDiagnostics(diagnostics) {
   return diagnostics.includes("LSP daemon unreachable");
 }
 function sessionStatePath(sessionId) {
-  const root = process.env["PLUGIN_DATA"] ?? join9(homedir4(), ".codex", "codex-lsp");
-  return join9(root, "sessions", `${safePathSegment(sessionId)}.json`);
+  const root = process.env["PLUGIN_DATA"] ?? join11(homedir4(), ".codex", "codex-lsp");
+  return join11(root, "sessions", `${safePathSegment(sessionId)}.json`);
 }
 function readSessionState(path) {
   try {
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     if (isLspSessionState(parsed))
       return parsed;
     return emptyState();
   } catch (error) {
-    if (error instanceof SyntaxError || isRecord4(error) && error["code"] === "ENOENT")
+    if (error instanceof SyntaxError || isRecord7(error) && error["code"] === "ENOENT")
       return emptyState();
     throw error;
   }
 }
 function writeSessionState(path, state) {
-  mkdirSync4(dirname6(path), { recursive: true });
+  mkdirSync4(dirname8(path), { recursive: true });
   writeFileSync3(path, `${JSON.stringify(state)}
 `);
 }
@@ -3405,12 +3471,12 @@ function safePathSegment(value) {
   return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
 }
 function isLspSessionState(value) {
-  if (!isRecord4(value) || !Array.isArray(value["unavailableExtensions"]))
+  if (!isRecord7(value) || !Array.isArray(value["unavailableExtensions"]))
     return false;
   const postCompactProbePending = value["postCompactProbePending"];
   return value["unavailableExtensions"].every((item) => typeof item === "string") && (postCompactProbePending === undefined || typeof postCompactProbePending === "boolean");
 }
-function isRecord4(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -3421,7 +3487,7 @@ function extractMutatedFilePaths(input) {
     return [];
   if (isFailedToolResponse(input.tool_response))
     return [];
-  const toolInput = isRecord7(input.tool_input) ? input.tool_input : {};
+  const toolInput = isRecord9(input.tool_input) ? input.tool_input : {};
   const paths = new Set;
   addStringValue(paths, toolInput["path"]);
   addStringValue(paths, toolInput["filePath"]);
@@ -3440,7 +3506,7 @@ function isMutationTool(value) {
   return MUTATION_TOOL_NAMES.has(value.toLowerCase());
 }
 function isFailedToolResponse(value) {
-  if (!isRecord7(value))
+  if (!isRecord9(value))
     return false;
   return value["isError"] === true || value["is_error"] === true || value["error"] === true || value["status"] === "error";
 }
@@ -3483,7 +3549,7 @@ function addPatchFiles(paths, value) {
   if (!Array.isArray(value))
     return;
   for (const item of value) {
-    if (!isRecord7(item))
+    if (!isRecord9(item))
       continue;
     addStringValue(paths, item["path"]);
     addStringValue(paths, item["filePath"]);
@@ -3492,7 +3558,7 @@ function addPatchFiles(paths, value) {
     addStringValue(paths, item["move_path"]);
   }
 }
-function isRecord7(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -3514,6 +3580,7 @@ var CONTEXT_PRESSURE_MARKERS = [
   "long threads and multiple compactions"
 ];
 async function runLspDiagnosticsText(filePath) {
+  ensureLspDaemonCliEnv();
   const result = await callDiagnosticsViaDaemon(filePath, { context: currentRequestContext() });
   return result.content.map((block) => block.text).join(`
 `);
@@ -3650,7 +3717,7 @@ function isContextPressureTranscript(transcriptPath) {
   if (typeof transcriptPath !== "string")
     return false;
   try {
-    return hasContextPressureMarker(readFileSync8(transcriptPath, "utf8"));
+    return hasContextPressureMarker(readFileSync9(transcriptPath, "utf8"));
   } catch (error) {
     if (error instanceof Error)
       return false;
@@ -3675,7 +3742,7 @@ function limitHookText(text2, maxChars) {
 function isCleanDiagnostics(diagnostics) {
   return diagnostics.length === 0 || diagnostics === CLEAN_DIAGNOSTICS_TEXT || diagnostics.startsWith(UNSUPPORTED_EXTENSION_TEXT);
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -3692,7 +3759,7 @@ async function runHookCli(runHook, stdin) {
     if (!raw.trim())
       return;
     const parsed = JSON.parse(raw);
-    const input = isRecord9(parsed) ? parsed : {};
+    const input = isRecord10(parsed) ? parsed : {};
     const output = await runHook(input);
     if (output)
       process.stdout.write(output);
@@ -3714,8 +3781,6 @@ async function readStdin(stdin) {
 }
 
 // components/lsp/src/cli.ts
-var require2 = createRequire2(import.meta.url);
-var PACKAGE_LSP_MCP_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
 async function main() {
   const [command = "mcp", subcommand = ""] = argv.slice(2);
   if (command === "hook" && subcommand === "post-tool-use") {
@@ -3740,7 +3805,7 @@ main().catch((error) => {
   process.exitCode = 1;
 });
 async function runPackageLspMcpCli() {
-  const cliPath = require2.resolve(PACKAGE_LSP_MCP_CLI);
+  const cliPath = resolveLspDaemonCliPath();
   const child = spawn3(execPath2, [cliPath, "mcp"], { stdio: "inherit" });
   await new Promise((resolve6, reject) => {
     child.once("error", reject);

package/packages/omo-codex/plugin/components/lsp/dist/codex-hook.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { callDiagnosticsViaDaemon, currentRequestContext } from "@code-yeongyu/lsp-daemon";
+import { ensureLspDaemonCliEnv } from "./daemon-cli-path.js";
 import { isLspDaemonUnreachableDiagnostics, isUnavailableLspDiagnostics, markLspSessionCompacted, recordLspDiagnosticsObservations, sessionIdFrom, shouldSkipUnavailableLspDiagnostics, } from "./lsp-session-state.js";
 import { extractMutatedFilePaths } from "./mutated-file-paths.js";
 export { extractMutatedFilePaths } from "./mutated-file-paths.js";
@@ -20,6 +21,7 @@ const CONTEXT_PRESSURE_MARKERS = [
     "long threads and multiple compactions",
 ];
 export async function runLspDiagnosticsText(filePath) {
+    ensureLspDaemonCliEnv();
     const result = await callDiagnosticsViaDaemon(filePath, { context: currentRequestContext() });
     return result.content.map((block) => block.text).join("\n");
 }

package/packages/omo-codex/plugin/components/lsp/dist/daemon-cli-path.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureLspDaemonCliEnv(env?: NodeJS.ProcessEnv): void;
+export declare function resolveLspDaemonCliPath(): string;