oh-my-opencode 4.19.0 → 4.19.2

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

@@ -0,0 +1,176 @@
+import { describe, expect, it } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, 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 win32Sidecar?: 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);
+		if (scripts.win32Sidecar !== undefined) writeFileSync(join(dir, "hang.cjs"), scripts.win32Sidecar);
+		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" };
+}
+
+function isProcessAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+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 spawns a hanging descendant #when SessionStart times out #then it exits promptly and reaps the descendant", async () => {
+		// given
+		const stdout: string[] = [];
+		const spawned: WorkerSpawnInvocation[] = [];
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-slow-home-"));
+		const survivorPidPath = join(homeDir, "survivor.pid");
+		const fake = createFakeCodegraphBin({
+			posix: "#!/bin/sh\nsleep 30 &\necho \"$!\" > \"$HOME/survivor.pid\"\nwait\n",
+			win32: '@echo off\r\nnode "%~dp0hang.cjs"\r\n',
+			win32Sidecar: [
+				'const { spawn } = require("node:child_process");',
+				'const { writeFileSync } = require("node:fs");',
+				'const { join } = require("node:path");',
+				'const child = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { stdio: "ignore" });',
+				'writeFileSync(join(process.env.HOME, "survivor.pid"), String(child.pid));',
+				"setInterval(() => {}, 1000);",
+				"",
+			].join("\n"),
+		});
+		const workspace = createAllowedWorkspace("codegraph-slow-probe-workspace");
+		let descendantPid: number | undefined;
+
+		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;
+			descendantPid = Number.parseInt(readFileSync(survivorPidPath, "utf8").trim(), 10);
+
+			// then
+			expect(result.exitCode).toBe(0);
+			expect(result.action).toBe("spawned");
+			expect(spawned).toHaveLength(1);
+			expect(elapsedMs).toBeLessThan(15_000);
+			expect(isProcessAlive(descendantPid)).toBeFalse();
+		} finally {
+			if (descendantPid !== undefined && isProcessAlive(descendantPid)) process.kill(descendantPid, "SIGKILL");
+			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/hook.test.ts

@@ -215,6 +215,7 @@ describe("CodeGraph SessionStart hook", () => {
 		// given
 		const stdout: string[] = [];
 		const spawned: WorkerSpawnInvocation[] = [];
+		const statusProbeDaemonValues: boolean[] = [];
 		const workspace = createAllowedWorkspace("codegraph-workspace");
 
 		try {
@@ -226,12 +227,16 @@ describe("CodeGraph SessionStart hook", () => {
 				stdin: Readable.from(["{}"]),
 				stdout: { write: (chunk) => stdout.push(chunk) },
 				spawnWorker: (invocation) => spawned.push(invocation),
-				statusProbe: () => Promise.resolve(false),
+				statusProbe: (options) => {
+					statusProbeDaemonValues.push(options.daemon);
+					return Promise.resolve(false);
+				},
 				workerCliPath: "/plugin/components/codegraph/dist/cli.js",
 			});
 
 			// then
 			expect(result).toEqual({ action: "spawned", exitCode: 0 });
+			expect(statusProbeDaemonValues).toEqual([true]);
 			expect(spawned).toEqual([
 				{
 					args: ["/plugin/components/codegraph/dist/cli.js", "hook", "session-start-worker"],

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/provisioned-node-guard.test.ts

@@ -3,6 +3,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { CODEGRAPH_PINNED_VERSION } from "../../../../../utils/src/codegraph/manifest.ts";
 import { runCodegraphSessionStartWorker } from "../src/hook.ts";
 import { runCodegraphServe } from "../src/serve.ts";
 
@@ -41,7 +42,12 @@ describe("CodeGraph provisioned launcher Node guard", () => {
 
 		try {
 			mkdirSync(join(installDir, "bin"), { recursive: true });
+			mkdirSync(join(installDir, ".provisioned"), { recursive: true });
 			writeFileSync(binPath, "");
+			writeFileSync(
+				join(installDir, ".provisioned", `codegraph-${CODEGRAPH_PINNED_VERSION}.json`),
+				`${JSON.stringify({ binPath, version: CODEGRAPH_PINNED_VERSION })}\n`,
+			);
 
 			// when
 			const result = await runCodegraphSessionStartWorker({

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,
 					},
 				},
 			]);

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

@@ -17,6 +17,7 @@ describe("runCodegraphServe MCP unavailable facade", () => {
 		const run = runCodegraphServe({
 			config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
 			env: { PATH: "/bin" },
+			nodeVersion: "22.14.0",
 			buildEnv: () => ({}),
 			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
 			stderr: { write: (chunk: string) => stderr.push(chunk) },
@@ -47,7 +48,7 @@ describe("runCodegraphServe MCP unavailable facade", () => {
 			result: {
 				capabilities: { tools: { listChanged: false } },
 				protocolVersion: "2025-06-18",
-				serverInfo: { name: "codegraph", version: "1.0.1" },
+				serverInfo: { name: "codegraph", version: "1.4.1" },
 			},
 		});
 	});

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

@@ -4,7 +4,7 @@ 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 () => {
+	it("#given CodeGraph is unresolved and daemon is omitted #when serving MCP #then provisions CodeGraph with daemon-on", async () => {
 		// given
 		const binPath = join("/tmp/home/.omo/codegraph", "bin", "codegraph");
 		const calls: Array<{
@@ -20,7 +20,6 @@ describe("runCodegraphServe provisioning", () => {
 			env: { PATH: "/bin" },
 			homeDir: "/tmp/home",
 			nodeVersion: "22.14.0",
-			buildEnv: () => ({}),
 			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
 			ensureProvisioned: (options) =>
 				Promise.resolve({
@@ -41,8 +40,63 @@ describe("runCodegraphServe provisioning", () => {
 			{
 				args: ["serve", "--mcp"],
 				command: binPath,
-				env: { CODEGRAPH_NO_DAEMON: "1", PATH: "/bin" },
+				env: {
+					CODEGRAPH_INSTALL_DIR: join("/tmp/home", ".omo", "codegraph"),
+					CODEGRAPH_NO_DOWNLOAD: "1",
+					CODEGRAPH_TELEMETRY: "0",
+					DO_NOT_TRACK: "1",
+					PATH: "/bin",
+				},
 			},
 		]);
 	});
+
+	it("#given CodeGraph is unresolved and codegraph.daemon=false #when serving MCP #then provisions CodeGraph with daemon-off", 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: { daemon: false, enabled: true }, sources: [], warnings: [] },
+			env: { PATH: "/bin" },
+			homeDir: "/tmp/home",
+			nodeVersion: "22.14.0",
+			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: {
+					CODEGRAPH_INSTALL_DIR: join("/tmp/home", ".omo", "codegraph"),
+					CODEGRAPH_NO_DAEMON: "1",
+					CODEGRAPH_NO_DOWNLOAD: "1",
+					CODEGRAPH_TELEMETRY: "0",
+					DO_NOT_TRACK: "1",
+					PATH: "/bin",
+				},
+			},
+		]);
+		expect(calls[0]?.env["CODEGRAPH_NO_DAEMON"]).toBe("1");
+	});
 });

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

@@ -17,6 +17,7 @@ describe("runCodegraphServe unavailable CodeGraph paths", () => {
 			...closedMcpStdio(),
 			config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
 			env: { PATH: "/bin" },
+			nodeVersion: "22.14.0",
 			buildEnv: () => ({}),
 			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
 			runProcess: (command: string) => {
@@ -122,6 +123,47 @@ describe("runCodegraphServe unavailable CodeGraph paths", () => {
 			rmSync(workspace, { recursive: true, force: true });
 		}
 	});
+
+	it("#given the unavailable facade with held-open stdio and a dead parent #when the watchdog polls #then the placeholder server settles without waiting for stdin EOF", async () => {
+		// given
+		// win32: the real-timer watchdog + PassThrough.destroy() teardown race leaves
+		// the read loop's async iterator pending on Windows, so this held-open-stdin
+		// case cannot settle under bun:test (which has no fake timers). The watchdog
+		// settle path IS covered deterministically by mcp-stdio-core's fake-timer test
+		// (passes on win32) and by real-process QA (task-13-*); production settles via
+		// stdin EOF, exercised by the other tests in this file that run on win32.
+		if (process.platform === "win32") return;
+		// Client stdio is held open and never sees EOF, so the parent-liveness
+		// watchdog is the only settle path for the placeholder server.
+		const stdin = new PassThrough();
+		const stdout = new PassThrough();
+		stdout.resume();
+		const stderr: string[] = [];
+
+		try {
+			// when
+			const exitCode = await runCodegraphServe({
+				config: { codegraph: { enabled: false }, sources: [], warnings: [] },
+				env: {},
+				stdin,
+				stdout,
+				stderr: { write: (chunk: string) => stderr.push(chunk) },
+				parentWatchdog: { pollIntervalMs: 10, probeAlive: () => false },
+			});
+
+			// then
+			expect(exitCode).toBe(0);
+			expect(stderr).toEqual([
+				"CodeGraph MCP skipped: disabled by OMO SOT config. Set [codex].codegraph.enabled=true to enable it.\n",
+			]);
+		} finally {
+			// The held-open streams are never ended by the test; destroy them so the
+			// bun test runner's event loop can drain and exit (an undestroyed
+			// PassThrough keeps the process alive on win32 and hangs the suite).
+			stdin.destroy();
+			stdout.destroy();
+		}
+	});
 });
 
 function closedMcpStdio(): { readonly stdin: PassThrough; readonly stdout: PassThrough } {