oh-my-opencode 4.12.1 → 4.14.0

package/packages/omo-codex/plugin/components/codegraph/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-codegraph",
-	"version": "4.12.1",
+	"version": "4.14.0",
 	"description": "Codex plugin MCP wrapper for CodeGraph.",
 	"type": "module",
 	"private": true,
@@ -8,11 +8,14 @@
 		"omo-codegraph": "./dist/cli.js"
 	},
 	"files": [
-		"dist"
+		"dist",
+		"LICENSE",
+		"NODE-RUNTIME-LICENSES.md",
+		"NOTICE"
 	],
 	"scripts": {
-		"build": "bun build src/serve.ts --target node --format esm --outfile dist/serve.js && bun build src/cli.ts --target node --format esm --outfile dist/cli.js",
-		"test": "bun test test/*.test.ts",
+		"build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && bun build src/serve.ts --target node --format esm --outfile dist/serve.js && bun build src/cli.ts --target node --format esm --outfile dist/cli.js",
+		"test": "bun test ./test",
 		"typecheck": "tsc --noEmit"
 	},
 	"devDependencies": {
@@ -21,6 +24,9 @@
 		"bun-types": "^1.3.1",
 		"typescript": "^6.0.3"
 	},
+	"optionalDependencies": {
+		"@colbymchenry/codegraph": "1.0.1"
+	},
 	"engines": {
 		"node": ">=20.0.0"
 	}

package/packages/omo-codex/plugin/components/codegraph/src/hook-types.ts

@@ -9,7 +9,7 @@ import type {
 import type { CodegraphWorkspacePreparation as SharedCodegraphWorkspacePreparation } from "../../../../../utils/src/codegraph/workspace.ts";
 import type { CodegraphConfig as SharedCodegraphConfig } from "../../../../../utils/src/omo-config.ts";
 
-export type SessionStartAction = "skipped-disabled" | "spawned";
+export type SessionStartAction = "skipped-disabled" | "skipped-initialized" | "spawned";
 export type PostToolUseAction = "emitted-guidance" | "skipped";
 export type WorkerAction = "failed" | "initialized" | "skipped-disabled" | "skipped-status" | "skipped-unavailable" | "skipped-unsupported-node" | "synced";
 
@@ -74,6 +74,12 @@ export interface SessionStartHookOptions {
 	readonly cwd?: string;
 	readonly env?: Record<string, string | undefined>;
 	readonly spawnWorker?: (invocation: WorkerSpawnInvocation) => void;
+	readonly statusProbe?: (options: {
+		readonly env: Record<string, string | undefined>;
+		readonly homeDir: string;
+		readonly projectRoot: string;
+		readonly trustedCodegraphInstallDir?: string;
+	}) => Promise<boolean>;
 	readonly stdin?: Readable & { readonly isTTY?: boolean };
 	readonly stdout?: HookStdout;
 	readonly workerCliPath?: string;

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

@@ -1,12 +1,15 @@
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { homedir } from "node:os";
+import { join } from "node:path";
 import { cwd as processCwd, env as processEnv, stdin as processStdin, stdout as processStdout } from "node:process";
 import type { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
+import { buildCodegraphChildEnv, buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
 import { buildCodegraphInitGuidanceForToolResult } from "../../../../../utils/src/codegraph/guidance.ts";
+import { resolveCodegraphCommand } from "../../../../../utils/src/codegraph/resolve.ts";
 import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
-import { SESSION_START_CWD_ENV } from "./session-start-worker.js";
+import { resolveCodegraphCommandInvocation, SESSION_START_CWD_ENV } from "./session-start-worker.js";
 import type {
 	HookStdout,
 	PostToolUseHookOptions,
@@ -38,6 +41,7 @@ export type {
 export { resolveCodegraphCommandInvocation, runCodegraphSessionStartWorker } from "./session-start-worker.js";
 
 export const CODEGRAPH_SESSION_START_NOTICE = "LazyCodex CodeGraph bootstrap scheduled in background";
+const STATUS_PROBE_TIMEOUT_MS = 2_000;
 
 export async function runCodegraphSessionStartHook(options: SessionStartHookOptions = {}): Promise<number> {
 	return (await executeCodegraphSessionStartHook(options)).exitCode;
@@ -58,15 +62,102 @@ export async function executeCodegraphSessionStartHook(options: SessionStartHook
 		return { action: "skipped-disabled", exitCode: 0 };
 	}
 
+	const isInitialized = await (options.statusProbe ?? isCodegraphProjectInitialized)({
+		env,
+		homeDir,
+		projectRoot,
+		...(config.trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir: config.trustedCodegraphInstallDir }),
+	});
+	if (isInitialized) {
+		return { action: "skipped-initialized", exitCode: 0 };
+	}
+
 	(options.spawnWorker ?? spawnDetachedWorker)({
 		args: [options.workerCliPath ?? defaultWorkerCliPath(), "hook", "session-start-worker"],
 		command: process.execPath,
-		env: { ...env, [SESSION_START_CWD_ENV]: projectRoot },
+		env: buildCodegraphChildEnv({
+			ambientEnv: env,
+			codegraphEnv: { [SESSION_START_CWD_ENV]: projectRoot },
+			runtimeEnv: env,
+		}),
 	});
 	writeHookJson(options.stdout ?? processStdout);
 	return { action: "spawned", exitCode: 0 };
 }
 
+async function isCodegraphProjectInitialized(options: {
+	readonly env: Record<string, string | undefined>;
+	readonly homeDir: string;
+	readonly projectRoot: string;
+	readonly trustedCodegraphInstallDir?: string;
+}): Promise<boolean> {
+	const resolved = resolveCodegraphCommand({
+		env: options.env,
+		homeDir: options.homeDir,
+		provisioned: () => provisionedBinFromInstallDir(options.trustedCodegraphInstallDir),
+	});
+	if (!resolved.exists) return false;
+
+	const invocation = resolveCodegraphCommandInvocation(resolved.command, [...resolved.argsPrefix, "status", "--json"]);
+	const codegraphEnv = {
+		...buildCodegraphEnv({ homeDir: options.homeDir }),
+		...(options.trustedCodegraphInstallDir === undefined ? {} : { CODEGRAPH_INSTALL_DIR: options.trustedCodegraphInstallDir }),
+	};
+	const status = await runStatusProbe(
+		options.projectRoot,
+		invocation.command,
+		invocation.args,
+		buildCodegraphChildEnv({ ambientEnv: options.env, codegraphEnv, runtimeEnv: options.env }),
+	);
+	if (status.exitCode !== 0 || status.timedOut) return false;
+	return codegraphStatusSaysInitialized(status.stdout);
+}
+
+function runStatusProbe(
+	projectRoot: string,
+	command: string,
+	args: readonly string[],
+	env: Record<string, string>,
+): Promise<{ readonly exitCode: number; readonly stdout: string; readonly timedOut: boolean }> {
+	return new Promise((resolveProbe) => {
+		execFile(
+			command,
+			[...args],
+			{
+				cwd: projectRoot,
+				encoding: "utf8",
+				env,
+				maxBuffer: 1024 * 1024,
+				timeout: STATUS_PROBE_TIMEOUT_MS,
+				windowsHide: true,
+			},
+			(error, stdout) => {
+				if (error === null) {
+					resolveProbe({ exitCode: 0, stdout: toOutputText(stdout), timedOut: false });
+					return;
+				}
+				resolveProbe({ exitCode: resolveExitCode(error), stdout: toOutputText(stdout), timedOut: error.killed === true });
+			},
+		);
+	});
+}
+
+function codegraphStatusSaysInitialized(stdout: string): boolean {
+	const parsed = parseJson(stdout);
+	if (!isRecord(parsed)) return false;
+	const initialized = parsed["initialized"] ?? parsed["isInitialized"] ?? parsed["ready"];
+	if (typeof initialized === "boolean") return initialized;
+	const status = parsed["status"];
+	if (typeof status !== "string") return false;
+	const normalized = status.toLowerCase();
+	return (normalized.includes("initialized") || normalized.includes("ready")) && !normalized.includes("not initialized") && !normalized.includes("uninitialized");
+}
+
+function provisionedBinFromInstallDir(installDir: string | undefined): string | null {
+	if (installDir === undefined) return null;
+	return join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
+}
+
 export async function executeCodegraphPostToolUseHook(options: PostToolUseHookOptions = {}): Promise<PostToolUseHookResult> {
 	const env = options.env ?? processEnv;
 	const input = await readHookInput(options.stdin ?? processStdin);
@@ -111,6 +202,15 @@ function resolveHomeDir(env: Record<string, string | undefined>): string {
 	return env["HOME"] ?? env["USERPROFILE"] ?? homedir();
 }
 
+function resolveExitCode(error: Error): number {
+	if ("code" in error && typeof error.code === "number") return error.code;
+	return 1;
+}
+
+function toOutputText(value: string | Buffer): string {
+	return Buffer.isBuffer(value) ? value.toString("utf8") : value;
+}
+
 function resolveProjectRoot(input: unknown, fallback: string): string {
 	if (!isRecord(input)) return fallback;
 	const cwd = input["cwd"];

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

@@ -0,0 +1,114 @@
+import { spawn } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+
+import {
+	errorResponse,
+	isPlainRecord,
+	jsonRpcId,
+	readStdioJsonRpcMessages,
+	writeStdioJsonRpcResponse,
+	type StdioJsonRpcResponseMode,
+} from "../../../../../mcp-stdio-core/src/index.ts";
+import type { CodegraphServeProcessOptions } from "./serve.js";
+import { resolveServeProcessInvocation } from "./serve-invocation.js";
+
+class CodegraphBridgeStdioError extends Error {
+	override readonly name = "CodegraphBridgeStdioError";
+
+	constructor(readonly streamName: string) {
+		super(`CodeGraph MCP bridge missing child ${streamName}`);
+	}
+}
+
+export async function runBridgedCodegraphProcess(
+	command: string,
+	args: readonly string[],
+	options: CodegraphServeProcessOptions,
+): Promise<number> {
+	const invocation = resolveServeProcessInvocation(command, args);
+	const child = spawn(invocation.command, invocation.args, {
+		cwd: options.cwd,
+		env: options.env,
+		stdio: ["pipe", "pipe", "inherit"],
+	});
+	const childInput = child.stdin;
+	const childOutput = child.stdout;
+	if (childInput === null) throw new CodegraphBridgeStdioError("stdin");
+	if (childOutput === null) throw new CodegraphBridgeStdioError("stdout");
+
+	const responseModes = new Map<string, StdioJsonRpcResponseMode>();
+	let defaultResponseMode: StdioJsonRpcResponseMode = "framed";
+	const childExit = new Promise<number>((resolveExit, reject) => {
+		child.once("error", reject);
+		child.once("exit", (code, signal) => {
+			if (code !== null) {
+				resolveExit(code);
+				return;
+			}
+			resolveExit(signal === null ? 0 : 1);
+		});
+	});
+	const bridgeDone = Promise.all([
+		forwardClientToCodegraph(options.input, childInput, responseModes, (mode) => {
+			defaultResponseMode = mode;
+		}),
+		forwardCodegraphToClient(childOutput, options.output, responseModes, () => defaultResponseMode),
+	]);
+	const destroyChildPipes = (): void => {
+		childInput.destroy();
+		childOutput.destroy();
+	};
+	void childExit.then(destroyChildPipes, destroyChildPipes);
+	return Promise.race([childExit, bridgeDone.then(() => childExit)]);
+}
+
+async function forwardClientToCodegraph(
+	input: Readable,
+	childInput: Writable,
+	responseModes: Map<string, StdioJsonRpcResponseMode>,
+	setDefaultResponseMode: (mode: StdioJsonRpcResponseMode) => void,
+): Promise<void> {
+	for await (const message of readStdioJsonRpcMessages(input)) {
+		if (message.kind === "parse_error") {
+			continue;
+		}
+		const responseMode = message.responseMode;
+		setDefaultResponseMode(responseMode);
+		const key = responseModeKey(message.payload);
+		if (key !== null) responseModes.set(key, responseMode);
+		await writeLine(childInput, JSON.stringify(message.payload));
+	}
+	childInput.end();
+}
+
+async function forwardCodegraphToClient(
+	childOutput: Readable,
+	output: Writable,
+	responseModes: Map<string, StdioJsonRpcResponseMode>,
+	defaultResponseMode: () => StdioJsonRpcResponseMode,
+): Promise<void> {
+	for await (const message of readStdioJsonRpcMessages(childOutput)) {
+		if (message.kind === "parse_error") {
+			writeStdioJsonRpcResponse(output, errorResponse(null, -32700, "Parse error", message.message), defaultResponseMode());
+			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);
+	}
+}
+
+function responseModeKey(payload: unknown): string | null {
+	if (!isPlainRecord(payload) || !("id" in payload)) return null;
+	const id = jsonRpcId(payload["id"]);
+	return `${typeof id}:${String(id)}`;
+}
+
+async function writeLine(output: Writable, line: string): Promise<void> {
+	if (output.write(`${line}\n`)) return;
+	await new Promise<void>((resolveDrain, reject) => {
+		output.once("drain", resolveDrain);
+		output.once("error", reject);
+	});
+}

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

@@ -0,0 +1,75 @@
+import type { Readable, Writable } from "node:stream";
+
+import {
+	errorResponse,
+	isPlainRecord,
+	jsonRpcId,
+	runJsonRpcStdioServer,
+	successResponse,
+	type JsonRpcResponse,
+} from "../../../../../mcp-stdio-core/src/index.ts";
+
+export interface UnavailableCodegraphMcpOptions {
+	readonly input: Readable;
+	readonly output: Writable;
+	readonly reason: string;
+	readonly serverVersion: string;
+}
+
+interface UnavailableCodegraphMcpHandlerOptions {
+	readonly reason: string;
+	readonly serverVersion: string;
+}
+
+export async function runUnavailableCodegraphMcpServer(
+	options: UnavailableCodegraphMcpOptions,
+): Promise<void> {
+	await runJsonRpcStdioServer({
+		handler: handleUnavailableCodegraphMcpRequest,
+		handlerOptions: {
+			reason: options.reason.trim(),
+			serverVersion: options.serverVersion,
+		},
+		input: options.input,
+		output: options.output,
+	});
+}
+
+async function handleUnavailableCodegraphMcpRequest(
+	input: unknown,
+	options: UnavailableCodegraphMcpHandlerOptions,
+): Promise<JsonRpcResponse | undefined> {
+	if (!isPlainRecord(input)) {
+		return errorResponse(null, -32600, "Invalid Request");
+	}
+
+	const id = jsonRpcId(input["id"]);
+	const method = input["method"];
+	if (method === "notifications/initialized") return undefined;
+	if (method === "ping") return successResponse(id, {});
+	if (method === "initialize") {
+		return successResponse(id, {
+			capabilities: { tools: { listChanged: false } },
+			protocolVersion: requestedProtocolVersion(input["params"]),
+			serverInfo: { name: "codegraph", version: options.serverVersion },
+		});
+	}
+
+	if (method === "tools/list") {
+		return successResponse(id, { tools: [] });
+	}
+
+	if (method === "tools/call") {
+		return successResponse(id, {
+			content: [{ text: options.reason, type: "text" }],
+			isError: true,
+		});
+	}
+
+	return errorResponse(id, -32601, `Method not found: ${String(method)}`);
+}
+
+function requestedProtocolVersion(params: unknown): string {
+	if (!isPlainRecord(params) || typeof params["protocolVersion"] !== "string") return "2024-11-05";
+	return params["protocolVersion"];
+}

package/packages/omo-codex/plugin/components/codegraph/src/serve-invocation.ts

@@ -0,0 +1,29 @@
+import { extname } from "node:path";
+import { execPath as processExecPath } from "node:process";
+
+export interface ServeProcessInvocation {
+	readonly args: readonly string[];
+	readonly command: string;
+}
+
+const WINDOWS_CMD_EXTENSIONS = new Set([".bat", ".cmd"]);
+const WINDOWS_NODE_SCRIPT_EXTENSIONS = new Set([".cjs", ".js", ".mjs"]);
+
+export function resolveServeProcessInvocation(
+	command: string,
+	args: readonly string[],
+	platform: NodeJS.Platform = process.platform,
+): ServeProcessInvocation {
+	if (platform !== "win32") return { args: [...args], command };
+
+	const extension = extname(command).toLowerCase();
+	if (WINDOWS_NODE_SCRIPT_EXTENSIONS.has(extension)) {
+		return { args: [command, ...args], command: processExecPath };
+	}
+
+	if (WINDOWS_CMD_EXTENSIONS.has(extension)) {
+		return { args: ["/d", "/s", "/c", command, ...args], command: "cmd.exe" };
+	}
+
+	return { args: [...args], command };
+}

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

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, extname, join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import {
 	cwd as processCwd,
 	env as processEnv,
-	execPath as processExecPath,
+	stdin as processStdin,
 	stderr as processStderr,
+	stdout as processStdout,
 } from "node:process";
+import type { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
-import { buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
+import { buildCodegraphChildEnv, buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
 import {
 	buildCodegraphNodeSkipHint,
 	evaluateCodegraphNodeSupport,
@@ -28,11 +29,19 @@ import {
 } from "../../../../../utils/src/codegraph/resolve.ts";
 import { getCodexOmoConfig, type CodexOmoConfig } from "../../../shared/src/config-loader.ts";
 import type { CodegraphConfig } from "./hook.js";
+import { runBridgedCodegraphProcess } from "./mcp-bridge.js";
+import { runUnavailableCodegraphMcpServer } from "./mcp-unavailable.js";
+import { SESSION_START_CWD_ENV } from "./session-start-worker.js";
+export { resolveServeProcessInvocation } from "./serve-invocation.js";
 
-export type ServeStdio = "inherit";
+export type ServeStdio = "pipe";
 
 export interface CodegraphServeProcessOptions {
+	readonly cwd: string;
 	readonly env: Record<string, string | undefined>;
+	readonly input: Readable;
+	readonly output: Writable;
+	readonly stderr: CodegraphServeStderr;
 	readonly stdio: ServeStdio;
 }
 
@@ -45,11 +54,6 @@ export type CodegraphProvisioner = (
 	options: EnsureCodegraphProvisionedOptions,
 ) => ReturnType<typeof ensureCodegraphProvisioned>;
 
-export interface ServeProcessInvocation {
-	readonly args: readonly string[];
-	readonly command: string;
-}
-
 export interface CodegraphServeStderr {
 	readonly write: (chunk: string) => void;
 }
@@ -61,6 +65,8 @@ export interface RunCodegraphServeOptions {
 	readonly cwd?: string;
 	readonly env?: Record<string, string | undefined>;
 	readonly homeDir?: string;
+	readonly stdin?: Readable;
+	readonly stdout?: Writable;
 	readonly nodeVersion?: string;
 	readonly resolve?: (options: ResolveCodegraphCommandOptions) => ReturnType<typeof resolveCodegraphCommand>;
 	readonly runProcess?: CodegraphServeProcessRunner;
@@ -73,59 +79,70 @@ const CODEGRAPH_SKIP_HINT =
 const CODEGRAPH_DISABLED_HINT =
 	"CodeGraph MCP skipped: disabled by OMO SOT config. Set [codex].codegraph.enabled=true to enable it.\n";
 const CODEGRAPH_VERSION = "1.0.1";
-const WINDOWS_CMD_EXTENSIONS = new Set([".bat", ".cmd"]);
-const WINDOWS_NODE_SCRIPT_EXTENSIONS = new Set([".cjs", ".js", ".mjs"]);
+const PROJECT_CWD_ENV_KEYS = ["OMO_CODEGRAPH_PROJECT_CWD", SESSION_START_CWD_ENV, "PWD"] as const;
 
 export async function runCodegraphServe(options: RunCodegraphServeOptions = {}): Promise<number> {
 	const env = options.env ?? processEnv;
 	const homeDir = options.homeDir ?? homedir();
-	const config = options.config ?? getCodexOmoConfig({ cwd: options.cwd ?? processCwd(), env, homeDir });
+	const wrapperCwd = options.cwd ?? processCwd();
+	const projectCwd = resolveProjectCwd(env, wrapperCwd);
+	const config = options.config ?? getCodexOmoConfig({ cwd: projectCwd, env, homeDir });
 	const codegraphConfig = config.codegraph ?? {};
 	if (codegraphConfig.enabled === false) {
-		(options.stderr ?? processStderr).write(CODEGRAPH_DISABLED_HINT);
-		return 1;
+		return runUnavailableMcp(CODEGRAPH_DISABLED_HINT, options);
 	}
 
+	const trustedInstallDir = config.trustedCodegraphInstallDir;
 	const resolutionOptions = {
 		env,
 		homeDir,
-		provisioned: () => provisionedBinFromInstallDir(codegraphConfig.install_dir),
+		provisioned: () => provisionedBinFromInstallDir(trustedInstallDir),
 	} satisfies ResolveCodegraphCommandOptions;
 	let resolution = options.resolve?.(resolutionOptions) ?? resolveCodegraphCommand(resolutionOptions);
 	const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
 	if (!resolution.exists || shouldSkipResolvedCommand(resolution, options.commandExists ?? existsSync)) {
 		if (resolution.source === "path" && !nodeSupport.supported) {
-			(options.stderr ?? processStderr).write(buildCodegraphNodeSkipHint(nodeSupport));
-			return 1;
+			return runUnavailableMcp(buildCodegraphNodeSkipHint(nodeSupport), options);
 		}
 		const provisioned = await provisionMissingCodegraph({
 			config: codegraphConfig,
 			ensureProvisioned: options.ensureProvisioned ?? ensureCodegraphProvisioned,
 			homeDir,
 			resolution,
+			...(trustedInstallDir === undefined ? {} : { trustedInstallDir }),
 		});
 		if (provisioned === null) {
-			(options.stderr ?? processStderr).write(CODEGRAPH_SKIP_HINT);
-			return 1;
+			return runUnavailableMcp(CODEGRAPH_SKIP_HINT, options);
 		}
 		resolution = provisioned;
 	}
 
 	if (codegraphCommandRequiresSupportedLocalNode(resolution) && !nodeSupport.supported) {
-		(options.stderr ?? processStderr).write(buildCodegraphNodeSkipHint(nodeSupport));
-		return 1;
+		return runUnavailableMcp(buildCodegraphNodeSkipHint(nodeSupport), options);
 	}
 
-	const runProcess = options.runProcess ?? runChildProcess;
-	const codegraphEnv = codegraphEnvForConfig(codegraphConfig, homeDir, options.buildEnv);
-	const mergedEnv = {
-		...env,
-		...codegraphEnv,
-	};
+	const runProcess = options.runProcess ?? runBridgedCodegraphProcess;
+	const codegraphEnv = codegraphEnvForConfig(trustedInstallDir, homeDir, options.buildEnv);
+	const mergedEnv = buildCodegraphChildEnv({ ambientEnv: env, codegraphEnv, runtimeEnv: env });
 	return runProcess(resolution.command, [...resolution.argsPrefix, "serve", "--mcp"], {
+		cwd: projectCwd,
 		env: mergedEnv,
-		stdio: "inherit",
+		input: options.stdin ?? processStdin,
+		output: options.stdout ?? processStdout,
+		stderr: options.stderr ?? processStderr,
+		stdio: "pipe",
+	});
+}
+
+async function runUnavailableMcp(reason: string, options: RunCodegraphServeOptions): Promise<number> {
+	(options.stderr ?? processStderr).write(reason);
+	await runUnavailableCodegraphMcpServer({
+		input: options.stdin ?? processStdin,
+		output: options.stdout ?? processStdout,
+		reason,
+		serverVersion: CODEGRAPH_VERSION,
 	});
+	return 0;
 }
 
 async function provisionMissingCodegraph(options: {
@@ -133,11 +150,12 @@ async function provisionMissingCodegraph(options: {
 	readonly ensureProvisioned: CodegraphProvisioner;
 	readonly homeDir: string;
 	readonly resolution: CodegraphCommandResolution;
+	readonly trustedInstallDir?: string;
 }): Promise<CodegraphCommandResolution | null> {
 	if (options.resolution.source === "env") return null;
 	if (options.config.auto_provision === false) return null;
 
-	const installDir = options.config.install_dir ?? join(options.homeDir, ".omo", "codegraph");
+	const installDir = options.trustedInstallDir ?? join(options.homeDir, ".omo", "codegraph");
 	const result = await options.ensureProvisioned({
 		installDir,
 		lockDir: join(installDir, ".locks"),
@@ -161,12 +179,22 @@ function looksLikePath(command: string): boolean {
 }
 
 function codegraphEnvForConfig(
-	config: CodegraphConfig,
+	trustedInstallDir: string | undefined,
 	homeDir: string,
 	buildEnv: ((options: { readonly homeDir: string }) => Record<string, string>) | undefined,
 ): Record<string, string> {
 	const env = buildEnv?.({ homeDir }) ?? buildCodegraphEnv({ homeDir });
-	return config.install_dir === undefined ? env : { ...env, CODEGRAPH_INSTALL_DIR: config.install_dir };
+	return trustedInstallDir === undefined ? env : { ...env, CODEGRAPH_INSTALL_DIR: trustedInstallDir };
+}
+
+function resolveProjectCwd(env: Record<string, string | undefined>, fallback: string): string {
+	for (const key of PROJECT_CWD_ENV_KEYS) {
+		const candidate = env[key]?.trim();
+		if (candidate === undefined || candidate.length === 0) continue;
+		const resolved = resolve(candidate);
+		if (existsSync(resolved)) return resolved;
+	}
+	return resolve(fallback);
 }
 
 function provisionedBinFromInstallDir(installDir: string | undefined): string | null {
@@ -179,44 +207,6 @@ export async function runCodegraphServeCli(): Promise<void> {
 	process.exitCode = await runCodegraphServe();
 }
 
-async function runChildProcess(
-	command: string,
-	args: readonly string[],
-	options: CodegraphServeProcessOptions,
-): Promise<number> {
-	const invocation = resolveServeProcessInvocation(command, args);
-	const child = spawn(invocation.command, invocation.args, { env: options.env, stdio: options.stdio });
-	return new Promise<number>((resolve, reject) => {
-		child.once("error", reject);
-		child.once("exit", (code, signal) => {
-			if (code !== null) {
-				resolve(code);
-				return;
-			}
-			resolve(signal === null ? 0 : 1);
-		});
-	});
-}
-
-export function resolveServeProcessInvocation(
-	command: string,
-	args: readonly string[],
-	platform: NodeJS.Platform = process.platform,
-): ServeProcessInvocation {
-	if (platform !== "win32") return { args: [...args], command };
-
-	const extension = extname(command).toLowerCase();
-	if (WINDOWS_NODE_SCRIPT_EXTENSIONS.has(extension)) {
-		return { args: [command, ...args], command: processExecPath };
-	}
-
-	if (WINDOWS_CMD_EXTENSIONS.has(extension)) {
-		return { args: ["/d", "/s", "/c", command, ...args], command: "cmd.exe" };
-	}
-
-	return { args: [...args], command };
-}
-
 if (isDirectInvocation(process.argv[1])) {
 	runCodegraphServeCli().catch((error: unknown) => {
 		processStderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);