oh-my-opencode 4.18.2 → 4.19.1

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

@@ -1,7 +1,8 @@
-import { spawn } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import type { Readable, Writable } from "node:stream";
 
 import {
+	createParentWatchdog,
 	errorResponse,
 	isPlainRecord,
 	jsonRpcId,
@@ -35,6 +36,8 @@ const CODEGRAPH_NODE_INCLUDE_CODE_DESCRIPTION =
 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.";
 
+const SIGKILL_ESCALATION_MS = 2_000;
+
 export async function runBridgedCodegraphProcess(
 	command: string,
 	args: readonly string[],
@@ -63,22 +66,45 @@ export async function runBridgedCodegraphProcess(
 			resolveExit(signal === null ? 0 : 1);
 		});
 	});
-	const clientForwardingDone = forwardClientToCodegraph(options.input, childInput, pendingResponses, (mode) => {
-		defaultResponseMode = mode;
+	const destroyChildPipes = (): void => {
+		childInput.destroy();
+		childOutput.destroy();
+	};
+	void childExit.then(destroyChildPipes, destroyChildPipes);
+	// Parent-liveness watchdog: when the parent dies while holding our stdio
+	// open, the client stream never sees EOF, so the only settle path is to
+	// drop the client input, close the child pipes, and terminate the child.
+	// The bridge then resolves through the normal child-exit path, and the
+	// destroyed input releases its read handle so the process can actually
+	// exit (same teardown pattern as runJsonRpcStdioServer's own watchdog).
+	// In daemon mode the child is the upstream lightweight proxy, so killing
+	// it on parent death is correct; the detached daemon is a separate process
+	// and is never touched.
+	let parentWatchdogFired = false;
+	const parentWatchdog = createParentWatchdog(options.parentWatchdog, () => {
+		parentWatchdogFired = true;
+		options.input.destroy();
+		destroyChildPipes();
+		terminateCodegraphChild(child);
 	});
+	const clientForwardingDone = forwardClientToCodegraph(
+		options.input,
+		childInput,
+		pendingResponses,
+		(mode) => {
+			defaultResponseMode = mode;
+		},
+		() => parentWatchdogFired,
+	);
 	const responseForwardingDone = forwardCodegraphToClient(
 		childOutput,
 		options.output,
 		pendingResponses,
 		() => defaultResponseMode,
+		() => parentWatchdogFired,
 	);
 	const bridgeDone = Promise.all([clientForwardingDone, responseForwardingDone]);
 	const childAndResponsesDone = Promise.all([childExit, responseForwardingDone]).then(([exitCode]) => exitCode);
-	const destroyChildPipes = (): void => {
-		childInput.destroy();
-		childOutput.destroy();
-	};
-	void childExit.then(destroyChildPipes, destroyChildPipes);
 	try {
 		return await Promise.race([childAndResponsesDone, bridgeDone.then(() => childExit)]);
 	} catch (error) {
@@ -86,32 +112,64 @@ export async function runBridgedCodegraphProcess(
 		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
 		await childExit.catch(() => undefined);
 		throw error;
+	} finally {
+		parentWatchdog.clear();
 	}
 }
 
+function terminateCodegraphChild(child: ChildProcess): void {
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	child.kill("SIGTERM");
+	const escalation = setTimeout(() => {
+		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+	}, SIGKILL_ESCALATION_MS);
+	escalation.unref();
+}
+
+// Stream errors raised by the watchdog's own teardown (input destroy, child
+// pipe destroy) while a forwarder is parked on that stream.
+function isWatchdogTeardownError(error: unknown): boolean {
+	if (!(error instanceof Error) || !("code" in error)) return false;
+	return (
+		error.code === "ERR_STREAM_PREMATURE_CLOSE" ||
+		error.code === "ERR_STREAM_DESTROYED" ||
+		error.code === "ERR_STREAM_WRITE_AFTER_END" ||
+		error.code === "EPIPE"
+	);
+}
+
 async function forwardClientToCodegraph(
 	input: Readable,
 	childInput: Writable,
 	pendingResponses: Map<string, PendingClientResponse>,
 	setDefaultResponseMode: (mode: StdioJsonRpcResponseMode) => void,
+	tolerateWatchdogClose: () => boolean,
 ): 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) {
-			pendingResponses.set(key, {
-				method: jsonRpcMethod(message.payload),
-				responseMode,
-				toolName: jsonRpcToolName(message.payload),
-			});
+	try {
+		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) {
+				pendingResponses.set(key, {
+					method: jsonRpcMethod(message.payload),
+					responseMode,
+					toolName: jsonRpcToolName(message.payload),
+				});
+			}
+			await writeLine(childInput, JSON.stringify(message.payload));
 		}
-		await writeLine(childInput, JSON.stringify(message.payload));
+		childInput.end();
+	} catch (error) {
+		// The parent watchdog destroys the client input and child pipes while
+		// this forwarder is parked on a read or write; that teardown is
+		// self-inflicted, so settle quietly and let the child-exit path report
+		// the outcome.
+		if (!(tolerateWatchdogClose() && isWatchdogTeardownError(error))) throw error;
 	}
-	childInput.end();
 }
 
 async function forwardCodegraphToClient(
@@ -119,17 +177,25 @@ async function forwardCodegraphToClient(
 	output: Writable,
 	pendingResponses: Map<string, PendingClientResponse>,
 	defaultResponseMode: () => StdioJsonRpcResponseMode,
+	tolerateWatchdogClose: () => boolean,
 ): Promise<void> {
-	for await (const message of readStdioJsonRpcMessages(childOutput)) {
-		if (message.kind === "parse_error") {
-			await writeStdioJsonRpcResponse(output, errorResponse(null, -32700, "Parse error", message.message), defaultResponseMode());
-			continue;
+	try {
+		for await (const message of readStdioJsonRpcMessages(childOutput)) {
+			if (message.kind === "parse_error") {
+				await writeStdioJsonRpcResponse(output, errorResponse(null, -32700, "Parse error", message.message), defaultResponseMode());
+				continue;
+			}
+			const key = responseModeKey(message.payload);
+			const pendingResponse = key === null ? undefined : pendingResponses.get(key);
+			const responseMode = pendingResponse?.responseMode ?? defaultResponseMode();
+			if (key !== null) pendingResponses.delete(key);
+			await writeStdioJsonRpcResponse(output, clarifyCodegraphResponse(message.payload, pendingResponse), responseMode);
 		}
-		const key = responseModeKey(message.payload);
-		const pendingResponse = key === null ? undefined : pendingResponses.get(key);
-		const responseMode = pendingResponse?.responseMode ?? defaultResponseMode();
-		if (key !== null) pendingResponses.delete(key);
-		await writeStdioJsonRpcResponse(output, clarifyCodegraphResponse(message.payload, pendingResponse), responseMode);
+	} catch (error) {
+		// The parent watchdog destroys the child pipes while this forwarder is
+		// parked on a read; that close is self-inflicted, so settle quietly and
+		// let the child-exit path report the outcome.
+		if (!(tolerateWatchdogClose() && isWatchdogTeardownError(error))) throw error;
 	}
 }
 

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

@@ -7,6 +7,7 @@ import {
 	runJsonRpcStdioServer,
 	successResponse,
 	type JsonRpcResponse,
+	type ParentWatchdogConfig,
 } from "../../../../../mcp-stdio-core/src/index.ts";
 
 export interface UnavailableCodegraphMcpOptions {
@@ -14,6 +15,9 @@ export interface UnavailableCodegraphMcpOptions {
 	readonly output: Writable;
 	readonly reason: string;
 	readonly serverVersion: string;
+	// Test seam: production callers leave this unset so the watchdog uses its
+	// defaults (parentPid = process.ppid, 30s poll).
+	readonly parentWatchdog?: ParentWatchdogConfig;
 }
 
 interface UnavailableCodegraphMcpHandlerOptions {
@@ -32,6 +36,7 @@ export async function runUnavailableCodegraphMcpServer(
 		},
 		input: options.input,
 		output: options.output,
+		parentWatchdog: options.parentWatchdog ?? {},
 	});
 }
 

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

@@ -13,10 +13,11 @@ import type { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
 import {
-	CODEGRAPH_NO_DAEMON_ENV,
 	buildCodegraphChildEnv,
 	buildCodegraphEnv,
 } from "../../../../../utils/src/codegraph/env.ts";
+import type { ParentWatchdogConfig } from "../../../../../mcp-stdio-core/src/index.ts";
+import { CODEGRAPH_PINNED_VERSION } from "../../../../../utils/src/codegraph/manifest.ts";
 import {
 	buildCodegraphNodeSkipHint,
 	evaluateCodegraphNodeSupport,
@@ -48,6 +49,7 @@ export interface CodegraphServeProcessOptions {
 	readonly output: Writable;
 	readonly stderr: CodegraphServeStderr;
 	readonly stdio: ServeStdio;
+	readonly parentWatchdog?: ParentWatchdogConfig;
 }
 
 export type CodegraphServeProcessRunner = (
@@ -64,7 +66,7 @@ export interface CodegraphServeStderr {
 }
 
 export interface RunCodegraphServeOptions {
-	readonly buildEnv?: (options: { readonly homeDir: string }) => Record<string, string>;
+	readonly buildEnv?: (options: { readonly daemon: boolean; readonly homeDir: string }) => Record<string, string>;
 	readonly commandExists?: (filePath: string) => boolean;
 	readonly config?: CodexOmoConfig;
 	readonly cwd?: string;
@@ -77,6 +79,10 @@ export interface RunCodegraphServeOptions {
 	readonly runProcess?: CodegraphServeProcessRunner;
 	readonly stderr?: CodegraphServeStderr;
 	readonly ensureProvisioned?: CodegraphProvisioner;
+	// Test seam: production callers leave this unset so the bridge and the
+	// unavailable facade use the watchdog defaults (parentPid = process.ppid,
+	// 30s poll).
+	readonly parentWatchdog?: ParentWatchdogConfig;
 }
 
 const CODEGRAPH_SKIP_HINT =
@@ -84,7 +90,7 @@ 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_EXCLUDED_HINT = "CodeGraph MCP skipped: project excluded by OMO CodeGraph policy.\n";
-const CODEGRAPH_VERSION = "1.0.1";
+const CODEGRAPH_VERSION = CODEGRAPH_PINNED_VERSION;
 const PROJECT_CWD_ENV_KEYS = ["OMO_CODEGRAPH_PROJECT_CWD", SESSION_START_CWD_ENV, "PWD"] as const;
 
 export async function runCodegraphServe(options: RunCodegraphServeOptions = {}): Promise<number> {
@@ -136,7 +142,7 @@ export async function runCodegraphServe(options: RunCodegraphServeOptions = {}):
 	}
 
 	const runProcess = options.runProcess ?? runBridgedCodegraphProcess;
-	const codegraphEnv = codegraphEnvForConfig(trustedInstallDir, homeDir, options.buildEnv);
+	const codegraphEnv = codegraphEnvForConfig(trustedInstallDir, homeDir, codegraphConfig.daemon === true, options.buildEnv);
 	const mergedEnv = buildCodegraphChildEnv({ ambientEnv: env, codegraphEnv, runtimeEnv: env });
 	return runProcess(resolution.command, [...resolution.argsPrefix, "serve", "--mcp"], {
 		cwd: projectCwd,
@@ -145,6 +151,7 @@ export async function runCodegraphServe(options: RunCodegraphServeOptions = {}):
 		output: options.stdout ?? processStdout,
 		stderr: options.stderr ?? processStderr,
 		stdio: "pipe",
+		parentWatchdog: options.parentWatchdog ?? {},
 	});
 }
 
@@ -155,6 +162,7 @@ async function runUnavailableMcp(reason: string, options: RunCodegraphServeOptio
 		output: options.stdout ?? processStdout,
 		reason,
 		serverVersion: CODEGRAPH_VERSION,
+		parentWatchdog: options.parentWatchdog ?? {},
 	});
 	return 0;
 }
@@ -195,9 +203,10 @@ function looksLikePath(command: string): boolean {
 function codegraphEnvForConfig(
 	trustedInstallDir: string | undefined,
 	homeDir: string,
-	buildEnv: ((options: { readonly homeDir: string }) => Record<string, string>) | undefined,
+	daemon: boolean,
+	buildEnv: ((options: { readonly daemon: boolean; readonly homeDir: string }) => Record<string, string>) | undefined,
 ): Record<string, string> {
-	const env = { ...(buildEnv?.({ homeDir }) ?? buildCodegraphEnv({ homeDir })), [CODEGRAPH_NO_DAEMON_ENV]: "1" };
+	const env = buildEnv?.({ daemon, homeDir }) ?? buildCodegraphEnv({ daemon, homeDir });
 	return trustedInstallDir === undefined ? env : { ...env, CODEGRAPH_INSTALL_DIR: trustedInstallDir };
 }
 

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

@@ -6,6 +6,7 @@ import { cwd as processCwd, env as processEnv, execPath as processExecPath, stde
 
 import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
 import { buildCodegraphChildEnv, buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
+import { CODEGRAPH_PINNED_VERSION } from "../../../../../utils/src/codegraph/manifest.ts";
 import { evaluateCodegraphNodeSupport, type CodegraphNodeSupport } from "../../../../../utils/src/codegraph/node-support.ts";
 import { ensureCodegraphProvisioned } from "../../../../../utils/src/codegraph/provision.ts";
 import {
@@ -25,7 +26,7 @@ import type {
 
 export const SESSION_START_CWD_ENV = "OMO_CODEGRAPH_SESSION_START_CWD";
 
-const CODEGRAPH_VERSION = "1.0.1";
+const CODEGRAPH_VERSION = CODEGRAPH_PINNED_VERSION;
 const COMMAND_TIMEOUT_MS = 60_000;
 const WINDOWS_CMD_EXTENSIONS = new Set([".bat", ".cmd"]);
 const WINDOWS_NODE_SCRIPT_EXTENSIONS = new Set([".cjs", ".js", ".mjs"]);
@@ -127,7 +128,10 @@ async function resolveOrProvisionCommand(
 }
 
 function codegraphEnvForConfig(config: CodegraphBootstrapConfig, homeDir: string): Record<string, string> {
-	const env = buildCodegraphEnv({ homeDir });
+	// The detached indexing worker must NEVER engage the upstream daemon, even
+	// when the user opted into daemon mode for interactive MCP sessions: a
+	// daemon-backed init/sync would outlive and race the worker's lifecycle.
+	const env = buildCodegraphEnv({ daemon: false, homeDir });
 	return config.trustedCodegraphInstallDir === undefined ? env : { ...env, CODEGRAPH_INSTALL_DIR: config.trustedCodegraphInstallDir };
 }
 

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

@@ -61,6 +61,7 @@ function writeSweepReport(stdout: HookStdout, result: SweepCodegraphZombiesResul
 		failed: result.failed,
 		killed: result.killed.map(formatProcess),
 		ownedRoots: result.ownedRoots,
+		spared: result.spared.map(formatProcess),
 		stampFile: result.stampFile,
 	})}\n`);
 }

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

@@ -21,7 +21,7 @@ describe("CodeGraph SessionStart exclusion policy", () => {
 		const stdout: string[] = [];
 		const spawned: WorkerSpawnInvocation[] = [];
 		const stateRoot = createAllowedWorkspace("codegraph-omo-state");
-		const workspace = join(stateRoot, ".omo", "ultraresearch", "run", "clones", "repo");
+		const workspace = join(stateRoot, ".omo", "ulw-research", "run", "clones", "repo");
 		mkdirSync(workspace, { recursive: true });
 
 		try {

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

@@ -0,0 +1,148 @@
+import { describe, expect, it } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+
+import { executeCodegraphSessionStartHook, type WorkerSpawnInvocation } from "../src/hook.ts";
+
+const pluginRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));
+
+// Observed verbatim from a REAL codegraph 1.4.1 binary running `status --json` (exit 0)
+// against a project store built by a REAL codegraph 1.0.1 binary
+// (see .omo/evidence/codegraph-daemon-process-hygiene/task-2-store-upgrade.txt).
+const MIGRATED_1_0_1_STORE_STATUS_JSON = JSON.stringify({
+	initialized: true,
+	version: "1.4.1",
+	projectPath: "/private/tmp/cg-task2/fixture",
+	indexPath: "/private/tmp/cg-task2/fixture/.codegraph",
+	lastIndexed: "2026-07-21T04:28:09.593Z",
+	fileCount: 2,
+	nodeCount: 5,
+	edgeCount: 4,
+	dbSizeBytes: 159744,
+	backend: "node-sqlite",
+	journalMode: "wal",
+	nodesByKind: { file: 2, function: 3 },
+	languages: ["typescript"],
+	pendingChanges: { added: 0, modified: 0, removed: 0 },
+	worktreeMismatch: null,
+	index: {
+		builtWithVersion: "1.0.1",
+		builtWithExtractionVersion: 24,
+		currentExtractionVersion: 24,
+		reindexRecommended: false,
+		state: null,
+		pendingRefs: 0,
+	},
+});
+
+function createAllowedWorkspace(prefix: string): string {
+	return mkdtempSync(join(pluginRoot, `.tmp-${prefix}-`));
+}
+
+// On win32 execFile cannot run a #!/bin/sh script, so emit a codegraph.cmd batch file instead;
+// resolveCodegraphCommandInvocation wraps .cmd in `cmd.exe /d /s /c`, exactly like the real codegraph.cmd.
+function createFakeCodegraphBin(scripts: { readonly posix: string; readonly win32: string }): { readonly binPath: string; readonly dir: string } {
+	const dir = mkdtempSync(join(tmpdir(), "omo-codegraph-fake-bin-"));
+	if (process.platform === "win32") {
+		const binPath = join(dir, "codegraph.cmd");
+		writeFileSync(binPath, scripts.win32);
+		return { binPath, dir };
+	}
+	const binPath = join(dir, "codegraph");
+	writeFileSync(binPath, scripts.posix, { mode: 0o755 });
+	chmodSync(binPath, 0o755);
+	return { binPath, dir };
+}
+
+// Keep the probe hermetic on POSIX but viable on win32: resolveCodegraphCommandInvocation wraps
+// the fake .cmd in `cmd.exe /d /s /c`, and Windows can only resolve cmd.exe when the child env
+// carries the real system PATH (System32) plus SystemRoot (both whitelisted in SAFE_AMBIENT_ENV_KEYS).
+// A POSIX-only PATH makes the probe spawn fail, so the hook reports not-initialized and spawns.
+function probeEnv(homeDir: string, binPath: string): Record<string, string> {
+	if (process.platform === "win32") {
+		const env: Record<string, string> = {
+			HOME: homeDir,
+			OMO_CODEGRAPH_BIN: binPath,
+		};
+		if (process.env["PATH"] !== undefined) env["PATH"] = process.env["PATH"];
+		if (process.env["SystemRoot"] !== undefined) env["SystemRoot"] = process.env["SystemRoot"];
+		return env;
+	}
+	return { HOME: homeDir, OMO_CODEGRAPH_BIN: binPath, PATH: "/usr/bin:/bin" };
+}
+
+describe("CodeGraph SessionStart hook with a 1.0.1-era project store under the 1.4.1 binary", () => {
+	it("#given a real 1.4.1 status payload for a migrated 1.0.1 store #when SessionStart probes via the default probe #then it stays silent without spawning a re-init worker", async () => {
+		// given
+		const stdout: string[] = [];
+		const spawned: WorkerSpawnInvocation[] = [];
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-upgrade-home-"));
+		// The payload is a single JSON line with no cmd metacharacters (% ^ & < > |), so a plain echo is safe.
+		const fake = createFakeCodegraphBin({
+			posix: `#!/bin/sh\nprintf '%s\\n' '${MIGRATED_1_0_1_STORE_STATUS_JSON}'\n`,
+			win32: `@echo off\r\n@echo ${MIGRATED_1_0_1_STORE_STATUS_JSON}\r\n`,
+		});
+		const workspace = createAllowedWorkspace("codegraph-upgrade-workspace");
+		mkdirSync(join(workspace, ".codegraph"), { recursive: true });
+
+		try {
+			// when
+			const result = await executeCodegraphSessionStartHook({
+				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
+				cwd: workspace,
+				env: probeEnv(homeDir, fake.binPath),
+				stdin: Readable.from(["{}"]),
+				stdout: { write: (chunk) => stdout.push(chunk) },
+				spawnWorker: (invocation) => spawned.push(invocation),
+			});
+
+			// then
+			expect(result).toEqual({ action: "skipped-initialized", exitCode: 0 });
+			expect(spawned).toEqual([]);
+			expect(stdout.join("")).toBe("");
+		} finally {
+			rmSync(homeDir, { recursive: true, force: true });
+			rmSync(fake.dir, { recursive: true, force: true });
+			rmSync(workspace, { recursive: true, force: true, maxRetries: 10, retryDelay: 500 });
+		}
+	});
+
+	it("#given the status probe hangs past its 2s timeout #when SessionStart fires #then it exits zero promptly and spawns at most one bounded worker", async () => {
+		// given
+		const stdout: string[] = [];
+		const spawned: WorkerSpawnInvocation[] = [];
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-slow-home-"));
+		const fake = createFakeCodegraphBin({
+			posix: "#!/bin/sh\nsleep 30\n",
+			win32: "@echo off\r\nset /p _probe_hang=\r\n",
+		});
+		const workspace = createAllowedWorkspace("codegraph-slow-probe-workspace");
+
+		try {
+			// when
+			const startedAt = Date.now();
+			const result = await executeCodegraphSessionStartHook({
+				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
+				cwd: workspace,
+				env: probeEnv(homeDir, fake.binPath),
+				stdin: Readable.from(["{}"]),
+				stdout: { write: (chunk) => stdout.push(chunk) },
+				spawnWorker: (invocation) => spawned.push(invocation),
+			});
+			const elapsedMs = Date.now() - startedAt;
+
+			// then
+			expect(result.exitCode).toBe(0);
+			expect(result.action).toBe("spawned");
+			expect(spawned).toHaveLength(1);
+			expect(elapsedMs).toBeLessThan(15_000);
+		} finally {
+			rmSync(homeDir, { recursive: true, force: true });
+			rmSync(fake.dir, { recursive: true, force: true });
+			rmSync(workspace, { recursive: true, force: true, maxRetries: 10, retryDelay: 500 });
+		}
+	});
+});

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

@@ -1,5 +1,34 @@
 import { chmodSync, writeFileSync } from "node:fs";
 
+export const CODEGRAPH_141_DEFAULT_TOOLS: readonly Record<string, unknown>[] = [
+	{
+		name: "codegraph_explore",
+		description:
+			"PRIMARY TOOL — call FIRST for almost any question OR before an edit: how does X work, architecture, a bug, where/what is X, surveying an area, or the symbols you are about to change. Returns the verbatim source of the relevant symbols grouped by file in ONE capped call (Read-equivalent — treat the shown source as already Read; do NOT re-open those files), plus the call path among them. Query can be a natural-language question OR a bag of symbol/file names. Usually the ONLY call you need — more accurate context, in far fewer tokens and round-trips than a search/Read/Grep loop.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				query: {
+					type: "string",
+					description:
+						'Symbol names, file names, or short code terms to explore (e.g., "AuthService loginUser session-manager", "GraphTraverser BFS impact traversal.ts"). For a flow question, name the symbols spanning the flow (e.g. "mutateElement renderScene"). A natural-language question works too — no prior codegraph_search needed.',
+				},
+				maxFiles: {
+					type: "number",
+					description: "Maximum number of files to include source code from (default: 12)",
+					default: 12,
+				},
+				projectPath: {
+					type: "string",
+					description:
+						"Absolute path to the project to query (or any directory inside it) — codegraph uses the nearest .codegraph/ index at or above that path. Omit to use this session's default project. Pass it to query a second codebase, or when the server root has no index of its own (e.g. a monorepo where only sub-projects are indexed, so there is no default project).",
+				},
+			},
+			required: ["query"],
+		},
+	},
+];
+
 export function writeFakeNewlineCodegraph(filePath: string): void {
 	writeFileSync(
 		filePath,
@@ -12,10 +41,10 @@ export function writeFakeNewlineCodegraph(filePath: string): void {
 			"rl.on('line', (line) => {",
 			"  const request = JSON.parse(line);",
 			"  if (request.method === 'initialize') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { capabilities: { tools: { listChanged: false } }, protocolVersion: request.params.protocolVersion, serverInfo: { name: 'codegraph', version: '1.0.1' } } }) + '\\n');",
+			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { capabilities: { tools: { listChanged: false } }, protocolVersion: request.params.protocolVersion, serverInfo: { name: 'codegraph', version: '1.4.1' } } }) + '\\n');",
 			"  }",
 			"  if (request.method === 'tools/list') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: [{ name: 'codegraph_search' }, { name: 'codegraph_node' }, { name: 'codegraph_explore' }, { name: 'codegraph_callers' }] } }) + '\\n');",
+			`    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: ${JSON.stringify(CODEGRAPH_141_DEFAULT_TOOLS)} } }) + '\\n');`,
 			"  }",
 			"});",
 		].join("\n"),

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

@@ -43,7 +43,7 @@ describe("CodeGraph component runtime package metadata", () => {
 		const files = packageJson.files ?? [];
 
 		// then
-		expect(optionalDependencies["@colbymchenry/codegraph"]).toBe("1.0.1");
+		expect(optionalDependencies["@colbymchenry/codegraph"]).toBe("1.4.1");
 		expect(files).toContain("LICENSE");
 		expect(files).toContain("NODE-RUNTIME-LICENSES.md");
 		expect(files).toContain("NOTICE");

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

@@ -1,13 +1,15 @@
 import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { PassThrough, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
+import { isProcessAlive } from "../../../../../mcp-stdio-core/src/index.ts";
 import { runCodegraphServe } from "../src/serve.ts";
 import {
 	frameMcpRequest,
 	writeFakeExitingCodegraph,
+	writeFakeHeldOpenCodegraph,
 } from "./mcp-bridge-fixtures.ts";
 
 const componentRoot = realpathSync(
@@ -66,4 +68,66 @@ describe("runCodegraphServe MCP bridge lifecycle", () => {
 			rmSync(tempRoot, { recursive: true, force: true });
 		}
 	});
+
+	it("#given a held-open Codegraph child and a dead parent #when the bridge watchdog polls #then the child is terminated and the bridge settles through the child-exit path", async () => {
+		// given
+		const tempRoot = mkdtempSync(
+			join(componentRoot, ".tmp-codegraph-orphan-"),
+		);
+		const projectRoot = join(tempRoot, "project");
+		const fakeCodegraph = join(tempRoot, "codegraph-held-open.cjs");
+		const childPidFile = join(tempRoot, "child.pid");
+		// Client stdio is held open and never sees EOF, so the parent-liveness
+		// watchdog is the only settle path. The probe reports the parent alive
+		// until the child has started, making the poll fire deterministically.
+		const input = new PassThrough();
+		const output = new PassThrough();
+		output.resume();
+		let childPid: number | undefined;
+
+		try {
+			mkdirSync(projectRoot, { recursive: true });
+			writeFakeHeldOpenCodegraph(fakeCodegraph);
+			const run = runCodegraphServe({
+				cwd: tempRoot,
+				env: {
+					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
+					CODEGRAPH_FAKE_LOG: childPidFile,
+					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,
+				parentWatchdog: {
+					pollIntervalMs: 10,
+					probeAlive: () => !existsSync(childPidFile),
+				},
+			});
+
+			// when
+			const exitCode = await run;
+
+			// then
+			expect(exitCode).not.toBe(0);
+			childPid = Number(readFileSync(childPidFile, "utf8"));
+			expect(isProcessAlive(childPid)).toBe(false);
+		} finally {
+			if (childPid !== undefined && isProcessAlive(childPid)) {
+				process.kill(childPid, "SIGKILL");
+			}
+			input.destroy();
+			output.destroy();
+			rmSync(tempRoot, { recursive: true, force: true });
+		}
+	});
 });

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

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import { runCodegraphServe } from "../src/serve.ts";
 import {
 	arrayProperty,
+	CODEGRAPH_141_DEFAULT_TOOLS,
 	findTool,
 	frameMcpRequest,
 	parseMcpBodies,
@@ -86,19 +87,14 @@ describe("runCodegraphServe MCP protocol bridge", () => {
 					result: {
 						capabilities: { tools: { listChanged: false } },
 						protocolVersion: "2025-06-18",
-						serverInfo: { name: "codegraph", version: "1.0.1" },
+						serverInfo: { name: "codegraph", version: "1.4.1" },
 					},
 				},
 				{
 					id: 2,
 					jsonrpc: "2.0",
 					result: {
-						tools: [
-							{ name: "codegraph_search" },
-							{ name: "codegraph_node" },
-							{ name: "codegraph_explore" },
-							{ name: "codegraph_callers" },
-						],
+						tools: CODEGRAPH_141_DEFAULT_TOOLS,
 					},
 				},
 			]);