oh-my-opencode 4.19.2 → 4.19.4

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

@@ -0,0 +1,148 @@
+import { env as processEnv, stderr as processStderr } from "node:process";
+
+import type { CodegraphCommandResolution } from "../../../../../utils/src/codegraph/resolve.ts";
+import type { CodegraphSessionStartOutcome, WorkerAction } from "./hook-types.js";
+import {
+	clearSessionStartCooldown,
+	recordSessionStartFailure,
+	type SessionStartFailureAction,
+} from "./session-start-cooldown.js";
+import type { CodegraphProjectState } from "./session-start-project.js";
+
+export type WorkerResultContext = {
+	readonly baseCooldownMs: number;
+	readonly homeDir: string;
+	readonly logOutcome: (outcome: CodegraphSessionStartOutcome) => void;
+	readonly nowMs: () => number;
+	readonly projectRoot: string;
+};
+
+export type WorkerRunResult = {
+	readonly action: WorkerAction;
+	readonly releaseLock: boolean;
+};
+
+export function finishWorkerProjectState(
+	state: CodegraphProjectState,
+	context: WorkerResultContext,
+): WorkerRunResult | null {
+	switch (state.kind) {
+		case "inconclusive":
+			return finishWorkerFailure("skipped-probe-error", "skipped-probe-error", {
+				error: state.reason,
+				projectRoot: context.projectRoot,
+			}, context);
+		case "initialized":
+			return finishWorkerSuccess("skipped-initialized", { projectRoot: context.projectRoot }, context);
+		case "nested-root":
+			return finishWorkerSuccess("skipped-nested-root", {
+				ancestorRoot: state.ancestorRoot,
+				projectRoot: context.projectRoot,
+			}, context);
+		case "uninitialized":
+			return null;
+	}
+}
+
+export function finishWorkerInitialization(
+	state: CodegraphProjectState,
+	detail: {
+		readonly exitCode: number;
+		readonly source: CodegraphCommandResolution["source"];
+	},
+	context: WorkerResultContext,
+): WorkerRunResult {
+	switch (state.kind) {
+		case "inconclusive":
+			return finishWorkerFailure("skipped-probe-error", "skipped-probe-error", {
+				error: state.reason,
+				...detail,
+				projectRoot: context.projectRoot,
+				timedOut: false,
+			}, context);
+		case "initialized":
+			return finishWorkerSuccess("initialized", {
+				...detail,
+				projectRoot: context.projectRoot,
+				timedOut: false,
+			}, context);
+		case "nested-root":
+			return finishWorkerFailure("failed", "failed", {
+				...detail,
+				error: `codegraph init resolved to ancestor database at ${state.ancestorRoot}`,
+				projectRoot: context.projectRoot,
+				timedOut: false,
+			}, context);
+		case "uninitialized":
+			return finishWorkerFailure("failed", "failed", {
+				...detail,
+				error: "codegraph init completed without creating an exact project database",
+				projectRoot: context.projectRoot,
+				timedOut: false,
+			}, context);
+	}
+}
+
+export function finishWorkerFailure(
+	action: WorkerAction,
+	failureAction: SessionStartFailureAction,
+	detail: Omit<CodegraphSessionStartOutcome, "action">,
+	context: WorkerResultContext,
+): WorkerRunResult {
+	let releaseLock = true;
+	try {
+		recordSessionStartFailure({
+			action: failureAction,
+			baseCooldownMs: context.baseCooldownMs,
+			homeDir: context.homeDir,
+			nowMs: context.nowMs(),
+			projectRoot: context.projectRoot,
+		});
+	} catch (error) {
+		if (error instanceof Error) releaseLock = false;
+		else throw error;
+	}
+	safeLogWorkerOutcome(context.logOutcome, { ...detail, action });
+	return { action, releaseLock };
+}
+
+export function finishWorkerSuccess(
+	action: WorkerAction,
+	detail: Omit<CodegraphSessionStartOutcome, "action">,
+	context: WorkerResultContext,
+): WorkerRunResult {
+	try {
+		clearSessionStartCooldown({ homeDir: context.homeDir, projectRoot: context.projectRoot });
+	} catch (error) {
+		if (error instanceof Error) writeDebugLog(`failed to clear SessionStart cooldown: ${error.message}`);
+		else throw error;
+	}
+	safeLogWorkerOutcome(context.logOutcome, { ...detail, action });
+	return { action, releaseLock: true };
+}
+
+export function finishWorkerNeutral(
+	action: WorkerAction,
+	detail: Omit<CodegraphSessionStartOutcome, "action">,
+	context: WorkerResultContext,
+): WorkerRunResult {
+	safeLogWorkerOutcome(context.logOutcome, { ...detail, action });
+	return { action, releaseLock: true };
+}
+
+export function safeLogWorkerOutcome(
+	logOutcome: (outcome: CodegraphSessionStartOutcome) => void,
+	outcome: CodegraphSessionStartOutcome,
+): void {
+	try {
+		logOutcome(outcome);
+	} catch (error) {
+		if (error instanceof Error) processStderr.write(`[codegraph-session-start] failed to write outcome: ${error.message}\n`);
+		else throw error;
+	}
+}
+
+function writeDebugLog(message: string): void {
+	if (processEnv["OMO_CODEGRAPH_DEBUG"] !== "1") return;
+	processStderr.write(`[codegraph-session-start] ${message}\n`);
+}

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

@@ -1,46 +1,58 @@
-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 { cwd as processCwd, env as processEnv } 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 { hasCodegraphManagedInstall, resolvePinnedCodegraphBin } from "../../../../../utils/src/codegraph/managed-runtime.ts";
 import { evaluateCodegraphNodeSupport, type CodegraphNodeSupport } from "../../../../../utils/src/codegraph/node-support.ts";
 import { ensureCodegraphProvisioned } from "../../../../../utils/src/codegraph/provision.ts";
-import {
-	codegraphCommandRequiresSupportedLocalNode,
-	resolveCodegraphCommand,
-	type CodegraphCommandResolution,
-} from "../../../../../utils/src/codegraph/resolve.ts";
+import { resolveCodegraphCommand } 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,
 	CodegraphSessionStartDeps,
 	CodegraphSessionStartOutcome,
 	SessionStartWorkerOptions,
 	WorkerAction,
 } from "./hook-types.js";
+import {
+	resolveSessionStartCommand,
+	runSessionStartCodegraphCommand,
+	SESSION_START_COMMAND_TIMEOUT_MS,
+	sessionStartCodegraphEnv,
+	type CodegraphBootstrapConfig,
+} from "./session-start-command.js";
+import { DEFAULT_SESSION_START_COOLDOWN_MS } from "./session-start-cooldown.js";
+import { releaseSessionStartLock, sessionStartLockIsOwned, type SessionStartLock } from "./session-start-lock.js";
+import { appendSessionStartOutcome } from "./session-start-outcome.js";
+import { resolveSessionStartStatePaths } from "./session-start-paths.js";
+import { probeCodegraphProject, type CodegraphProjectState } from "./session-start-project.js";
+import {
+	finishWorkerFailure,
+	finishWorkerInitialization,
+	finishWorkerNeutral,
+	finishWorkerProjectState,
+	safeLogWorkerOutcome,
+	type WorkerResultContext,
+	type WorkerRunResult,
+} from "./session-start-worker-result.js";
 
 export const SESSION_START_CWD_ENV = "OMO_CODEGRAPH_SESSION_START_CWD";
+export const SESSION_START_LOCK_TOKEN_ENV = "OMO_CODEGRAPH_SESSION_START_LOCK_TOKEN";
 
-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"]);
-type CodegraphBootstrapConfig = CodegraphConfig & {
-	readonly trustedCodegraphInstallDir?: string;
+type WorkerContext = WorkerResultContext & {
+	readonly config: CodegraphBootstrapConfig;
+	readonly deps: CodegraphSessionStartDeps;
+	readonly env: Record<string, string | undefined>;
+	readonly probeProject: (projectRoot: string) => CodegraphProjectState;
 };
 
 const defaultDeps: CodegraphSessionStartDeps = {
 	ensureGitignored: ensureCodegraphGitignored,
 	ensureProvisioned: ensureCodegraphProvisioned,
+	managedInstallExists: hasCodegraphManagedInstall,
 	prepareWorkspace: prepareCodegraphWorkspace,
 	resolveCommand: resolveCodegraphCommand,
-	runCommand: runCodegraphCommand,
+	resolveManagedBin: resolvePinnedCodegraphBin,
+	runCommand: runSessionStartCodegraphCommand,
 };
 
 export async function runCodegraphSessionStartWorker(options: SessionStartWorkerOptions = {}): Promise<{ readonly action: WorkerAction }> {
@@ -48,177 +60,116 @@ export async function runCodegraphSessionStartWorker(options: SessionStartWorker
 	const homeDir = resolveHomeDir(env);
 	const projectRoot = options.cwd ?? env[SESSION_START_CWD_ENV] ?? processCwd();
 	const config = options.config ?? getCodexOmoConfig({ cwd: projectRoot, env, homeDir });
-	const logOutcome = options.logOutcome ?? ((outcome) => appendOutcome(homeDir, outcome));
-
-	if (config.codegraph?.enabled === false) {
-		return finish("skipped-disabled", { projectRoot }, logOutcome);
+	const lock = resolveWorkerLock(homeDir, projectRoot, env[SESSION_START_LOCK_TOKEN_ENV]);
+	if (lock !== null && !sessionStartLockIsOwned(lock)) {
+		const outcome = { action: "skipped-locked", projectRoot } satisfies CodegraphSessionStartOutcome;
+		safeLogWorkerOutcome(options.logOutcome ?? ((value) => appendSessionStartOutcome(homeDir, value)), outcome);
+		return { action: "skipped-locked" };
 	}
 
-	const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
-	const bootstrapConfig: CodegraphBootstrapConfig = {
-		...(config.codegraph ?? {}),
-		...(config.trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir: config.trustedCodegraphInstallDir }),
+	const customResolutionDeps = options.deps?.resolveCommand === undefined
+		? {}
+		: {
+			managedInstallExists: options.deps.managedInstallExists ?? (() => false),
+			resolveManagedBin: options.deps.resolveManagedBin ?? (() => null),
+		};
+	const context: WorkerContext = {
+		baseCooldownMs: config.codegraph?.session_start_cooldown_ms ?? DEFAULT_SESSION_START_COOLDOWN_MS,
+		config: {
+			...(config.codegraph ?? {}),
+			...(config.trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir: config.trustedCodegraphInstallDir }),
+		},
+		deps: { ...defaultDeps, ...customResolutionDeps, ...options.deps },
+		env,
+		homeDir,
+		logOutcome: options.logOutcome ?? ((outcome) => appendSessionStartOutcome(homeDir, outcome)),
+		nowMs: () => options.nowMs ?? Date.now(),
+		probeProject: options.projectProbe ?? probeCodegraphProject,
+		projectRoot,
 	};
-	return runBootstrap(projectRoot, bootstrapConfig, env, homeDir, nodeSupport, { ...defaultDeps, ...options.deps }, logOutcome);
+
+	let result: WorkerRunResult;
+	if (config.codegraph?.enabled === false) {
+		result = finishWorkerNeutral("skipped-disabled", { projectRoot }, context);
+	} else {
+		const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
+		result = await runBootstrap(context, nodeSupport);
+	}
+	if (lock !== null && result.releaseLock) releaseSessionStartLock(lock);
+	return { action: result.action };
 }
 
-async function runBootstrap(
-	projectRoot: string,
-	config: CodegraphBootstrapConfig,
-	env: Record<string, string | undefined>,
-	homeDir: string,
-	nodeSupport: CodegraphNodeSupport,
-	deps: CodegraphSessionStartDeps,
-	logOutcome: (outcome: CodegraphSessionStartOutcome) => void,
-): Promise<{ readonly action: WorkerAction }> {
+async function runBootstrap(context: WorkerContext, nodeSupport: CodegraphNodeSupport): Promise<WorkerRunResult> {
 	try {
-		const command = await resolveOrProvisionCommand(deps, config, env, homeDir, nodeSupport);
+		const projectState = context.probeProject(context.projectRoot);
+		const projectDecision = finishWorkerProjectState(projectState, context);
+		if (projectDecision !== null) return projectDecision;
+
+		const command = await resolveSessionStartCommand({
+			config: context.config,
+			deps: context.deps,
+			env: context.env,
+			homeDir: context.homeDir,
+			nodeSupport,
+		});
 		if (command.kind === "unavailable") {
-			return finish("skipped-unavailable", { error: command.error, projectRoot, source: command.source }, logOutcome);
+			return finishWorkerFailure("skipped-unavailable", "skipped-unavailable", {
+				error: command.error,
+				projectRoot: context.projectRoot,
+				source: command.source,
+			}, context);
 		}
 		if (command.kind === "unsupported-node") {
-			return finish("skipped-unsupported-node", { projectRoot }, logOutcome);
+			return finishWorkerFailure("skipped-unsupported-node", "skipped-unsupported-node", { projectRoot: context.projectRoot }, context);
 		}
 
-		deps.prepareWorkspace(projectRoot, { homeDir });
-		deps.ensureGitignored(projectRoot);
-		const codegraphEnv = codegraphEnvForConfig(config, homeDir);
-		const status = await deps.runCommand(projectRoot, command.resolution.command, [...command.resolution.argsPrefix, "status", "--json"], { env: codegraphEnv, timeoutMs: COMMAND_TIMEOUT_MS });
-		const decision = decideStartupAction(status);
-		if (decision.kind === "skip") return finish("skipped-status", { error: decision.reason, projectRoot }, logOutcome);
-
-		const actionArgs = command.resolution.argsPrefix.concat(decision.kind === "init" ? ["init"] : ["sync"]);
-		const action = await deps.runCommand(projectRoot, command.resolution.command, actionArgs, { env: codegraphEnv, timeoutMs: COMMAND_TIMEOUT_MS });
-		return finish(decision.kind === "init" ? "initialized" : "synced", { exitCode: action.exitCode, projectRoot, source: command.resolution.source, timedOut: action.timedOut }, logOutcome);
-	} catch (error) {
-		return finish("failed", { error: error instanceof Error ? error.message : String(error), projectRoot }, logOutcome);
-	}
-}
-
-function finish(action: WorkerAction, detail: Omit<CodegraphSessionStartOutcome, "action">, logOutcome: (outcome: CodegraphSessionStartOutcome) => void): { readonly action: WorkerAction } {
-	safeLogOutcome(logOutcome, { ...detail, action });
-	return { action };
-}
-
-type ResolutionResult =
-	| { readonly kind: "resolved"; readonly resolution: CodegraphCommandResolution }
-	| { readonly kind: "unsupported-node" }
-	| { readonly error: string; readonly kind: "unavailable"; readonly projectRoot?: string; readonly source: CodegraphCommandResolution["source"] };
-
-async function resolveOrProvisionCommand(
-	deps: CodegraphSessionStartDeps,
-	config: CodegraphBootstrapConfig,
-	env: Record<string, string | undefined>,
-	homeDir: string,
-	nodeSupport: CodegraphNodeSupport,
-): Promise<ResolutionResult> {
-	const trustedInstallDir = config.trustedCodegraphInstallDir;
-	const resolved = deps.resolveCommand({ env, homeDir, provisioned: () => provisionedBinFromInstallDir(trustedInstallDir) });
-	if (resolved.exists && canUseResolvedCommand(resolved, nodeSupport)) {
-		return { kind: "resolved", resolution: resolved };
-	}
-	if (resolved.exists && config.auto_provision === false) return { kind: "unsupported-node" };
-	if (config.auto_provision === false) return { error: "codegraph binary unavailable and auto_provision is disabled", kind: "unavailable", source: resolved.source };
-
-	const installDir = trustedInstallDir ?? join(homeDir, ".omo", "codegraph");
-	const provisioned = await deps.ensureProvisioned({ installDir, lockDir: join(installDir, ".locks"), version: CODEGRAPH_VERSION });
-	if (!provisioned.provisioned || provisioned.binPath === undefined) {
-		return { error: provisioned.error ?? "provisioning did not produce a binary", kind: "unavailable", source: resolved.source };
-	}
-	return { kind: "resolved", resolution: { argsPrefix: [], command: provisioned.binPath, exists: true, source: "provisioned" } };
-}
-
-function codegraphEnvForConfig(config: CodegraphBootstrapConfig, homeDir: string): Record<string, string> {
-	// 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 };
-}
-
-function canUseResolvedCommand(resolved: CodegraphCommandResolution, nodeSupport: CodegraphNodeSupport): boolean {
-	return !codegraphCommandRequiresSupportedLocalNode(resolved) || nodeSupport.supported;
-}
-
-function decideStartupAction(status: CodegraphCommandResult): { readonly kind: "init" } | { readonly kind: "skip"; readonly reason: string } | { readonly kind: "sync" } {
-	if (status.timedOut) return { kind: "skip", reason: "status timed out" };
-	const text = `${status.stdout}\n${status.stderr ?? ""}`.toLowerCase();
-	if (text.includes("not initialized") || text.includes("uninitialized")) return { kind: "init" };
-	const initialized = jsonSaysInitialized(parseJson(status.stdout));
-	if (initialized === false) return { kind: "init" };
-	if (initialized === true) return { kind: "sync" };
-	if (status.exitCode !== 0) return { kind: "skip", reason: `status exited ${status.exitCode}` };
-	return { kind: "sync" };
-}
-
-function jsonSaysInitialized(value: unknown): boolean | undefined {
-	if (!isRecord(value)) return undefined;
-	const initialized = value["initialized"] ?? value["isInitialized"] ?? value["ready"];
-	if (typeof initialized === "boolean") return initialized;
-	const status = value["status"];
-	if (typeof status !== "string") return undefined;
-	const normalized = status.toLowerCase();
-	if (normalized.includes("not initialized") || normalized.includes("uninitialized")) return false;
-	if (normalized.includes("initialized") || normalized.includes("ready")) return true;
-	return 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 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(
-	command: string,
-	args: readonly string[],
-	platform: NodeJS.Platform = process.platform,
-): { readonly args: readonly string[]; readonly command: string } {
-	if (platform !== "win32") return { args: [...args], command };
-	const extension = extname(command).toLowerCase();
-	if (WINDOWS_NODE_SCRIPT_EXTENSIONS.has(extension)) return { args: [command, ...args], command: processExecPath };
-	if (!WINDOWS_CMD_EXTENSIONS.has(extension)) return { args: [...args], command };
-	return { args: ["/d", "/s", "/c", command, ...args], command: "cmd.exe" };
-}
-
-function appendOutcome(homeDir: string, outcome: CodegraphSessionStartOutcome): void {
-	const logDir = join(homeDir, ".omo", "codegraph");
-	mkdirSync(logDir, { recursive: true });
-	appendFileSync(join(logDir, "session-start.jsonl"), `${JSON.stringify({ ...outcome, timestamp: new Date().toISOString() })}\n`);
-}
-
-function safeLogOutcome(logOutcome: (outcome: CodegraphSessionStartOutcome) => void, outcome: CodegraphSessionStartOutcome): void {
-	try {
-		logOutcome(outcome);
+		context.deps.prepareWorkspace(context.projectRoot, { homeDir: context.homeDir });
+		context.deps.ensureGitignored(context.projectRoot);
+		const preparedState = context.probeProject(context.projectRoot);
+		const preparedDecision = finishWorkerProjectState(preparedState, context);
+		if (preparedDecision !== null) return preparedDecision;
+
+		const action = await context.deps.runCommand(
+			context.projectRoot,
+			command.resolution.command,
+			[...command.resolution.argsPrefix, "init"],
+			{ env: sessionStartCodegraphEnv(context.config, context.homeDir), timeoutMs: SESSION_START_COMMAND_TIMEOUT_MS },
+		);
+		if (action.timedOut) {
+			return finishWorkerFailure("failed", "timeout", {
+				error: "codegraph init timed out",
+				exitCode: action.exitCode,
+				projectRoot: context.projectRoot,
+				source: command.resolution.source,
+				timedOut: true,
+			}, context);
+		}
+		if (action.exitCode !== 0) {
+			return finishWorkerFailure("failed", "failed", {
+				error: `codegraph init exited ${action.exitCode}`,
+				exitCode: action.exitCode,
+				projectRoot: context.projectRoot,
+				source: command.resolution.source,
+				timedOut: false,
+			}, context);
+		}
+		return finishWorkerInitialization(context.probeProject(context.projectRoot), {
+			exitCode: action.exitCode,
+			source: command.resolution.source,
+		}, context);
 	} catch (error) {
-		if (error instanceof Error) processStderr.write(`[codegraph-session-start] failed to write outcome: ${error.message}\n`);
-		else throw error;
+		return finishWorkerFailure("failed", "failed", {
+			error: error instanceof Error ? error.message : String(error),
+			projectRoot: context.projectRoot,
+		}, context);
 	}
 }
 
-function provisionedBinFromInstallDir(installDir: string | undefined): string | null {
-	return resolvePinnedCodegraphBin(installDir);
+function resolveWorkerLock(homeDir: string, projectRoot: string, token: string | undefined): SessionStartLock | null {
+	if (token === undefined || token.length === 0) return null;
+	return { path: resolveSessionStartStatePaths(homeDir, projectRoot).lockPath, token };
 }
 
 function resolveHomeDir(env: Record<string, string | undefined>): string {
 	return env["HOME"] ?? env["USERPROFILE"] ?? homedir();
 }
-
-function parseJson(text: string): unknown {
-	try {
-		return JSON.parse(text);
-	} catch (error) {
-		if (error instanceof SyntaxError) return undefined;
-		throw error;
-	}
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}

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

@@ -34,8 +34,8 @@ describe("CodeGraph SessionStart exclusion policy", () => {
 				stdin: Readable.from(["{}"]),
 				stdout: { write: (chunk) => stdout.push(chunk) },
 				spawnWorker: (invocation) => spawned.push(invocation),
-				statusProbe: () => {
-					throw new Error("excluded projects must not probe CodeGraph status");
+				ancestorProbe: () => {
+					throw new Error("excluded projects must not probe CodeGraph ancestors");
 				},
 				sweepZombies: () => {
 					sweepCalls += 1;
@@ -68,8 +68,8 @@ describe("CodeGraph SessionStart exclusion policy", () => {
 				env: { HOME: "/tmp/home" },
 				stdin: Readable.from(["{}"]),
 				stdout: { write: (chunk) => stdout.push(chunk) },
+				ancestorProbe: () => ({ kind: "uninitialized" }),
 				spawnWorker: (invocation) => spawned.push(invocation),
-				statusProbe: () => Promise.resolve(false),
 			});
 
 			// then
@@ -97,8 +97,8 @@ describe("CodeGraph SessionStart exclusion policy", () => {
 				env: { HOME: "/tmp/home" },
 				stdin: Readable.from(["{}"]),
 				stdout: { write: (chunk) => stdout.push(chunk) },
+				ancestorProbe: () => ({ kind: "uninitialized" }),
 				spawnWorker: (invocation) => spawned.push(invocation),
-				statusProbe: () => Promise.resolve(false),
 			});
 
 			// then