oh-my-opencode 4.12.0 → 4.13.0

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { Readable } from "node:stream";
@@ -8,8 +8,7 @@ import { fileURLToPath } from "node:url";
 import { runCodegraphCli } from "../src/cli.ts";
 import {
 	executeCodegraphSessionStartHook,
-	resolveCodegraphCommandInvocation,
-	runCodegraphSessionStartWorker,
+	runCodegraphPostToolUseHook,
 	type WorkerSpawnInvocation,
 } from "../src/hook.ts";
 
@@ -48,6 +47,54 @@ describe("CodeGraph SessionStart hook", () => {
 		}
 	});
 
+	it("#given CodeGraph MCP reports an uninitialized project #when PostToolUse fires #then it emits OMO global-store init guidance", async () => {
+		// given
+		const output = runCodegraphPostToolUseHook(
+			{
+				cwd: "/Users/me/project",
+				tool_name: "codegraph.codegraph_status",
+				tool_response: {
+					error: [
+						"Tool execution failed: CodeGraph not initialized in /Users/me/project.",
+						"Run 'codegraph init' in that project first.",
+					].join(" "),
+				},
+			},
+			{ homeDir: "/Users/me" },
+		);
+
+		// when
+		const parsed = JSON.parse(output);
+
+		// then
+		expect(parsed).toEqual({
+			hookSpecificOutput: {
+				hookEventName: "PostToolUse",
+				additionalContext: expect.stringContaining('"/Users/me/.omo/codegraph/projects/project-'),
+			},
+		});
+		expect(parsed.hookSpecificOutput.additionalContext).toContain('run `codegraph init` from "/Users/me/project"');
+	});
+
+	it("#given real CodeGraph status output has no MCP path phrase #when PostToolUse fires #then it emits OMO global-store init guidance", async () => {
+		// given
+		const output = runCodegraphPostToolUseHook(
+			{
+				cwd: "/Users/me/project",
+				tool_name: "mcp__codegraph__codegraph_status",
+				tool_response: ['Project: /Users/me/project', "Not initialized", 'Run "codegraph init" to initialize'].join("\n"),
+			},
+			{ homeDir: "/Users/me" },
+		);
+
+		// when
+		const parsed = JSON.parse(output);
+
+		// then
+		expect(parsed.hookSpecificOutput.additionalContext).toContain('CodeGraph is not initialized for "/Users/me/project"');
+		expect(parsed.hookSpecificOutput.additionalContext).toContain('"/Users/me/.omo/codegraph/projects/project-');
+	});
+
 	it("#given CodeGraph is disabled by Codex SOT config #when SessionStart fires #then it skips without spawning", async () => {
 		// given
 		const stdout: string[] = [];
@@ -198,323 +245,6 @@ describe("CodeGraph SessionStart hook", () => {
 		}
 	});
 
-	it("#given an unsupported local Node and a PATH CodeGraph command #when worker runs #then it skips without touching the workspace", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-home-"));
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				nodeVersion: "26.3.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					resolveCommand: () => {
-						return { argsPrefix: [], command: "/usr/local/bin/codegraph", exists: true, source: "path" };
-					},
-					ensureProvisioned: () => {
-						throw new Error("ensureProvisioned should not run on unsupported Node");
-					},
-					prepareWorkspace: () => {
-						throw new Error("prepareWorkspace should not run on unsupported Node");
-					},
-					runCommand: () => {
-						throw new Error("runCommand should not run on unsupported Node");
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-unsupported-node" });
-			expect(existsSync(join(workspace, ".codegraph"))).toBe(false);
-			expect(outcomes).toEqual([{ action: "skipped-unsupported-node", projectRoot: workspace }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given an unsupported local Node but bundled CodeGraph resolves through CODEGRAPH_NODE_BIN #when worker runs #then it bootstraps with the compatible runtime", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-home-"));
-		const nodeBin = "/opt/node22/bin/node";
-		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { CODEGRAPH_NODE_BIN: nodeBin, HOME: homeDir },
-				nodeVersion: "26.3.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => {
-						throw new Error("provisioning should not run when bundled CodeGraph resolved");
-					},
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: ["codegraph.js"], command: nodeBin, exists: true, source: "bundled" }),
-					runCommand: (_projectRoot, command, args) => {
-						calls.push({ args, command });
-						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls).toEqual([
-				{ args: ["codegraph.js", "status", "--json"], command: nodeBin },
-				{ args: ["codegraph.js", "init"], command: nodeBin },
-			]);
-			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "bundled", timedOut: false }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given CodeGraph cannot be resolved or provisioned #when worker runs #then it logs a graceful skip", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-home-"));
-		const outcomes: unknown[] = [];
-		const calls: string[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				nodeVersion: "22.14.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => {
-						calls.push("ensureGitignored");
-						return true;
-					},
-					ensureProvisioned: () => Promise.resolve({ error: "offline", provisioned: false }),
-					prepareWorkspace: () => {
-						calls.push("prepareWorkspace");
-						return {
-							dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-							dataRoot: join(homeDir, ".omo/codegraph"),
-							linked: true,
-							mode: "global-linked",
-							projectLink: join(workspace, ".codegraph"),
-						};
-					},
-					resolveCommand: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
-					runCommand: () => {
-						calls.push("runCommand");
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-unavailable" });
-			expect(calls).toEqual([]);
-			expect(outcomes).toEqual([
-				{
-					action: "skipped-unavailable",
-					error: "offline",
-					projectRoot: workspace,
-					source: "path",
-				},
-			]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given CodeGraph is unavailable and auto provisioning is disabled #when worker runs #then it leaves the project untouched", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-unavailable-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-unavailable-home-"));
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
-				nodeVersion: "22.14.0",
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureProvisioned: () => {
-						throw new Error("auto provision should not run");
-					},
-					resolveCommand: () => ({ argsPrefix: [], command: "missing-codegraph", exists: false, source: "path" }),
-					runCommand: () => {
-						throw new Error("codegraph command should not run");
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-unavailable" });
-			expect(existsSync(join(workspace, ".codegraph"))).toBe(false);
-			expect(existsSync(join(workspace, ".git", "info", "exclude"))).toBe(false);
-			expect(outcomes).toEqual([
-				{
-					action: "skipped-unavailable",
-					error: "codegraph binary unavailable and auto_provision is disabled",
-					projectRoot: workspace,
-					source: "path",
-				},
-			]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given Windows install_dir has codegraph.cmd #when worker resolves provisioned CodeGraph #then it uses the cmd shim", async () => {
-		await withProcessPlatform("win32", async () => {
-			// given
-			const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-win32-"));
-			const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-win32-home-"));
-			const installDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-win32-install-"));
-			const binPath = join(installDir, "bin", "codegraph.cmd");
-			const calls: { readonly args: readonly string[]; readonly command: string; readonly env: Record<string, string> }[] = [];
-			const outcomes: unknown[] = [];
-			try {
-				mkdirSync(join(installDir, "bin"), { recursive: true });
-				writeFileSync(binPath, "");
-
-				// when
-				const result = await runCodegraphSessionStartWorker({
-					config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], warnings: [] },
-					nodeVersion: "22.14.0",
-					cwd: workspace,
-					env: { HOME: homeDir },
-					logOutcome: (outcome) => outcomes.push(outcome),
-					deps: {
-						ensureGitignored: () => true,
-						ensureProvisioned: () => {
-							throw new Error("provisioning should not run when install_dir binary exists");
-						},
-						prepareWorkspace: () => ({
-							dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-							dataRoot: join(homeDir, ".omo/codegraph"),
-							linked: true,
-							mode: "global-linked",
-							projectLink: join(workspace, ".codegraph"),
-						}),
-						resolveCommand: (options) => {
-							const provisioned = options?.provisioned?.() ?? null;
-							return { argsPrefix: [], command: provisioned ?? "missing-codegraph", exists: provisioned !== null, source: provisioned === null ? "path" : "provisioned" };
-						},
-						runCommand: (_projectRoot, command, args, options) => {
-							calls.push({ args, command, env: options.env });
-							return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
-						},
-					},
-				});
-
-				// then
-				expect(result).toEqual({ action: "initialized" });
-				expect(calls.map((call) => ({ args: [...call.args], command: call.command }))).toEqual([
-					{ args: ["status", "--json"], command: binPath },
-					{ args: ["init"], command: binPath },
-				]);
-				expect(calls[0]?.env["CODEGRAPH_INSTALL_DIR"]).toBe(installDir);
-				expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
-			} finally {
-				rmSync(workspace, { recursive: true, force: true });
-				rmSync(homeDir, { recursive: true, force: true });
-				rmSync(installDir, { recursive: true, force: true });
-			}
-		});
-	});
-
-	it("#given Windows codegraph.cmd #when default worker runner builds invocation #then it runs through cmd.exe", () => {
-		// given
-		const command = "C:\\Users\\test\\.omo\\codegraph\\bin\\codegraph.cmd";
-
-		// when
-		const invocation = resolveCodegraphCommandInvocation(command, ["status", "--json"], "win32");
-
-		// then
-		expect(invocation).toEqual({
-			args: ["/d", "/s", "/c", command, "status", "--json"],
-			command: "cmd.exe",
-		});
-	});
-
-	it("#given non-Windows codegraph command #when default worker runner builds invocation #then it executes directly", () => {
-		// given
-		const command = "/home/test/.omo/codegraph/bin/codegraph";
-
-		// when
-		const invocation = resolveCodegraphCommandInvocation(command, ["sync"], "linux");
-
-		// then
-		expect(invocation).toEqual({ args: ["sync"], command });
-	});
-
-	it("#given resolved CodeGraph status #when worker runs #then it runs status before init or sync", async () => {
-		for (const scenario of [
-			{ action: "initialized", args: [["status", "--json"], ["init"]], stdout: '{"initialized":false}' },
-			{ action: "synced", args: [["status", "--json"], ["sync"]], stdout: '{"initialized":true}' },
-		] as const) {
-			// given
-			const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-status-"));
-			const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-status-home-"));
-			const calls: { readonly args: readonly string[]; readonly command: string; readonly env: Record<string, string> }[] = [];
-			const outcomes: unknown[] = [];
-			try {
-				// when
-				const result = await runCodegraphSessionStartWorker({
-					config: { codegraph: { enabled: true, install_dir: "/tmp/codegraph-install" }, sources: [], warnings: [] },
-					nodeVersion: "22.14.0",
-					cwd: workspace,
-					env: { HOME: homeDir },
-					logOutcome: (outcome) => outcomes.push(outcome),
-					deps: {
-						ensureGitignored: () => true,
-						ensureProvisioned: () => Promise.resolve({ binPath: "/tmp/codegraph", provisioned: true }),
-						prepareWorkspace: () => ({
-							dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-							dataRoot: join(homeDir, ".omo/codegraph"),
-							linked: true,
-							mode: "global-linked",
-							projectLink: join(workspace, ".codegraph"),
-						}),
-						resolveCommand: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
-						runCommand: (_projectRoot, command, args, options) => {
-							calls.push({ args, command, env: options.env });
-							return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? scenario.stdout : "", timedOut: false });
-						},
-					},
-				});
-
-				// then
-				expect(result).toEqual({ action: scenario.action });
-				expect(calls.map((call) => [...call.args])).toEqual(scenario.args.map((args) => [...args]));
-				expect(calls[0]?.env["CODEGRAPH_INSTALL_DIR"]).toBe("/tmp/codegraph-install");
-				expect(outcomes).toEqual([{ action: scenario.action, exitCode: 0, projectRoot: workspace, source: "path", timedOut: false }]);
-			} finally {
-				rmSync(workspace, { recursive: true, force: true });
-				rmSync(homeDir, { recursive: true, force: true });
-			}
-		}
-	});
-
 	it("#given malformed hook input with CodeGraph disabled #when SessionStart fires #then it stays silent and exits zero", async () => {
 		// given
 		const stdout: string[] = [];
@@ -552,13 +282,3 @@ describe("CodeGraph SessionStart hook", () => {
 		);
 	});
 });
-
-async function withProcessPlatform(platform: NodeJS.Platform, run: () => Promise<void>): Promise<void> {
-	const descriptor = Object.getOwnPropertyDescriptor(process, "platform");
-	Object.defineProperty(process, "platform", { configurable: true, enumerable: true, value: platform });
-	try {
-		await run();
-	} finally {
-		if (descriptor !== undefined) Object.defineProperty(process, "platform", descriptor);
-	}
-}

package/packages/omo-codex/plugin/components/codegraph/test/package-runtime.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "bun:test";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+type CodegraphPackageJson = {
+	readonly files?: readonly string[];
+	readonly optionalDependencies?: Readonly<Record<string, string>>;
+};
+
+const componentRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const repoRoot = resolve(componentRoot, "../../../../..");
+
+function readCodegraphPackageJson(): CodegraphPackageJson {
+	const parsed: unknown = JSON.parse(readFileSync(resolve(componentRoot, "package.json"), "utf8"));
+	if (!isCodegraphPackageJson(parsed)) throw new TypeError("Invalid CodeGraph package metadata");
+	return parsed;
+}
+
+function isCodegraphPackageJson(value: unknown): value is CodegraphPackageJson {
+	return isRecord(value) && maybeStringArray(value["files"]) && maybeStringRecord(value["optionalDependencies"]);
+}
+
+function maybeStringArray(value: unknown): value is readonly string[] | undefined {
+	return value === undefined || (Array.isArray(value) && value.every((item) => typeof item === "string"));
+}
+
+function maybeStringRecord(value: unknown): value is Readonly<Record<string, string>> | undefined {
+	return value === undefined || (isRecord(value) && Object.values(value).every((item) => typeof item === "string"));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+describe("CodeGraph component runtime package metadata", () => {
+	it("#given the CodeGraph component package #when validating runtime distribution metadata #then upstream CodeGraph installs optionally with shipped legal files", () => {
+		// given
+		const packageJson = readCodegraphPackageJson();
+
+		// when
+		const optionalDependencies = packageJson.optionalDependencies ?? {};
+		const files = packageJson.files ?? [];
+
+		// then
+		expect(optionalDependencies["@colbymchenry/codegraph"]).toBe("1.0.1");
+		expect(files).toContain("LICENSE");
+		expect(files).toContain("NODE-RUNTIME-LICENSES.md");
+		expect(files).toContain("NOTICE");
+		expect(existsSync(resolve(componentRoot, "LICENSE"))).toBe(true);
+		expect(existsSync(resolve(componentRoot, "NODE-RUNTIME-LICENSES.md"))).toBe(true);
+		expect(existsSync(resolve(componentRoot, "NOTICE"))).toBe(true);
+		expect(existsSync(resolve(componentRoot, "dist", "cli.d.ts"))).toBe(false);
+		expect(existsSync(resolve(componentRoot, "dist", "serve.d.ts"))).toBe(false);
+	});
+
+	it("#given marketplace payload includes only the plugin tree #when reading CodeGraph NOTICE #then it is self-contained", () => {
+		// given
+		const notice = readFileSync(resolve(componentRoot, "NOTICE"), "utf8");
+
+		expect(notice).toContain("@colbymchenry/codegraph@1.0.1");
+		expect(notice).toContain("MIT license");
+		expect(notice).toContain("Node.js v24.16.0 runtime");
+		expect(notice).toContain("NODE-RUNTIME-LICENSES.md");
+		expect(notice).not.toContain("packages/omo-codex/THIRD-PARTY-NOTICES.md");
+	});
+
+	it("#given CodeGraph platform bundles include Node #when reading runtime licenses #then Node license text ships with the component", () => {
+		// given
+		const licenseText = readFileSync(resolve(componentRoot, "NODE-RUNTIME-LICENSES.md"), "utf8");
+
+		// then
+		expect(licenseText).toContain("Node.js v24.16.0 LICENSE text");
+		expect(licenseText).toContain("Copyright Node.js contributors");
+		expect(licenseText).toContain("The externally maintained libraries used by Node.js are:");
+	});
+
+	it("#given third-party notices #when validating CodeGraph component notices #then aggregate Codex notices list CodeGraph as shipped", () => {
+		// given
+		const codexNotice = readFileSync(resolve(repoRoot, "packages/omo-codex/THIRD-PARTY-NOTICES.md"), "utf8");
+
+		// when
+		const listsCodegraphComponent = codexNotice.includes("@sisyphuslabs/codex-codegraph");
+		const listsUpstreamRuntime = codexNotice.includes("@colbymchenry/codegraph");
+
+		// then
+		expect(listsCodegraphComponent).toBe(true);
+		expect(listsUpstreamRuntime).toBe(true);
+		expect(codexNotice).not.toContain("not currently an omo-codex plugin component");
+	});
+});

package/packages/omo-codex/plugin/components/codegraph/test/provisioned-node-guard.test.ts

@@ -35,7 +35,7 @@ describe("CodeGraph provisioned launcher Node guard", () => {
 		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-"));
 		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-home-"));
 		const installDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-install-"));
-		const binPath = join(installDir, "bin", "codegraph");
+		const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
 		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
 		const outcomes: unknown[] = [];
 
@@ -45,7 +45,7 @@ describe("CodeGraph provisioned launcher Node guard", () => {
 
 			// when
 			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], warnings: [] },
+				config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
 				nodeVersion: "26.3.0",
 				cwd: workspace,
 				env: { HOME: homeDir },

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

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "bun:test";
+import { PassThrough } from "node:stream";
+
+import { runCodegraphServe } from "../src/serve.ts";
+
+describe("runCodegraphServe MCP unavailable facade", () => {
+	it("#given CodeGraph is unavailable #when an MCP client initializes #then it answers with an empty-tool facade", async () => {
+		// given
+		const input = new PassThrough();
+		const output = new PassThrough();
+		const stderr: string[] = [];
+		let stdout = "";
+		output.on("data", (chunk: Buffer) => {
+			stdout += chunk.toString("utf8");
+		});
+
+		const run = runCodegraphServe({
+			config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
+			env: { PATH: "/bin" },
+			buildEnv: () => ({}),
+			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
+			stderr: { write: (chunk: string) => stderr.push(chunk) },
+			stdin: input,
+			stdout: output,
+		});
+
+		// when
+		input.end(frameMcpRequest({
+			id: 1,
+			method: "initialize",
+			params: {
+				capabilities: {},
+				clientInfo: { name: "ulw-red", version: "0.0.0" },
+				protocolVersion: "2025-06-18",
+			},
+		}));
+		const exitCode = await run;
+
+		// then
+		expect(exitCode).toBe(0);
+		expect(stderr).toEqual([
+			"CodeGraph MCP skipped: codegraph binary not found. Install CodeGraph or set OMO_CODEGRAPH_BIN.\n",
+		]);
+		expect(parseFirstJsonRpcBody(stdout)).toEqual({
+			id: 1,
+			jsonrpc: "2.0",
+			result: {
+				capabilities: { tools: { listChanged: false } },
+				protocolVersion: "2025-06-18",
+				serverInfo: { name: "codegraph", version: "1.0.1" },
+			},
+		});
+	});
+});
+
+function frameMcpRequest(request: {
+	readonly id: number;
+	readonly method: string;
+	readonly params: Record<string, unknown>;
+}): string {
+	const body = JSON.stringify({ jsonrpc: "2.0", ...request });
+	return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+}
+
+function parseFirstJsonRpcBody(transcript: string): unknown {
+	const [, body = ""] = transcript.split("\r\n\r\n", 2);
+	return JSON.parse(body);
+}

package/packages/omo-codex/plugin/components/codegraph/test/serve-node-support.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "bun:test";
+import { PassThrough } from "node:stream";
 
 import { CODEGRAPH_UNSAFE_NODE_ENV } from "../../../../../utils/src/codegraph/node-support.ts";
 import { runCodegraphServe } from "../src/serve.ts";
@@ -11,6 +12,7 @@ describe("runCodegraphServe node support", () => {
 
 		// when
 		const exitCode = await runCodegraphServe({
+			...closedMcpStdio(),
 			env: { PATH: "/bin" },
 			nodeVersion: "26.3.0",
 			buildEnv: () => ({}),
@@ -23,7 +25,7 @@ describe("runCodegraphServe node support", () => {
 		});
 
 		// then
-		expect(exitCode).toBe(1);
+		expect(exitCode).toBe(0);
 		expect(spawned).toEqual([]);
 		expect(stderr).toHaveLength(1);
 		expect(stderr[0]).toContain("CodeGraph MCP skipped");
@@ -31,3 +33,11 @@ describe("runCodegraphServe node support", () => {
 		expect(stderr[0]).toContain(CODEGRAPH_UNSAFE_NODE_ENV);
 	});
 });
+
+function closedMcpStdio(): { readonly stdin: PassThrough; readonly stdout: PassThrough } {
+	const stdin = new PassThrough();
+	const stdout = new PassThrough();
+	stdout.resume();
+	stdin.end();
+	return { stdin, stdout };
+}

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

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "bun:test";
+import { join } from "node:path";
+
+import { runCodegraphServe } from "../src/serve.ts";
+
+describe("runCodegraphServe provisioning", () => {
+	it("#given CodeGraph is unresolved #when serving MCP #then provisions CodeGraph before spawning", async () => {
+		// given
+		const binPath = join("/tmp/home/.omo/codegraph", "bin", "codegraph");
+		const calls: Array<{
+			readonly args: readonly string[];
+			readonly command: string;
+			readonly env: Record<string, string | undefined>;
+		}> = [];
+		const stderr: string[] = [];
+
+		// when
+		const exitCode = await runCodegraphServe({
+			config: { codegraph: { enabled: true }, sources: [], warnings: [] },
+			env: { PATH: "/bin" },
+			homeDir: "/tmp/home",
+			nodeVersion: "22.14.0",
+			buildEnv: () => ({}),
+			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
+			ensureProvisioned: (options) =>
+				Promise.resolve({
+					binPath: join(options.installDir ?? "/tmp/home/.omo/codegraph", "bin", "codegraph"),
+					provisioned: true,
+				}),
+			runProcess: (command, args, options) => {
+				calls.push({ args, command, env: options.env });
+				return Promise.resolve(0);
+			},
+			stderr: { write: (chunk: string) => stderr.push(chunk) },
+		});
+
+		// then
+		expect(exitCode).toBe(0);
+		expect(stderr).toEqual([]);
+		expect(calls).toEqual([
+			{
+				args: ["serve", "--mcp"],
+				command: binPath,
+				env: { PATH: "/bin" },
+			},
+		]);
+	});
+});