oh-my-opencode 4.11.0 → 4.12.0

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

@@ -2144,30 +2144,44 @@ async function exists3(path) {
 import { readFile as readFile10, writeFile as writeFile6 } from "node:fs/promises";
 import { join as join15 } from "node:path";
 var GIT_BASH_ENV_KEY = "OMO_CODEX_GIT_BASH_PATH";
+var CODEGRAPH_RELATIVE_ARGS = new Set(["components/codegraph/dist/serve.js", "./components/codegraph/dist/serve.js"]);
 async function stampGitBashMcpEnv(input) {
-  if (input.platform !== "win32")
-    return false;
-  const rawOverride = input.env?.[GIT_BASH_ENV_KEY];
-  const override = typeof rawOverride === "string" ? rawOverride.trim() : "";
-  if (override === "")
-    return false;
   const manifestPath = join15(input.pluginRoot, ".mcp.json");
   if (!await fileExistsStrict(manifestPath))
     return false;
   const parsed = JSON.parse(await readFile10(manifestPath, "utf8"));
   if (!isPlainRecord(parsed) || !isPlainRecord(parsed["mcpServers"]))
     return false;
-  const gitBashServer = parsed["mcpServers"]["git_bash"];
-  if (!isPlainRecord(gitBashServer))
-    return false;
-  const serverEnv = isPlainRecord(gitBashServer["env"]) ? gitBashServer["env"] : {};
-  if (serverEnv[GIT_BASH_ENV_KEY] === override)
+  let changed = stampCodegraphMcpPath(parsed["mcpServers"], input.pluginRoot);
+  if (input.platform === "win32") {
+    const rawOverride = input.env?.[GIT_BASH_ENV_KEY];
+    const override = typeof rawOverride === "string" ? rawOverride.trim() : "";
+    const gitBashServer = parsed["mcpServers"]["git_bash"];
+    if (override !== "" && isPlainRecord(gitBashServer)) {
+      const serverEnv = isPlainRecord(gitBashServer["env"]) ? gitBashServer["env"] : {};
+      if (serverEnv[GIT_BASH_ENV_KEY] !== override) {
+        gitBashServer["env"] = { ...serverEnv, [GIT_BASH_ENV_KEY]: override };
+        changed = true;
+      }
+    }
+  }
+  if (!changed)
     return false;
-  gitBashServer["env"] = { ...serverEnv, [GIT_BASH_ENV_KEY]: override };
   await writeFile6(manifestPath, `${JSON.stringify(parsed, null, "\t")}
 `);
   return true;
 }
+function stampCodegraphMcpPath(mcpServers, pluginRoot) {
+  const codegraphServer = mcpServers["codegraph"];
+  if (!isPlainRecord(codegraphServer) || !Array.isArray(codegraphServer["args"]))
+    return false;
+  const args = codegraphServer["args"];
+  const entrypoint = args[0];
+  if (typeof entrypoint !== "string" || !CODEGRAPH_RELATIVE_ARGS.has(entrypoint))
+    return false;
+  codegraphServer["args"] = [join15(pluginRoot, "components", "codegraph", "dist", "serve.js"), ...args.slice(1)];
+  return true;
+}
 
 // ../src/install/codex-hook-trust.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -2190,17 +2204,33 @@ async function trustedHookStatesForPlugin(input) {
   if (!await exists4(manifestPath))
     return [];
   const manifest = JSON.parse(await readFile11(manifestPath, "utf8"));
-  if (!isPlainRecord(manifest) || typeof manifest.hooks !== "string")
-    return [];
-  const hooksPath = join16(input.pluginRoot, manifest.hooks);
-  if (!await exists4(hooksPath))
+  if (!isPlainRecord(manifest))
     return [];
-  const parsed = JSON.parse(await readFile11(hooksPath, "utf8"));
-  if (!isPlainRecord(parsed) || !isPlainRecord(parsed.hooks))
+  const states = [];
+  for (const hookPath of hookManifestPaths(manifest.hooks)) {
+    const hooksPath = join16(input.pluginRoot, hookPath);
+    if (!await exists4(hooksPath))
+      continue;
+    const parsed = JSON.parse(await readFile11(hooksPath, "utf8"));
+    if (!isPlainRecord(parsed) || !isPlainRecord(parsed.hooks))
+      continue;
+    states.push(...trustedHookStatesForHooksFile({
+      keySource: `${input.pluginName}@${input.marketplaceName}:${hookPath}`,
+      hooks: parsed.hooks
+    }));
+  }
+  return states;
+}
+function hookManifestPaths(value) {
+  if (typeof value === "string" && value.trim() !== "")
+    return [stripDotSlash(value)];
+  if (!Array.isArray(value))
     return [];
-  const keySource = `${input.pluginName}@${input.marketplaceName}:${stripDotSlash(manifest.hooks)}`;
+  return value.filter((item) => typeof item === "string" && item.trim() !== "").map(stripDotSlash);
+}
+function trustedHookStatesForHooksFile(input) {
   const states = [];
-  for (const [eventName, groups] of Object.entries(parsed.hooks)) {
+  for (const [eventName, groups] of Object.entries(input.hooks)) {
     if (!Array.isArray(groups))
       continue;
     const eventLabel = EVENT_LABELS.get(eventName);
@@ -2216,7 +2246,7 @@ async function trustedHookStatesForPlugin(input) {
           continue;
         if (typeof handler.command !== "string" || handler.command.trim() === "")
           continue;
-        const key = `${keySource}:${eventLabel}:${groupIndex}:${handlerIndex}`;
+        const key = `${input.keySource}:${eventLabel}:${groupIndex}:${handlerIndex}`;
         states.push({ key, trustedHash: commandHookHash(eventLabel, group.matcher, handler) });
       }
     }

package/packages/omo-codex/plugin/components/bootstrap/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"command": "node \"${PLUGIN_ROOT}/components/bootstrap/dist/cli.js\" hook session-start",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\bootstrap.ps1\"",
 						"timeout": 30,
-						"statusMessage": "LazyCodex(4.11.0): Checking Bootstrap Provisioning"
+						"statusMessage": "(OmO) Checking Bootstrap Provisioning"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-bootstrap",
-	"version": "4.11.0",
+	"version": "4.12.0",
 	"description": "Codex SessionStart bootstrap component that provisions LazyCodex runtime dependencies from a detached worker.",
 	"type": "module",
 	"private": true,

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

@@ -1595,6 +1595,9 @@ function bunWhich(commandName) {
 }
 
 // ../../utils/src/codegraph/resolve.ts
+function codegraphCommandRequiresSupportedLocalNode(resolution) {
+  return resolution.source !== "bundled" && resolution.source !== "env" && resolution.source !== "provisioned";
+}
 var CODEGRAPH_PACKAGE = "@colbymchenry/codegraph";
 var CODEGRAPH_ENV_BIN = "OMO_CODEGRAPH_BIN";
 var CODEGRAPH_LEGACY_ENV_BIN = "CODEGRAPH_BIN";
@@ -1864,7 +1867,7 @@ function finish(action, detail, logOutcome) {
 async function resolveOrProvisionCommand(deps, config, env, homeDir, nodeSupport) {
   const resolved = deps.resolveCommand({ env, homeDir, provisioned: () => provisionedBinFromInstallDir(config.install_dir) });
   if (resolved.exists) {
-    if (resolved.source !== "bundled" && resolved.source !== "env" && !nodeSupport.supported) {
+    if (codegraphCommandRequiresSupportedLocalNode(resolved) && !nodeSupport.supported) {
       return { kind: "unsupported-node" };
     }
     return { kind: "resolved", resolution: resolved };
@@ -1990,7 +1993,6 @@ async function executeCodegraphSessionStartHook(options = {}) {
   const homeDir = resolveHomeDir2(env);
   const config = options.config ?? getCodexOmoConfig({ cwd: projectRoot, env, homeDir });
   if (config.codegraph?.enabled === false) {
-    writeHookJson(options.stdout ?? processStdout, "skipped-disabled");
     return { action: "skipped-disabled", exitCode: 0 };
   }
   (options.spawnWorker ?? spawnDetachedWorker)({
@@ -1998,11 +2000,16 @@ async function executeCodegraphSessionStartHook(options = {}) {
     command: process.execPath,
     env: { ...env, [SESSION_START_CWD_ENV]: projectRoot }
   });
-  writeHookJson(options.stdout ?? processStdout, "spawned");
+  writeHookJson(options.stdout ?? processStdout);
   return { action: "spawned", exitCode: 0 };
 }
-function writeHookJson(stdout, action) {
-  const output = action === "spawned" ? { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: CODEGRAPH_SESSION_START_NOTICE }, codegraph: { action } } : { hookSpecificOutput: { hookEventName: "SessionStart" }, codegraph: { action } };
+function writeHookJson(stdout) {
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: CODEGRAPH_SESSION_START_NOTICE
+    }
+  };
   stdout.write(`${JSON.stringify(output)}
 `);
 }
@@ -2078,12 +2085,16 @@ async function runCodegraphServe(options = {}) {
     provisioned: () => provisionedBinFromInstallDir2(codegraphConfig.install_dir)
   };
   const resolution = options.resolve?.(resolutionOptions) ?? resolveCodegraphCommand(resolutionOptions);
+  const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
   if (!resolution.exists || shouldSkipResolvedCommand(resolution, options.commandExists ?? existsSync7)) {
+    if (resolution.source === "path" && !nodeSupport.supported) {
+      (options.stderr ?? processStderr2).write(buildCodegraphNodeSkipHint(nodeSupport));
+      return 1;
+    }
     (options.stderr ?? processStderr2).write(CODEGRAPH_SKIP_HINT);
     return 1;
   }
-  const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
-  if (resolution.source !== "bundled" && resolution.source !== "env" && !nodeSupport.supported) {
+  if (codegraphCommandRequiresSupportedLocalNode(resolution) && !nodeSupport.supported) {
     (options.stderr ?? processStderr2).write(buildCodegraphNodeSkipHint(nodeSupport));
     return 1;
   }

package/packages/omo-codex/plugin/components/codegraph/dist/serve.js

@@ -132,6 +132,9 @@ function bunWhich(commandName) {
 }
 
 // ../../../../utils/src/codegraph/resolve.ts
+function codegraphCommandRequiresSupportedLocalNode(resolution) {
+  return resolution.source !== "bundled" && resolution.source !== "env" && resolution.source !== "provisioned";
+}
 var CODEGRAPH_PACKAGE = "@colbymchenry/codegraph";
 var CODEGRAPH_ENV_BIN = "OMO_CODEGRAPH_BIN";
 var CODEGRAPH_LEGACY_ENV_BIN = "CODEGRAPH_BIN";
@@ -1511,12 +1514,16 @@ async function runCodegraphServe(options = {}) {
     provisioned: () => provisionedBinFromInstallDir(codegraphConfig.install_dir)
   };
   const resolution = options.resolve?.(resolutionOptions) ?? resolveCodegraphCommand(resolutionOptions);
+  const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
   if (!resolution.exists || shouldSkipResolvedCommand(resolution, options.commandExists ?? existsSync4)) {
+    if (resolution.source === "path" && !nodeSupport.supported) {
+      (options.stderr ?? processStderr).write(buildCodegraphNodeSkipHint(nodeSupport));
+      return 1;
+    }
     (options.stderr ?? processStderr).write(CODEGRAPH_SKIP_HINT);
     return 1;
   }
-  const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
-  if (resolution.source !== "bundled" && resolution.source !== "env" && !nodeSupport.supported) {
+  if (codegraphCommandRequiresSupportedLocalNode(resolution) && !nodeSupport.supported) {
     (options.stderr ?? processStderr).write(buildCodegraphNodeSkipHint(nodeSupport));
     return 1;
   }

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-codegraph",
-	"version": "4.11.0",
+	"version": "4.12.0",
 	"description": "Codex plugin MCP wrapper for CodeGraph.",
 	"type": "module",
 	"private": true,

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

@@ -8,7 +8,6 @@ import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
 import { SESSION_START_CWD_ENV } from "./session-start-worker.js";
 import type {
 	HookStdout,
-	SessionStartAction,
 	SessionStartHookOptions,
 	SessionStartHookResult,
 	WorkerSpawnInvocation,
@@ -47,7 +46,6 @@ export async function executeCodegraphSessionStartHook(options: SessionStartHook
 	const config = options.config ?? getCodexOmoConfig({ cwd: projectRoot, env, homeDir });
 
 	if (config.codegraph?.enabled === false) {
-		writeHookJson(options.stdout ?? processStdout, "skipped-disabled");
 		return { action: "skipped-disabled", exitCode: 0 };
 	}
 
@@ -56,14 +54,17 @@ export async function executeCodegraphSessionStartHook(options: SessionStartHook
 		command: process.execPath,
 		env: { ...env, [SESSION_START_CWD_ENV]: projectRoot },
 	});
-	writeHookJson(options.stdout ?? processStdout, "spawned");
+	writeHookJson(options.stdout ?? processStdout);
 	return { action: "spawned", exitCode: 0 };
 }
 
-function writeHookJson(stdout: HookStdout, action: SessionStartAction): void {
-	const output = action === "spawned"
-		? { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: CODEGRAPH_SESSION_START_NOTICE }, codegraph: { action } }
-		: { hookSpecificOutput: { hookEventName: "SessionStart" }, codegraph: { action } };
+function writeHookJson(stdout: HookStdout): void {
+	const output = {
+		hookSpecificOutput: {
+			hookEventName: "SessionStart",
+			additionalContext: CODEGRAPH_SESSION_START_NOTICE,
+		},
+	};
 	stdout.write(`${JSON.stringify(output)}\n`);
 }
 

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

@@ -17,6 +17,7 @@ import {
 	evaluateCodegraphNodeSupport,
 } from "../../../../../utils/src/codegraph/node-support.ts";
 import {
+	codegraphCommandRequiresSupportedLocalNode,
 	resolveCodegraphCommand,
 	type CodegraphCommandResolution,
 	type ResolveCodegraphCommandOptions,
@@ -82,13 +83,17 @@ export async function runCodegraphServe(options: RunCodegraphServeOptions = {}):
 		provisioned: () => provisionedBinFromInstallDir(codegraphConfig.install_dir),
 	} satisfies ResolveCodegraphCommandOptions;
 	const 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;
+		}
 		(options.stderr ?? processStderr).write(CODEGRAPH_SKIP_HINT);
 		return 1;
 	}
 
-	const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
-	if (resolution.source !== "bundled" && resolution.source !== "env" && !nodeSupport.supported) {
+	if (codegraphCommandRequiresSupportedLocalNode(resolution) && !nodeSupport.supported) {
 		(options.stderr ?? processStderr).write(buildCodegraphNodeSkipHint(nodeSupport));
 		return 1;
 	}

package/packages/omo-codex/plugin/components/codegraph/src/session-start-worker.ts

@@ -9,6 +9,7 @@ import { buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
 import { evaluateCodegraphNodeSupport, type CodegraphNodeSupport } from "../../../../../utils/src/codegraph/node-support.ts";
 import { ensureCodegraphProvisioned } from "../../../../../utils/src/codegraph/provision.ts";
 import {
+	codegraphCommandRequiresSupportedLocalNode,
 	resolveCodegraphCommand,
 	type CodegraphCommandResolution,
 } from "../../../../../utils/src/codegraph/resolve.ts";
@@ -103,7 +104,7 @@ async function resolveOrProvisionCommand(
 ): Promise<ResolutionResult> {
 	const resolved = deps.resolveCommand({ env, homeDir, provisioned: () => provisionedBinFromInstallDir(config.install_dir) });
 	if (resolved.exists) {
-		if (resolved.source !== "bundled" && resolved.source !== "env" && !nodeSupport.supported) {
+		if (codegraphCommandRequiresSupportedLocalNode(resolved) && !nodeSupport.supported) {
 			return { kind: "unsupported-node" };
 		}
 		return { kind: "resolved", resolution: resolved };

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

@@ -14,7 +14,7 @@ import {
 } from "../src/hook.ts";
 
 const pluginRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));
-const hooksConfigPath = resolve(pluginRoot, "hooks/hooks.json");
+const pluginConfigPath = resolve(pluginRoot, ".codex-plugin/plugin.json");
 
 describe("CodeGraph SessionStart hook", () => {
 	it("#given hook session-start cli args #when invoked with empty JSON input #then it emits valid JSON and exits zero", async () => {
@@ -42,7 +42,6 @@ describe("CodeGraph SessionStart hook", () => {
 					hookEventName: "SessionStart",
 					additionalContext: "LazyCodex CodeGraph bootstrap scheduled in background",
 				},
-				codegraph: { action: "spawned" },
 			});
 		} finally {
 			rmSync(homeDir, { recursive: true, force: true });
@@ -66,10 +65,7 @@ describe("CodeGraph SessionStart hook", () => {
 		// then
 		expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
 		expect(spawned).toEqual([]);
-		expect(JSON.parse(stdout.join(""))).toEqual({
-			hookSpecificOutput: { hookEventName: "SessionStart" },
-			codegraph: { action: "skipped-disabled" },
-		});
+		expect(stdout.join("")).toBe("");
 	});
 
 	it("#given HOME OMO config disables Codex CodeGraph #when SessionStart fires #then it skips without spawning", async () => {
@@ -97,7 +93,7 @@ describe("CodeGraph SessionStart hook", () => {
 			// then
 			expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
 			expect(spawned).toEqual([]);
-			expect(JSON.parse(stdout.join("")).codegraph).toEqual({ action: "skipped-disabled" });
+			expect(stdout.join("")).toBe("");
 		} finally {
 			rmSync(homeDir, { recursive: true, force: true });
 			rmSync(workspace, { recursive: true, force: true });
@@ -128,7 +124,7 @@ describe("CodeGraph SessionStart hook", () => {
 			// then
 			expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
 			expect(spawned).toEqual([]);
-			expect(JSON.parse(stdout.join("")).codegraph).toEqual({ action: "skipped-disabled" });
+			expect(stdout.join("")).toBe("");
 		} finally {
 			rmSync(homeDir, { recursive: true, force: true });
 			rmSync(workspace, { recursive: true, force: true });
@@ -191,7 +187,12 @@ describe("CodeGraph SessionStart hook", () => {
 					},
 				},
 			]);
-			expect(JSON.parse(stdout.join("")).codegraph).toEqual({ action: "spawned" });
+			expect(JSON.parse(stdout.join(""))).toEqual({
+				hookSpecificOutput: {
+					additionalContext: "LazyCodex CodeGraph bootstrap scheduled in background",
+					hookEventName: "SessionStart",
+				},
+			});
 		} finally {
 			rmSync(workspace, { recursive: true, force: true });
 		}
@@ -514,7 +515,7 @@ describe("CodeGraph SessionStart hook", () => {
 		}
 	});
 
-	it("#given malformed hook input #when SessionStart fires #then it still emits JSON and exits zero", async () => {
+	it("#given malformed hook input with CodeGraph disabled #when SessionStart fires #then it stays silent and exits zero", async () => {
 		// given
 		const stdout: string[] = [];
 		const spawned: WorkerSpawnInvocation[] = [];
@@ -531,23 +532,23 @@ describe("CodeGraph SessionStart hook", () => {
 		// then
 		expect(result.exitCode).toBe(0);
 		expect(spawned).toEqual([]);
-		expect(JSON.parse(stdout.join("")).codegraph).toEqual({ action: "skipped-disabled" });
+		expect(stdout.join("")).toBe("");
 	});
 
 	it("#given plugin hook config #when inspected #then CodeGraph is registered after bootstrap SessionStart", () => {
 		// given
-		const hooksConfig = JSON.parse(readFileSync(hooksConfigPath, "utf8"));
+		const pluginConfig: unknown = JSON.parse(readFileSync(pluginConfigPath, "utf8"));
 
 		// when
-		const sessionStartHooks = hooksConfig.hooks.SessionStart;
-		const commands = sessionStartHooks.map((entry: { readonly hooks: readonly [{ readonly command: string }] }) => {
-			return entry.hooks[0].command;
-		});
+		const hookPaths =
+			typeof pluginConfig === "object" && pluginConfig !== null && "hooks" in pluginConfig && Array.isArray(pluginConfig.hooks)
+				? pluginConfig.hooks.filter((hookPath): hookPath is string => typeof hookPath === "string")
+				: [];
 
 		// then
-		expect(commands).toContain('node "${PLUGIN_ROOT}/components/codegraph/dist/cli.js" hook session-start');
-		expect(commands.indexOf('node "${PLUGIN_ROOT}/components/bootstrap/dist/cli.js" hook session-start')).toBeLessThan(
-			commands.indexOf('node "${PLUGIN_ROOT}/components/codegraph/dist/cli.js" hook session-start'),
+		expect(hookPaths).toContain("./hooks/session-start-checking-codegraph-bootstrap.json");
+		expect(hookPaths.indexOf("./hooks/session-start-checking-bootstrap-provisioning.json")).toBeLessThan(
+			hookPaths.indexOf("./hooks/session-start-checking-codegraph-bootstrap.json"),
 		);
 	});
 });

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

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runCodegraphSessionStartWorker } from "../src/hook.ts";
+import { runCodegraphServe } from "../src/serve.ts";
+
+describe("CodeGraph provisioned launcher Node guard", () => {
+	it("#given provisioned CodeGraph binary #when serve runs under unsupported local Node #then it trusts the launcher", async () => {
+		// given
+		const commandPath = "/home/test/.omo/codegraph/bin/codegraph";
+		const spawned: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
+
+		// when
+		const exitCode = await runCodegraphServe({
+			env: {},
+			nodeVersion: "26.3.0",
+			buildEnv: () => ({}),
+			resolve: () => ({ argsPrefix: [], command: commandPath, exists: true, source: "provisioned" }),
+			runProcess: (command, args) => {
+				spawned.push({ args, command });
+				return Promise.resolve(0);
+			},
+			stderr: { write: () => undefined },
+		});
+
+		// then
+		expect(exitCode).toBe(0);
+		expect(spawned).toEqual([{ args: ["serve", "--mcp"], command: commandPath }]);
+	});
+
+	it("#given provisioned CodeGraph exists #when SessionStart worker runs under unsupported local Node #then it bootstraps through the launcher", async () => {
+		// given
+		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 calls: Array<{ readonly args: readonly string[]; readonly command: 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: "26.3.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) => {
+						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: ["status", "--json"], command: binPath },
+				{ args: ["init"], command: binPath },
+			]);
+			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 });
+		}
+	});
+});

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

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "bun:test";
+
+import { CODEGRAPH_UNSAFE_NODE_ENV } from "../../../../../utils/src/codegraph/node-support.ts";
+import { runCodegraphServe } from "../src/serve.ts";
+
+describe("runCodegraphServe node support", () => {
+	it("#given Node is too new and no command resolves #when serving MCP #then the unsupported-node hint wins", async () => {
+		// given
+		const stderr: string[] = [];
+		const spawned: string[] = [];
+
+		// when
+		const exitCode = await runCodegraphServe({
+			env: { PATH: "/bin" },
+			nodeVersion: "26.3.0",
+			buildEnv: () => ({}),
+			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
+			runProcess: (command: string) => {
+				spawned.push(command);
+				return Promise.resolve(0);
+			},
+			stderr: { write: (chunk: string) => stderr.push(chunk) },
+		});
+
+		// then
+		expect(exitCode).toBe(1);
+		expect(spawned).toEqual([]);
+		expect(stderr).toHaveLength(1);
+		expect(stderr[0]).toContain("CodeGraph MCP skipped");
+		expect(stderr[0]).toContain("Node 26 is unsupported");
+		expect(stderr[0]).toContain(CODEGRAPH_UNSAFE_NODE_ENV);
+	});
+});

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

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "LazyCodex(4.11.0): Checking Comments"
+						"statusMessage": "(OmO) Checking Comments"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "4.11.0",
+	"version": "4.12.0",
 	"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/comment-checker/test/package-smoke.test.ts

@@ -1,44 +1,12 @@
-import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
-
-type PackageJson = {
-	readonly type: string;
-	readonly packageManager: string;
-	readonly bin: Record<string, string>;
-	readonly dependencies?: Record<string, unknown>;
-	readonly optionalDependencies: Record<string, string>;
-};
-
-type HookCommand = {
-	readonly command: string;
-};
-
-type HookEntry = {
-	readonly hooks: readonly HookCommand[];
-};
-
-type HooksJson = {
-	readonly hooks: Record<string, readonly HookEntry[]>;
-};
-
-function readPackageJson(path: string): PackageJson {
-	const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
-	if (!isPackageJson(parsed)) throw new TypeError(`Invalid package metadata: ${path}`);
-	return parsed;
-}
-
-function readHooksJson(path: string): HooksJson {
-	const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
-	if (!isHooksJson(parsed)) throw new TypeError(`Invalid hooks metadata: ${path}`);
-	return parsed;
-}
+import { readHooksJson, readPackageJson, readTextFile } from "../../test-support/package-smoke-fixture.js";
 
 describe("plugin package metadata", () => {
 	it("#given packaged plugin files #when validating entrypoints #then hook command uses portable plugin root interpolation", () => {
 		// given
 		const packageJson = readPackageJson("package.json");
 		const hooksJson = readHooksJson("hooks/hooks.json");
-		const cliSource = readFileSync("src/cli.ts", "utf8");
+		const cliSource = readTextFile("src/cli.ts");
 
 		// when
 		const command = hooksJson.hooks["PostToolUse"]?.[0]?.hooks[0]?.command;
@@ -54,40 +22,3 @@ describe("plugin package metadata", () => {
 		expect(command).toBe(`node "${pluginRoot}/dist/cli.js" hook post-tool-use`);
 	});
 });
-
-function isPackageJson(value: unknown): value is PackageJson {
-	if (!isRecord(value)) return false;
-	const dependencies = value["dependencies"];
-	return (
-		value["type"] === "module" &&
-		value["packageManager"] === "npm@11.12.1" &&
-		isStringRecord(value["bin"]) &&
-		isStringRecord(value["optionalDependencies"]) &&
-		(dependencies === undefined || isRecord(dependencies))
-	);
-}
-
-function isHooksJson(value: unknown): value is HooksJson {
-	if (!isRecord(value) || !isRecord(value["hooks"])) return false;
-	return Object.values(value["hooks"]).every(isHookEntries);
-}
-
-function isHookEntries(value: unknown): value is readonly HookEntry[] {
-	return Array.isArray(value) && value.every(isHookEntry);
-}
-
-function isHookEntry(value: unknown): value is HookEntry {
-	return isRecord(value) && Array.isArray(value["hooks"]) && value["hooks"].every(isHookCommand);
-}
-
-function isHookCommand(value: unknown): value is HookCommand {
-	return isRecord(value) && typeof value["command"] === "string";
-}
-
-function isStringRecord(value: unknown): value is Record<string, string> {
-	return 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);
-}