oh-my-opencode 4.19.0 → 4.19.2

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-codegraph",
-	"version": "4.19.0",
+	"version": "4.19.2",
 	"description": "Codex plugin MCP wrapper for CodeGraph.",
 	"type": "module",
 	"private": true,
@@ -25,7 +25,7 @@
 		"typescript": "^6.0.3"
 	},
 	"optionalDependencies": {
-		"@colbymchenry/codegraph": "1.0.1"
+		"@colbymchenry/codegraph": "1.4.1"
 	},
 	"engines": {
 		"node": ">=20.0.0"

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

@@ -1,6 +1,7 @@
 import type { Readable } from "node:stream";
 
 import type { CodexOmoConfig as SharedCodexOmoConfig } from "../../../shared/src/config-loader.ts";
+import type { CODEGRAPH_PINNED_VERSION } from "../../../../../utils/src/codegraph/manifest.ts";
 import type { SweepCodegraphZombiesOptions } from "../../../../../utils/src/codegraph/process-sweep.ts";
 import type { CodegraphProvisionResult as SharedCodegraphProvisionResult } from "../../../../../utils/src/codegraph/provision.ts";
 import type {
@@ -58,7 +59,7 @@ export interface CodegraphSessionStartOutcome {
 
 export interface CodegraphSessionStartDeps {
 	readonly ensureGitignored: (projectRoot: string) => boolean;
-	readonly ensureProvisioned: (options: { readonly installDir?: string; readonly lockDir: string; readonly version: "1.0.1" }) => Promise<CodegraphProvisionResult>;
+	readonly ensureProvisioned: (options: { readonly installDir?: string; readonly lockDir: string; readonly version: typeof CODEGRAPH_PINNED_VERSION }) => Promise<CodegraphProvisionResult>;
 	readonly prepareWorkspace: (projectRoot: string, options: { readonly homeDir: string }) => CodegraphWorkspacePreparation;
 	readonly resolveCommand: (options?: ResolveCodegraphCommandOptions) => CodegraphCommandResolution;
 	readonly runCommand: (
@@ -76,6 +77,7 @@ export interface SessionStartHookOptions {
 	readonly env?: Record<string, string | undefined>;
 	readonly spawnWorker?: (invocation: WorkerSpawnInvocation) => void;
 	readonly statusProbe?: (options: {
+		readonly daemon: boolean;
 		readonly env: Record<string, string | undefined>;
 		readonly homeDir: string;
 		readonly projectRoot: string;

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

@@ -1,6 +1,5 @@
-import { execFile, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { join } from "node:path";
 import {
 	cwd as processCwd,
 	env as processEnv,
@@ -13,7 +12,9 @@ import { fileURLToPath } from "node:url";
 
 import { buildCodegraphChildEnv, buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
 import { buildCodegraphInitGuidanceForToolResult } from "../../../../../utils/src/codegraph/guidance.ts";
+import { resolvePinnedCodegraphBin } from "../../../../../utils/src/codegraph/managed-runtime.ts";
 import { resolveCodegraphCommand } from "../../../../../utils/src/codegraph/resolve.ts";
+import { runProcessWithTreeTimeout } from "../../../../../utils/src/process-tree.ts";
 import { shouldExcludeCodegraphProject } from "../../../../../utils/src/codegraph/workspace.ts";
 import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
 import { pruneCodegraphProjectStoresBestEffort } from "./cache-gc.js";
@@ -66,13 +67,6 @@ export async function executeCodegraphSessionStartHook(options: SessionStartHook
 	const projectRoot = resolveProjectRoot(input, options.cwd ?? processCwd());
 	const homeDir = resolveHomeDir(env);
 	const config = options.config ?? getCodexOmoConfig({ cwd: projectRoot, env, homeDir });
-	pruneCodegraphProjectStoresBestEffort(homeDir, { debugLog: writeDebugLog });
-	await sweepCodegraphZombiesBestEffort({
-		env,
-		homeDir,
-		...(config.trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir: config.trustedCodegraphInstallDir }),
-		log: writeDebugLog,
-	}, options.sweepZombies);
 
 	if (config.codegraph?.enabled === false) {
 		return { action: "skipped-disabled", exitCode: 0 };
@@ -86,7 +80,16 @@ export async function executeCodegraphSessionStartHook(options: SessionStartHook
 		return { action: "skipped-excluded", exitCode: 0 };
 	}
 
+	pruneCodegraphProjectStoresBestEffort(homeDir, { debugLog: writeDebugLog });
+	await sweepCodegraphZombiesBestEffort({
+		env,
+		homeDir,
+		...(config.trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir: config.trustedCodegraphInstallDir }),
+		log: writeDebugLog,
+	}, options.sweepZombies);
+
 	const isInitialized = await (options.statusProbe ?? isCodegraphProjectInitialized)({
+		daemon: config.codegraph?.daemon !== false,
 		env,
 		homeDir,
 		projectRoot,
@@ -110,6 +113,7 @@ export async function executeCodegraphSessionStartHook(options: SessionStartHook
 }
 
 async function isCodegraphProjectInitialized(options: {
+	readonly daemon: boolean;
 	readonly env: Record<string, string | undefined>;
 	readonly homeDir: string;
 	readonly projectRoot: string;
@@ -124,7 +128,7 @@ async function isCodegraphProjectInitialized(options: {
 
 	const invocation = resolveCodegraphCommandInvocation(resolved.command, [...resolved.argsPrefix, "status", "--json"]);
 	const codegraphEnv = {
-		...buildCodegraphEnv({ homeDir: options.homeDir }),
+		...buildCodegraphEnv({ daemon: options.daemon, homeDir: options.homeDir }),
 		...(options.trustedCodegraphInstallDir === undefined ? {} : { CODEGRAPH_INSTALL_DIR: options.trustedCodegraphInstallDir }),
 	};
 	const status = await runStatusProbe(
@@ -143,27 +147,14 @@ function runStatusProbe(
 	args: readonly string[],
 	env: Record<string, string>,
 ): Promise<{ readonly exitCode: number; readonly stdout: string; readonly timedOut: boolean }> {
-	return new Promise((resolveProbe) => {
-		execFile(
-			command,
-			[...args],
-			{
-				cwd: projectRoot,
-				encoding: "utf8",
-				env,
-				maxBuffer: 1024 * 1024,
-				timeout: STATUS_PROBE_TIMEOUT_MS,
-				windowsHide: true,
-			},
-			(error, stdout) => {
-				if (error === null) {
-					resolveProbe({ exitCode: 0, stdout: toOutputText(stdout), timedOut: false });
-					return;
-				}
-				resolveProbe({ exitCode: resolveExitCode(error), stdout: toOutputText(stdout), timedOut: error.killed === true });
-			},
-		);
-	});
+	return runProcessWithTreeTimeout({
+		args,
+		command,
+		cwd: projectRoot,
+		env,
+		maxBuffer: 1024 * 1024,
+		timeoutMs: STATUS_PROBE_TIMEOUT_MS,
+	}).then(({ exitCode, stdout, timedOut }) => ({ exitCode, stdout, timedOut }));
 }
 
 function codegraphStatusSaysInitialized(stdout: string): boolean {
@@ -178,8 +169,7 @@ function codegraphStatusSaysInitialized(stdout: string): boolean {
 }
 
 function provisionedBinFromInstallDir(installDir: string | undefined): string | null {
-	if (installDir === undefined) return null;
-	return join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
+	return resolvePinnedCodegraphBin(installDir);
 }
 
 export async function executeCodegraphPostToolUseHook(options: PostToolUseHookOptions = {}): Promise<PostToolUseHookResult> {
@@ -231,15 +221,6 @@ function resolveHomeDir(env: Record<string, string | undefined>): string {
 	return env["HOME"] ?? env["USERPROFILE"] ?? homedir();
 }
 
-function resolveExitCode(error: Error): number {
-	if ("code" in error && typeof error.code === "number") return error.code;
-	return 1;
-}
-
-function toOutputText(value: string | Buffer): string {
-	return Buffer.isBuffer(value) ? value.toString("utf8") : value;
-}
-
 function resolveProjectRoot(input: unknown, fallback: string): string {
 	if (!isRecord(input)) return fallback;
 	const cwd = input["cwd"];

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

@@ -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,12 @@ 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 { resolvePinnedCodegraphBin } from "../../../../../utils/src/codegraph/managed-runtime.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 +50,7 @@ export interface CodegraphServeProcessOptions {
 	readonly output: Writable;
 	readonly stderr: CodegraphServeStderr;
 	readonly stdio: ServeStdio;
+	readonly parentWatchdog?: ParentWatchdogConfig;
 }
 
 export type CodegraphServeProcessRunner = (
@@ -64,7 +67,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 +80,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 +91,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 +143,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 !== false, options.buildEnv);
 	const mergedEnv = buildCodegraphChildEnv({ ambientEnv: env, codegraphEnv, runtimeEnv: env });
 	return runProcess(resolution.command, [...resolution.argsPrefix, "serve", "--mcp"], {
 		cwd: projectCwd,
@@ -145,6 +152,7 @@ export async function runCodegraphServe(options: RunCodegraphServeOptions = {}):
 		output: options.stdout ?? processStdout,
 		stderr: options.stderr ?? processStderr,
 		stdio: "pipe",
+		parentWatchdog: options.parentWatchdog ?? {},
 	});
 }
 
@@ -155,6 +163,7 @@ async function runUnavailableMcp(reason: string, options: RunCodegraphServeOptio
 		output: options.stdout ?? processStdout,
 		reason,
 		serverVersion: CODEGRAPH_VERSION,
+		parentWatchdog: options.parentWatchdog ?? {},
 	});
 	return 0;
 }
@@ -195,9 +204,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 };
 }
 
@@ -212,9 +222,7 @@ function resolveProjectCwd(env: Record<string, string | undefined>, fallback: st
 }
 
 function provisionedBinFromInstallDir(installDir: string | undefined): string | null {
-	if (installDir === undefined) return null;
-	const candidate = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
-	return existsSync(candidate) ? candidate : null;
+	return resolvePinnedCodegraphBin(installDir);
 }
 
 export async function runCodegraphServeCli(): Promise<void> {

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

@@ -1,11 +1,12 @@
-import { execFile } from "node:child_process";
-import { appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { appendFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { extname, join } from "node:path";
 import { cwd as processCwd, env as processEnv, execPath as processExecPath, stderr as processStderr } from "node:process";
 
 import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
 import { buildCodegraphChildEnv, buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
+import { resolvePinnedCodegraphBin } from "../../../../../utils/src/codegraph/managed-runtime.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 {
@@ -14,6 +15,7 @@ import {
 	type CodegraphCommandResolution,
 } from "../../../../../utils/src/codegraph/resolve.ts";
 import { ensureCodegraphGitignored, prepareCodegraphWorkspace } from "../../../../../utils/src/codegraph/workspace.ts";
+import { runProcessWithTreeTimeout } from "../../../../../utils/src/process-tree.ts";
 import type {
 	CodegraphCommandResult,
 	CodegraphConfig,
@@ -25,7 +27,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 +129,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 };
 }
 
@@ -160,15 +165,14 @@ function jsonSaysInitialized(value: unknown): boolean | undefined {
 
 async function runCodegraphCommand(projectRoot: string, command: string, args: readonly string[], options: { readonly env: Record<string, string>; readonly timeoutMs: number }): Promise<CodegraphCommandResult> {
 	const invocation = resolveCodegraphCommandInvocation(command, args);
-	return new Promise((resolvePromise) => {
-		execFile(invocation.command, [...invocation.args], { cwd: projectRoot, encoding: "utf8", env: buildCodegraphChildEnv({ ambientEnv: processEnv, codegraphEnv: options.env }), maxBuffer: 1024 * 1024, timeout: options.timeoutMs, windowsHide: true }, (error, stdout, stderr) => {
-			if (error === null) {
-				resolvePromise({ exitCode: 0, stderr: toOutputText(stderr), stdout: toOutputText(stdout), timedOut: false });
-				return;
-			}
-			resolvePromise({ exitCode: resolveExitCode(error), stderr: toOutputText(stderr), stdout: toOutputText(stdout), timedOut: error.killed === true });
-		});
-	});
+	return runProcessWithTreeTimeout({
+		args: invocation.args,
+		command: invocation.command,
+		cwd: projectRoot,
+		env: buildCodegraphChildEnv({ ambientEnv: processEnv, codegraphEnv: options.env }),
+		maxBuffer: 1024 * 1024,
+		timeoutMs: options.timeoutMs,
+	}).then(({ exitCode, stderr, stdout, timedOut }) => ({ exitCode, stderr, stdout, timedOut }));
 }
 
 export function resolveCodegraphCommandInvocation(
@@ -199,18 +203,7 @@ function safeLogOutcome(logOutcome: (outcome: CodegraphSessionStartOutcome) => v
 }
 
 function provisionedBinFromInstallDir(installDir: string | undefined): string | null {
-	if (installDir === undefined) return null;
-	const candidate = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
-	return existsSync(candidate) ? candidate : null;
-}
-
-function resolveExitCode(error: Error): number {
-	if ("code" in error && typeof error.code === "number") return error.code;
-	return 1;
-}
-
-function toOutputText(value: string | Buffer): string {
-	return Buffer.isBuffer(value) ? value.toString("utf8") : value;
+	return resolvePinnedCodegraphBin(installDir);
 }
 
 function resolveHomeDir(env: Record<string, string | undefined>): string {

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

@@ -20,6 +20,7 @@ describe("CodeGraph SessionStart exclusion policy", () => {
 		// given
 		const stdout: string[] = [];
 		const spawned: WorkerSpawnInvocation[] = [];
+		let sweepCalls = 0;
 		const stateRoot = createAllowedWorkspace("codegraph-omo-state");
 		const workspace = join(stateRoot, ".omo", "ulw-research", "run", "clones", "repo");
 		mkdirSync(workspace, { recursive: true });
@@ -36,10 +37,14 @@ describe("CodeGraph SessionStart exclusion policy", () => {
 				statusProbe: () => {
 					throw new Error("excluded projects must not probe CodeGraph status");
 				},
+				sweepZombies: () => {
+					sweepCalls += 1;
+				},
 			});
 
 			// then
 			expect(result).toEqual({ action: "skipped-excluded", exitCode: 0 });
+			expect(sweepCalls).toBe(0);
 			expect(spawned).toEqual([]);
 			expect(stdout.join("")).toBe("");
 		} finally {