oh-my-opencode 5.0.0-beta.33 → 5.0.0-beta.35

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

@@ -1,33 +0,0 @@
-{
-	"name": "@sisyphuslabs/codex-codegraph",
-	"version": "5.0.0-beta.33",
-	"description": "Codex plugin MCP wrapper for CodeGraph.",
-	"type": "module",
-	"private": true,
-	"bin": {
-		"omo-codegraph": "./dist/cli.js"
-	},
-	"files": [
-		"dist",
-		"LICENSE",
-		"NODE-RUNTIME-LICENSES.md",
-		"NOTICE"
-	],
-	"scripts": {
-		"build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && bun build src/serve.ts --target node --format esm --outfile dist/serve.js && bun build src/cli.ts --target node --format esm --outfile dist/cli.js",
-		"test": "bun test ./test",
-		"typecheck": "tsc --noEmit"
-	},
-	"devDependencies": {
-		"@oh-my-opencode/utils": "file:../../../../utils",
-		"@types/node": "^26.2.0",
-		"bun-types": "^1.4.0",
-		"typescript": "^7.0.2"
-	},
-	"optionalDependencies": {
-		"@colbymchenry/codegraph": "1.5.0"
-	},
-	"engines": {
-		"node": ">=20.0.0"
-	}
-}

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

@@ -1,29 +0,0 @@
-import {
-	pruneDeadCodegraphProjectStores,
-	type PruneCodegraphStoreResult,
-} from "../../../../../utils/src/codegraph/workspace.ts";
-
-interface PruneCodegraphProjectStoresBestEffortOptions {
-	readonly debugLog?: (message: string) => void;
-	readonly prune?: (options: { readonly homeDir: string }) => PruneCodegraphStoreResult;
-}
-
-const NON_FATAL_GC_ERROR_CODES = new Set(["EACCES", "EBUSY", "ENOENT", "ENOTEMPTY", "ENOTDIR", "EPERM"]);
-
-export function pruneCodegraphProjectStoresBestEffort(
-	homeDir: string,
-	options: PruneCodegraphProjectStoresBestEffortOptions = {},
-): void {
-	try {
-		(options.prune ?? pruneDeadCodegraphProjectStores)({ homeDir });
-	} catch (error) {
-		if (!isNonFatalCodegraphGcError(error)) throw error;
-		options.debugLog?.(`CodeGraph cache GC skipped: ${error.message}`);
-	}
-}
-
-export function isNonFatalCodegraphGcError(error: unknown): error is Error {
-	if (!(error instanceof Error)) return false;
-	const code = typeof error === "object" && error !== null && "code" in error ? (error as { readonly code?: unknown }).code : undefined;
-	return typeof code === "string" && NON_FATAL_GC_ERROR_CODES.has(code);
-}

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

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-import { realpathSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { stderr as processStderr } from "node:process";
-import { fileURLToPath } from "node:url";
-
-import {
-	runCodegraphPostToolUseHookCli,
-	runCodegraphSessionStartHook,
-	runCodegraphSessionStartWorker,
-	type PostToolUseHookOptions,
-	type SessionStartHookOptions,
-	type SessionStartWorkerOptions,
-} from "./hook.js";
-import { runCodegraphServeCli } from "./serve.js";
-import { runCodegraphSweepCli, type RunCodegraphSweepCliOptions } from "./sweep-cli.js";
-
-export interface RunCodegraphCliOptions extends SessionStartHookOptions {
-	readonly sweepOptions?: SweepCodegraphZombiesTestOptions;
-	readonly workerOptions?: SessionStartWorkerOptions;
-}
-
-type SweepCodegraphZombiesTestOptions = Omit<RunCodegraphSweepCliOptions, "argv" | "env" | "stdout">;
-
-export async function runCodegraphCli(options: RunCodegraphCliOptions = {}): Promise<number> {
-	const argv = options.argv ?? process.argv;
-	const command = argv[2];
-	const subcommand = argv[3];
-
-	if (command === "sweep") {
-		return runCodegraphSweepCli({
-			...options.sweepOptions,
-			argv,
-			...(options.env === undefined ? {} : { env: options.env }),
-			...(options.stdout === undefined ? {} : { stdout: options.stdout }),
-		});
-	}
-
-	if (command === "hook" && subcommand === "session-start") {
-		return runCodegraphSessionStartHook(options);
-	}
-
-	if (command === "hook" && subcommand === "post-tool-use") {
-		const hookOptions: PostToolUseHookOptions = {
-			...(options.env === undefined ? {} : { env: options.env }),
-			...(options.stdin === undefined ? {} : { stdin: options.stdin }),
-			...(options.stdout === undefined ? {} : { stdout: options.stdout }),
-		};
-		return runCodegraphPostToolUseHookCli(hookOptions);
-	}
-
-	if (command === "hook" && subcommand === "session-start-worker") {
-		const workerOptions: SessionStartWorkerOptions = {
-			...options.workerOptions,
-			...(options.workerOptions?.cwd === undefined && options.cwd !== undefined ? { cwd: options.cwd } : {}),
-			...(options.workerOptions?.env === undefined && options.env !== undefined ? { env: options.env } : {}),
-		};
-		await runCodegraphSessionStartWorker(workerOptions);
-		return 0;
-	}
-
-	await runCodegraphServeCli();
-	return process.exitCode === undefined ? 0 : Number(process.exitCode);
-}
-
-if (isDirectInvocation(process.argv[1])) {
-	runCodegraphCli().catch((error: unknown) => {
-		processStderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
-		process.exitCode = 1;
-	});
-}
-
-function isDirectInvocation(argvPath: string | undefined): boolean {
-	if (argvPath === undefined) return false;
-	const modulePath = fileURLToPath(import.meta.url);
-	const moduleName = basename(modulePath);
-	if (moduleName !== "cli.js" && moduleName !== "cli.ts") return false;
-	return realpathSync(resolve(argvPath)) === realpathSync(modulePath);
-}

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

@@ -1,33 +0,0 @@
-import { homedir } from "node:os";
-import type { Readable } from "node:stream";
-
-export function resolveHomeDir(env: Record<string, string | undefined>): string {
-	return env["HOME"] ?? env["USERPROFILE"] ?? homedir();
-}
-
-export function resolveHookProjectRoot(input: unknown, fallback: string): string {
-	if (!isRecord(input)) return fallback;
-	const cwd = input["cwd"];
-	return typeof cwd === "string" && cwd.trim().length > 0 ? cwd : fallback;
-}
-
-export async function readHookInput(stdin: Readable & { readonly isTTY?: boolean }): Promise<unknown> {
-	if (stdin.isTTY === true) return undefined;
-	let text = "";
-	for await (const chunk of stdin) text += typeof chunk === "string" ? chunk : String(chunk);
-	if (text.trim().length === 0) return undefined;
-	return parseJson(text);
-}
-
-export function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}
-
-function parseJson(text: string): unknown {
-	try {
-		return JSON.parse(text);
-	} catch (error) {
-		if (error instanceof SyntaxError) return undefined;
-		throw error;
-	}
-}

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

@@ -1,25 +0,0 @@
-import { fileURLToPath } from "node:url";
-
-import {
-	sweepCodegraphZombies,
-	type SweepCodegraphZombiesOptions,
-} from "../../../../../utils/src/codegraph/process-sweep.ts";
-
-export async function sweepCodegraphZombiesBestEffort(
-	options: Omit<SweepCodegraphZombiesOptions, "pluginRoot">,
-	sweep: (options: SweepCodegraphZombiesOptions) => Promise<unknown> | unknown = sweepCodegraphZombies,
-): Promise<void> {
-	try {
-		await sweep({
-			...options,
-			pluginRoot: defaultPluginRoot(),
-			...(options.log === undefined ? {} : { log: options.log }),
-		});
-	} catch (error) {
-		options.log?.(`CodeGraph zombie sweep skipped: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-
-function defaultPluginRoot(): string {
-	return fileURLToPath(new URL("../../..", import.meta.url));
-}

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

@@ -1,131 +0,0 @@
-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 {
-	CodegraphCommandResolution,
-	ResolveCodegraphCommandOptions,
-} from "../../../../../utils/src/codegraph/resolve.ts";
-import type { CodegraphWorkspacePreparation as SharedCodegraphWorkspacePreparation } from "../../../../../utils/src/codegraph/workspace.ts";
-import type { CodegraphConfig as SharedCodegraphConfig } from "../../../../../utils/src/omo-config.ts";
-import type { CodegraphAncestorState, CodegraphProjectState } from "./session-start-project.js";
-
-export type SessionStartAction =
-	| "skipped-cooldown"
-	| "skipped-disabled"
-	| "skipped-excluded"
-	| "skipped-inconclusive"
-	| "skipped-initialized"
-	| "skipped-locked"
-	| "skipped-nested-root"
-	| "skipped-spawn-error"
-	| "spawned";
-export type PostToolUseAction = "emitted-guidance" | "skipped";
-export type WorkerAction =
-	| "failed"
-	| "initialized"
-	| "skipped-disabled"
-	| "skipped-initialized"
-	| "skipped-locked"
-	| "skipped-nested-root"
-	| "skipped-probe-error"
-	| "skipped-status"
-	| "skipped-unavailable"
-	| "skipped-unsupported-node"
-	| "synced";
-export type SessionStartOutcomeAction = SessionStartAction | WorkerAction;
-
-export interface WorkerSpawnInvocation {
-	readonly args: readonly string[];
-	readonly command: string;
-	readonly env: Record<string, string | undefined>;
-}
-
-export interface HookStdout {
-	readonly write: (chunk: string) => void;
-}
-
-export interface SessionStartHookResult {
-	readonly action: SessionStartAction;
-	readonly exitCode: 0;
-}
-
-export interface PostToolUseHookResult {
-	readonly action: PostToolUseAction;
-	readonly exitCode: 0;
-}
-
-export interface CodegraphCommandResult {
-	readonly exitCode: number;
-	readonly stderr?: string;
-	readonly stdout: string;
-	readonly timedOut: boolean;
-}
-
-export type CodegraphConfig = Partial<SharedCodegraphConfig>;
-export type CodexOmoConfig = SharedCodexOmoConfig;
-export type OmoConfigSource = CodexOmoConfig["sources"][number];
-export type CodegraphProvisionResult = SharedCodegraphProvisionResult;
-export type CodegraphWorkspacePreparation = SharedCodegraphWorkspacePreparation;
-
-export interface CodegraphSessionStartOutcome {
-	readonly action: SessionStartOutcomeAction;
-	readonly ancestorRoot?: string;
-	readonly cooldownUntil?: number;
-	readonly error?: string;
-	readonly exitCode?: number;
-	readonly failureCount?: number;
-	readonly projectRoot?: string;
-	readonly source?: CodegraphCommandResolution["source"];
-	readonly timedOut?: boolean;
-}
-
-export interface CodegraphSessionStartDeps {
-	readonly ensureGitignored: (projectRoot: string) => boolean;
-	readonly ensureProvisioned: (options: { readonly installDir?: string; readonly lockDir: string; readonly version: typeof CODEGRAPH_PINNED_VERSION }) => Promise<CodegraphProvisionResult>;
-	readonly managedInstallExists: (installDir: string) => boolean;
-	readonly prepareWorkspace: (projectRoot: string, options: { readonly homeDir: string }) => CodegraphWorkspacePreparation;
-	readonly resolveCommand: (options?: ResolveCodegraphCommandOptions) => CodegraphCommandResolution;
-	readonly resolveManagedBin: (installDir: string) => string | null;
-	readonly runCommand: (
-		projectRoot: string,
-		command: string,
-		args: readonly string[],
-		options: { readonly env: Record<string, string>; readonly timeoutMs: number },
-	) => Promise<CodegraphCommandResult>;
-}
-
-export interface SessionStartHookOptions {
-	readonly ancestorProbe?: (projectRoot: string) => CodegraphAncestorState;
-	readonly argv?: readonly string[];
-	readonly config?: CodexOmoConfig;
-	readonly cwd?: string;
-	readonly env?: Record<string, string | undefined>;
-	readonly lockStaleMs?: number;
-	readonly logOutcome?: (outcome: CodegraphSessionStartOutcome) => void;
-	readonly nowMs?: number;
-	readonly spawnWorker?: (invocation: WorkerSpawnInvocation) => void;
-	readonly stdin?: Readable & { readonly isTTY?: boolean };
-	readonly stdout?: HookStdout;
-	readonly sweepZombies?: (options: SweepCodegraphZombiesOptions) => Promise<unknown> | unknown;
-	readonly workerCliPath?: string;
-}
-
-export interface PostToolUseHookOptions {
-	readonly env?: Record<string, string | undefined>;
-	readonly stdin?: Readable & { readonly isTTY?: boolean };
-	readonly stdout?: HookStdout;
-}
-
-export interface SessionStartWorkerOptions {
-	readonly config?: CodexOmoConfig;
-	readonly cwd?: string;
-	readonly deps?: Partial<CodegraphSessionStartDeps>;
-	readonly env?: Record<string, string | undefined>;
-	readonly logOutcome?: (outcome: CodegraphSessionStartOutcome) => void;
-	readonly nodeVersion?: string;
-	readonly nowMs?: number;
-	readonly projectProbe?: (projectRoot: string) => CodegraphProjectState;
-}

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

@@ -1,258 +0,0 @@
-import {
-	cwd as processCwd,
-	env as processEnv,
-	stderr as processStderr,
-	stdin as processStdin,
-	stdout as processStdout,
-} from "node:process";
-import { fileURLToPath } from "node:url";
-
-import { buildCodegraphChildEnv } from "../../../../../utils/src/codegraph/env.ts";
-import { shouldExcludeCodegraphProject } from "../../../../../utils/src/codegraph/workspace.ts";
-import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
-import { pruneCodegraphProjectStoresBestEffort } from "./cache-gc.js";
-import { readHookInput, resolveHomeDir, resolveHookProjectRoot } from "./hook-input.js";
-import { sweepCodegraphZombiesBestEffort } from "./hook-sweep.js";
-import type {
-	CodegraphSessionStartOutcome,
-	SessionStartHookOptions,
-	SessionStartHookResult,
-} from "./hook-types.js";
-import {
-	DEFAULT_SESSION_START_COOLDOWN_MS,
-	readSessionStartCooldown,
-	recordSessionStartFailure,
-} from "./session-start-cooldown.js";
-import { spawnDetachedSessionStartWorker, writeSessionStartNotice } from "./session-start-hook-runtime.js";
-import { acquireSessionStartLock, releaseSessionStartLock, type SessionStartLock } from "./session-start-lock.js";
-import { appendSessionStartOutcome } from "./session-start-outcome.js";
-import {
-	probeCodegraphAncestors,
-	probeExactCodegraphProject,
-	type CodegraphProjectState,
-} from "./session-start-project.js";
-import { SESSION_START_CWD_ENV, SESSION_START_LOCK_TOKEN_ENV } from "./session-start-worker.js";
-
-export type {
-	CodegraphCommandResult,
-	CodegraphConfig,
-	CodegraphProvisionResult,
-	CodegraphSessionStartDeps,
-	CodegraphSessionStartOutcome,
-	CodegraphWorkspacePreparation,
-	CodexOmoConfig,
-	HookStdout,
-	OmoConfigSource,
-	PostToolUseHookOptions,
-	PostToolUseHookResult,
-	SessionStartAction,
-	SessionStartHookOptions,
-	SessionStartHookResult,
-	SessionStartWorkerOptions,
-	WorkerAction,
-	WorkerSpawnInvocation,
-} from "./hook-types.js";
-export {
-	executeCodegraphPostToolUseHook,
-	runCodegraphPostToolUseHook,
-	runCodegraphPostToolUseHookCli,
-} from "./post-tool-use-hook.js";
-export { resolveCodegraphCommandInvocation } from "./session-start-command.js";
-export { runCodegraphSessionStartWorker } from "./session-start-worker.js";
-
-export const CODEGRAPH_SESSION_START_NOTICE = "LazyCodex CodeGraph bootstrap scheduled in background";
-export const DEFAULT_SESSION_START_LOCK_STALE_MS = 10 * 60 * 1_000;
-
-type HookContext = {
-	readonly baseCooldownMs: number;
-	readonly env: Record<string, string | undefined>;
-	readonly homeDir: string;
-	readonly logOutcome: (outcome: CodegraphSessionStartOutcome) => void;
-	readonly nowMs: number;
-	readonly options: SessionStartHookOptions;
-	readonly projectRoot: string;
-};
-
-export async function runCodegraphSessionStartHook(options: SessionStartHookOptions = {}): Promise<number> {
-	return (await executeCodegraphSessionStartHook(options)).exitCode;
-}
-
-export async function executeCodegraphSessionStartHook(options: SessionStartHookOptions = {}): Promise<SessionStartHookResult> {
-	const env = options.env ?? processEnv;
-	const input = await readHookInput(options.stdin ?? processStdin);
-	const projectRoot = resolveHookProjectRoot(input, options.cwd ?? processCwd());
-	const homeDir = resolveHomeDir(env);
-	const config = options.config ?? getCodexOmoConfig({ cwd: projectRoot, env, homeDir });
-	if (config.codegraph?.enabled === false) return { action: "skipped-disabled", exitCode: 0 };
-
-	const excludedRoots = config.codegraph?.excluded_roots;
-	const exclusion = shouldExcludeCodegraphProject(projectRoot, {
-		homeDir,
-		...(excludedRoots === undefined ? {} : { excludedRoots }),
-	});
-	if (exclusion.excluded) 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 nowMs = options.nowMs ?? Date.now();
-	const context: HookContext = {
-		baseCooldownMs: config.codegraph?.session_start_cooldown_ms ?? DEFAULT_SESSION_START_COOLDOWN_MS,
-		env,
-		homeDir,
-		logOutcome: options.logOutcome ?? ((outcome) => appendSessionStartOutcome(homeDir, outcome, nowMs)),
-		nowMs,
-		options,
-		projectRoot,
-	};
-	const projectDecision = handleProjectState(resolveHookProjectState(context), context);
-	if (projectDecision !== null) return projectDecision;
-
-	const cooldown = readSessionStartCooldown({
-		baseCooldownMs: context.baseCooldownMs,
-		homeDir,
-		nowMs,
-		projectRoot,
-	});
-	if (cooldown.kind === "inconclusive") return { action: "skipped-inconclusive", exitCode: 0 };
-	if (cooldown.kind === "active") {
-		safeLogOutcome(context.logOutcome, {
-			action: "skipped-cooldown",
-			cooldownUntil: cooldown.cooldownUntil,
-			failureCount: cooldown.failureCount,
-			projectRoot,
-		});
-		return { action: "skipped-cooldown", exitCode: 0 };
-	}
-
-	const lockResult = acquireSessionStartLock({
-		homeDir,
-		nowMs,
-		projectRoot,
-		staleMs: options.lockStaleMs ?? DEFAULT_SESSION_START_LOCK_STALE_MS,
-	});
-	if (lockResult.kind === "inconclusive") return { action: "skipped-inconclusive", exitCode: 0 };
-	if (lockResult.kind === "locked") {
-		safeLogOutcome(context.logOutcome, { action: "skipped-locked", projectRoot });
-		return { action: "skipped-locked", exitCode: 0 };
-	}
-	if (lockResult.recoveredStale) return handleRecoveredStaleLock(lockResult.lock, context);
-
-	const lockedProjectDecision = handleProjectState(resolveHookProjectState(context), context);
-	if (lockedProjectDecision !== null) {
-		releaseSessionStartLock(lockResult.lock);
-		return lockedProjectDecision;
-	}
-
-	try {
-		(options.spawnWorker ?? spawnDetachedSessionStartWorker)({
-			args: [options.workerCliPath ?? defaultWorkerCliPath(), "hook", "session-start-worker"],
-			command: process.execPath,
-			env: buildCodegraphChildEnv({
-				ambientEnv: env,
-				codegraphEnv: {
-					[SESSION_START_CWD_ENV]: projectRoot,
-					[SESSION_START_LOCK_TOKEN_ENV]: lockResult.lock.token,
-				},
-				runtimeEnv: env,
-			}),
-		});
-	} catch (error) {
-		if (error instanceof Error) return handleSpawnFailure(error, lockResult.lock, context);
-		throw error;
-	}
-
-	writeSessionStartNotice(options.stdout ?? processStdout, CODEGRAPH_SESSION_START_NOTICE);
-	return { action: "spawned", exitCode: 0 };
-}
-
-function resolveHookProjectState(context: HookContext): CodegraphProjectState {
-	const exact = probeExactCodegraphProject(context.projectRoot);
-	if (exact.kind !== "uninitialized") return exact;
-	return (context.options.ancestorProbe ?? probeCodegraphAncestors)(context.projectRoot);
-}
-
-function handleProjectState(state: CodegraphProjectState, context: HookContext): SessionStartHookResult | null {
-	switch (state.kind) {
-		case "inconclusive":
-			return { action: "skipped-inconclusive", exitCode: 0 };
-		case "initialized":
-			return { action: "skipped-initialized", exitCode: 0 };
-		case "nested-root":
-			safeLogOutcome(context.logOutcome, { action: "skipped-nested-root", ancestorRoot: state.ancestorRoot, projectRoot: context.projectRoot });
-			return { action: "skipped-nested-root", exitCode: 0 };
-		case "uninitialized":
-			return null;
-	}
-}
-
-function handleRecoveredStaleLock(lock: SessionStartLock, context: HookContext): SessionStartHookResult {
-	try {
-		const cooldown = recordSessionStartFailure({
-			action: "stale-lock",
-			baseCooldownMs: context.baseCooldownMs,
-			homeDir: context.homeDir,
-			nowMs: context.nowMs,
-			projectRoot: context.projectRoot,
-		});
-		releaseSessionStartLock(lock);
-		safeLogOutcome(context.logOutcome, {
-			action: "skipped-cooldown",
-			cooldownUntil: cooldown.cooldownUntil,
-			error: "recovered stale SessionStart worker lock",
-			failureCount: cooldown.failureCount,
-			projectRoot: context.projectRoot,
-		});
-		return { action: "skipped-cooldown", exitCode: 0 };
-	} catch (error) {
-		if (error instanceof Error) return { action: "skipped-inconclusive", exitCode: 0 };
-		throw error;
-	}
-}
-
-function handleSpawnFailure(error: unknown, lock: SessionStartLock, context: HookContext): SessionStartHookResult {
-	try {
-		const cooldown = recordSessionStartFailure({
-			action: "spawn-failed",
-			baseCooldownMs: context.baseCooldownMs,
-			homeDir: context.homeDir,
-			nowMs: context.nowMs,
-			projectRoot: context.projectRoot,
-		});
-		releaseSessionStartLock(lock);
-		safeLogOutcome(context.logOutcome, {
-			action: "skipped-spawn-error",
-			cooldownUntil: cooldown.cooldownUntil,
-			error: error instanceof Error ? error.message : String(error),
-			failureCount: cooldown.failureCount,
-			projectRoot: context.projectRoot,
-		});
-	} catch (cooldownError) {
-		if (cooldownError instanceof Error) return { action: "skipped-inconclusive", exitCode: 0 };
-		throw cooldownError;
-	}
-	return { action: "skipped-spawn-error", exitCode: 0 };
-}
-
-function safeLogOutcome(logOutcome: (outcome: CodegraphSessionStartOutcome) => void, outcome: CodegraphSessionStartOutcome): void {
-	try {
-		logOutcome(outcome);
-	} catch (error) {
-		if (error instanceof Error) writeDebugLog(`failed to write SessionStart outcome: ${error.message}`);
-		else throw error;
-	}
-}
-
-function writeDebugLog(message: string): void {
-	if (processEnv["OMO_CODEGRAPH_DEBUG"] !== "1") return;
-	processStderr.write(`${message}\n`);
-}
-
-function defaultWorkerCliPath(): string {
-	return fileURLToPath(import.meta.url);
-}