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

package/packages/omo-codex/plugin/components/codegraph/test/session-start-state.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync, utimesSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-	clearSessionStartCooldown,
-	readSessionStartCooldown,
-	recordSessionStartFailure,
-} from "../src/session-start-cooldown.ts";
-import {
-	acquireSessionStartLock,
-	releaseSessionStartLock,
-} from "../src/session-start-lock.ts";
-
-describe("CodeGraph SessionStart lock", () => {
-	it("#given a live project lock #when a second hook acquires it #then the second hook is deduplicated", () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-lock-home-"));
-		const projectRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-lock-project-"));
-		try {
-			const first = acquireSessionStartLock({ homeDir, nowMs: 10_000, projectRoot, staleMs: 60_000 });
-			expect(first.kind).toBe("acquired");
-
-			// when
-			const second = acquireSessionStartLock({ homeDir, nowMs: 10_001, projectRoot, staleMs: 60_000 });
-
-			// then
-			expect(second).toEqual({ kind: "locked" });
-			if (first.kind === "acquired") releaseSessionStartLock(first.lock);
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(projectRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given a project lock older than the stale threshold #when another hook acquires it #then the stale lock is recovered", () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-stale-home-"));
-		const projectRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-stale-project-"));
-		try {
-			const first = acquireSessionStartLock({ homeDir, nowMs: 1_000, projectRoot, staleMs: 500 });
-			expect(first.kind).toBe("acquired");
-			if (first.kind !== "acquired") return;
-			const staleDate = new Date(1_000);
-			utimesSync(first.lock.path, staleDate, staleDate);
-
-			// when
-			const second = acquireSessionStartLock({ homeDir, nowMs: 2_000, projectRoot, staleMs: 500 });
-
-			// then
-			expect(second.kind).toBe("acquired");
-			if (second.kind === "acquired") {
-				expect(second.recoveredStale).toBe(true);
-				releaseSessionStartLock(second.lock);
-			}
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(projectRoot, { recursive: true, force: true });
-		}
-	});
-});
-
-describe("CodeGraph SessionStart cooldown", () => {
-	it("#given a failed worker outcome #when the cooldown is checked #then retries are suppressed until expiry and the next failure backs off", () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-cooldown-home-"));
-		const projectRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-cooldown-project-"));
-		try {
-			const first = recordSessionStartFailure({
-				action: "failed",
-				baseCooldownMs: 1_000,
-				homeDir,
-				nowMs: 1_000,
-				projectRoot,
-			});
-
-			// when
-			const active = readSessionStartCooldown({ baseCooldownMs: 1_000, homeDir, nowMs: 1_999, projectRoot });
-			const expired = readSessionStartCooldown({ baseCooldownMs: 1_000, homeDir, nowMs: 2_000, projectRoot });
-			const second = recordSessionStartFailure({
-				action: "skipped-status",
-				baseCooldownMs: 1_000,
-				homeDir,
-				nowMs: 2_000,
-				projectRoot,
-			});
-
-			// then
-			expect(first).toMatchObject({ cooldownUntil: 2_000, failureCount: 1 });
-			expect(active).toMatchObject({ cooldownUntil: 2_000, failureCount: 1, kind: "active" });
-			expect(expired).toEqual({ failureCount: 1, kind: "inactive" });
-			expect(second).toMatchObject({ cooldownUntil: 4_000, failureCount: 2 });
-			clearSessionStartCooldown({ homeDir, projectRoot });
-			expect(readSessionStartCooldown({ baseCooldownMs: 1_000, homeDir, nowMs: 2_001, projectRoot })).toEqual({
-				failureCount: 0,
-				kind: "inactive",
-			});
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(projectRoot, { recursive: true, force: true });
-		}
-	});
-});

package/packages/omo-codex/plugin/components/codegraph/test/session-start-trust-boundary.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { runCodegraphSessionStartWorker } from "../src/hook.ts";
-
-describe("CodeGraph SessionStart trust boundary", () => {
-	it("#given project config sets install_dir #when worker provisions CodeGraph #then it uses the trusted home install root", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-untrusted-project-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-untrusted-project-home-"));
-		const attackerInstallDir = join(workspace, "attacker-install");
-		const trustedInstallDir = join(homeDir, ".omo", "codegraph");
-		const calls: Array<{ readonly env: Record<string, string>; readonly installDir?: string; readonly lockDir?: string }> = [];
-		try {
-			mkdirSync(join(workspace, ".omo"), { recursive: true });
-			writeFileSync(join(workspace, ".omo", "omo.jsonc"), JSON.stringify({ codegraph: { enabled: true, install_dir: attackerInstallDir } }));
-
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				nodeVersion: "22.14.0",
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: (options) => {
-						calls.push({
-							env: {},
-							...(options.installDir === undefined ? {} : { installDir: options.installDir }),
-							...(options.lockDir === undefined ? {} : { lockDir: options.lockDir }),
-						});
-						return Promise.resolve({ binPath: join(trustedInstallDir, "bin", "codegraph"), provisioned: true });
-					},
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: (options) => {
-						expect(options?.provisioned?.()).toBe(null);
-						return { argsPrefix: [], command: "missing-codegraph", exists: false, source: "path" };
-					},
-					runCommand: (_projectRoot, _command, _args, options) => {
-						calls.push({ env: options.env });
-						mkdirSync(join(workspace, ".codegraph"), { recursive: true });
-						writeFileSync(join(workspace, ".codegraph", "codegraph.db"), "fixture");
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls[0]).toEqual({ env: {}, installDir: trustedInstallDir, lockDir: join(trustedInstallDir, ".locks") });
-			expect(calls[1]?.env["CODEGRAPH_INSTALL_DIR"]).toBe(trustedInstallDir);
-			expect(calls[1]?.env["CODEGRAPH_INSTALL_DIR"]).not.toBe(attackerInstallDir);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-});

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

@@ -1,106 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { existsSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { runCodegraphSessionStartWorker } from "../src/hook.ts";
-
-describe("CodeGraph SessionStart worker availability", () => {
-	it("#given CodeGraph cannot be resolved or provisioned #when worker runs #then it logs a graceful skip", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-home-"));
-		const outcomes: unknown[] = [];
-		const calls: string[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				nodeVersion: "22.14.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => {
-						calls.push("ensureGitignored");
-						return true;
-					},
-					ensureProvisioned: () => Promise.resolve({ error: "offline", provisioned: false }),
-					prepareWorkspace: () => {
-						calls.push("prepareWorkspace");
-						return {
-							dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-							dataRoot: join(homeDir, ".omo/codegraph"),
-							linked: true,
-							mode: "global-linked",
-							projectLink: join(workspace, ".codegraph"),
-						};
-					},
-					resolveCommand: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
-					runCommand: () => {
-						calls.push("runCommand");
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-unavailable" });
-			expect(calls).toEqual([]);
-			expect(outcomes).toEqual([
-				{
-					action: "skipped-unavailable",
-					error: "offline",
-					projectRoot: workspace,
-					source: "path",
-				},
-			]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given CodeGraph is unavailable and auto provisioning is disabled #when worker runs #then it leaves the project untouched", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-unavailable-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-unavailable-home-"));
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
-				nodeVersion: "22.14.0",
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureProvisioned: () => {
-						throw new Error("auto provision should not run");
-					},
-					resolveCommand: () => ({ argsPrefix: [], command: "missing-codegraph", exists: false, source: "path" }),
-					runCommand: () => {
-						throw new Error("codegraph command should not run");
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-unavailable" });
-			expect(existsSync(join(workspace, ".codegraph"))).toBe(false);
-			expect(existsSync(join(workspace, ".git", "info", "exclude"))).toBe(false);
-			expect(outcomes).toEqual([
-				{
-					action: "skipped-unavailable",
-					error: "codegraph binary unavailable and auto_provision is disabled",
-					projectRoot: workspace,
-					source: "path",
-				},
-			]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-});

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

@@ -1,116 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import type { CodegraphSessionStartOutcome } from "../src/hook.ts";
-import { runCodegraphSessionStartWorker } from "../src/hook.ts";
-import { readSessionStartCooldown } from "../src/session-start-cooldown.ts";
-
-describe("CodeGraph SessionStart worker cooldown", () => {
-	it("#given codegraph init times out #when the worker finishes #then it records a failed outcome and cooldown", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-timeout-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-timeout-home-"));
-		const outcomes: CodegraphSessionStartOutcome[] = [];
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { enabled: true, session_start_cooldown_ms: 60_000 }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome) => outcomes.push(outcome),
-				nodeVersion: "22.14.0",
-				nowMs: 1_000,
-				projectProbe: () => ({ kind: "uninitialized" }),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => Promise.resolve({ binPath: "/tmp/codegraph", provisioned: true }),
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
-					runCommand: () => Promise.resolve({ exitCode: 1, stdout: "", timedOut: true }),
-				},
-			});
-			const cooldown = readSessionStartCooldown({
-				baseCooldownMs: 60_000,
-				homeDir,
-				nowMs: 2_000,
-				projectRoot: workspace,
-			});
-
-			// then
-			expect(result).toEqual({ action: "failed" });
-			expect(outcomes).toEqual([{
-				action: "failed",
-				error: "codegraph init timed out",
-				exitCode: 1,
-				projectRoot: workspace,
-				source: "path",
-				timedOut: true,
-			}]);
-			expect(cooldown).toEqual({ cooldownUntil: 61_000, failureCount: 1, kind: "active" });
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("#given codegraph init exits zero without an exact database #when the worker verifies the result #then it records a failure cooldown", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-no-db-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-no-db-home-"));
-		const outcomes: CodegraphSessionStartOutcome[] = [];
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { enabled: true, session_start_cooldown_ms: 60_000 }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome) => outcomes.push(outcome),
-				nodeVersion: "22.14.0",
-				nowMs: 1_000,
-				projectProbe: () => ({ kind: "uninitialized" }),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => Promise.resolve({ binPath: "/tmp/codegraph", provisioned: true }),
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
-					runCommand: () => Promise.resolve({ exitCode: 0, stdout: "", timedOut: false }),
-				},
-			});
-			const cooldown = readSessionStartCooldown({
-				baseCooldownMs: 60_000,
-				homeDir,
-				nowMs: 2_000,
-				projectRoot: workspace,
-			});
-
-			// then
-			expect(result).toEqual({ action: "failed" });
-			expect(outcomes).toEqual([{
-				action: "failed",
-				error: "codegraph init completed without creating an exact project database",
-				exitCode: 0,
-				projectRoot: workspace,
-				source: "path",
-				timedOut: false,
-			}]);
-			expect(cooldown).toEqual({ cooldownUntil: 61_000, failureCount: 1, kind: "active" });
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-});

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

@@ -1,258 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, readFileSync, 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 { resolveCodegraphCommandInvocation, runCodegraphSessionStartWorker } from "../src/hook.ts";
-
-function writeProjectDatabase(workspace: string): void {
-	mkdirSync(join(workspace, ".codegraph"), { recursive: true });
-	writeFileSync(join(workspace, ".codegraph", "codegraph.db"), "fixture");
-}
-
-describe("CodeGraph SessionStart worker flow", () => {
-	it("#given install_dir has the pinned platform binary #when worker resolves provisioned CodeGraph #then it uses that launcher", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-platform-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-platform-home-"));
-		const installDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-platform-install-"));
-		const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
-		const calls: { readonly args: readonly string[]; readonly command: string; readonly env: Record<string, string> }[] = [];
-		const outcomes: unknown[] = [];
-		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({
-				config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
-				nodeVersion: "22.14.0",
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => {
-						throw new Error("provisioning should not run when install_dir binary exists");
-					},
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: (options) => {
-						const provisioned = options?.provisioned?.() ?? null;
-						return { argsPrefix: [], command: provisioned ?? "missing-codegraph", exists: provisioned !== null, source: provisioned === null ? "path" : "provisioned" };
-					},
-					resolveManagedBin: () => binPath,
-					runCommand: (_projectRoot, command, args, options) => {
-						calls.push({ args, command, env: options.env });
-						writeProjectDatabase(workspace);
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls.map((call) => ({ args: [...call.args], command: call.command }))).toEqual([
-				{ args: ["init"], command: binPath },
-			]);
-			expect(calls[0]?.env["CODEGRAPH_INSTALL_DIR"]).toBe(installDir);
-			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(installDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given Windows codegraph.cmd #when default worker runner builds invocation #then it runs through cmd.exe", () => {
-		// given
-		const command = "C:\\Users\\test\\.omo\\codegraph\\bin\\codegraph.cmd";
-
-		// when
-		const invocation = resolveCodegraphCommandInvocation(command, ["init"], "win32");
-
-		// then
-		expect(invocation).toEqual({
-			args: ["/d", "/s", "/c", command, "init"],
-			command: "cmd.exe",
-		});
-	});
-
-	it("#given Windows CodeGraph resolves to a Node script #when default worker runner builds invocation #then Node executes it", () => {
-		// given
-		const command = "C:\\Users\\test\\.omo\\codegraph\\bin\\codegraph.cjs";
-
-		// when
-		const invocation = resolveCodegraphCommandInvocation(command, ["init"], "win32");
-
-		// then
-		expect(invocation).toEqual({
-			args: [command, "init"],
-			command: process.execPath,
-		});
-	});
-
-	it("#given non-Windows codegraph command #when default worker runner builds invocation #then it executes directly", () => {
-		// given
-		const command = "/home/test/.omo/codegraph/bin/codegraph";
-
-		// when
-		const invocation = resolveCodegraphCommandInvocation(command, ["sync"], "linux");
-
-		// then
-		expect(invocation).toEqual({ args: ["sync"], command });
-	});
-
-	it("#given an uninitialized exact project #when worker runs #then it invokes init directly without a status command", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-init-direct-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-init-direct-home-"));
-		const calls: { readonly args: readonly string[]; readonly env: Record<string, string> }[] = [];
-		const outcomes: unknown[] = [];
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { enabled: true, install_dir: "/tmp/codegraph-install" }, sources: [], trustedCodegraphInstallDir: "/tmp/codegraph-install", warnings: [] },
-				nodeVersion: "22.14.0",
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => Promise.resolve({ binPath: "/tmp/codegraph", provisioned: true }),
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
-					runCommand: (_projectRoot, _command, args, options) => {
-						calls.push({ args, env: options.env });
-						writeProjectDatabase(workspace);
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls.map((call) => [...call.args])).toEqual([["init"]]);
-			expect(calls[0]?.env["CODEGRAPH_INSTALL_DIR"]).toBe("/tmp/codegraph-install");
-			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "path", timedOut: false }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given codegraph.daemon=true #when the indexing worker runs #then its env stays daemon-less with CODEGRAPH_NO_DAEMON=1", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-daemon-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-daemon-home-"));
-		const calls: { readonly args: readonly string[]; readonly command: string; readonly env: Record<string, string> }[] = [];
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { daemon: true, enabled: true, install_dir: "/tmp/codegraph-install" }, sources: [], trustedCodegraphInstallDir: "/tmp/codegraph-install", warnings: [] },
-				nodeVersion: "22.14.0",
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: () => undefined,
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => Promise.resolve({ binPath: "/tmp/codegraph", provisioned: true }),
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
-					runCommand: (_projectRoot, command, args, options) => {
-						calls.push({ args, command, env: options.env });
-						writeProjectDatabase(workspace);
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls.length).toBeGreaterThan(0);
-			for (const call of calls) {
-				expect(call.env["CODEGRAPH_NO_DAEMON"]).toBe("1");
-			}
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given ambient provider tokens #when default worker runner spawns CodeGraph #then child env only gets safe and controlled variables", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-env-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-env-home-"));
-		const logPath = join(homeDir, "child-env.jsonl");
-		const originalOpenAiKey = process.env["OPENAI_API_KEY"];
-		process.env["OPENAI_API_KEY"] = "sk-test-secret";
-
-		try {
-			const fakeCodegraphScript = [
-				"const fs = require('node:fs');",
-				`fs.appendFileSync(${JSON.stringify(logPath)}, JSON.stringify({install:process.env.CODEGRAPH_INSTALL_DIR,openai:process.env.OPENAI_API_KEY}) + '\\n');`,
-				"fs.mkdirSync('.codegraph', { recursive: true });",
-				"fs.writeFileSync('.codegraph/codegraph.db', 'fixture');",
-			].join("");
-
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: () => undefined,
-				nodeVersion: "22.14.0",
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => {
-						throw new Error("provisioning should not run when command is resolved");
-					},
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: ["-e", fakeCodegraphScript], command: process.execPath, exists: true, source: "bundled" }),
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			const captured = readFileSync(logPath, "utf8")
-				.trim()
-				.split("\n")
-				.map((line) => JSON.parse(line));
-			expect(captured).toEqual([{ install: join(homeDir, ".omo", "codegraph") }]);
-		} finally {
-			if (originalOpenAiKey === undefined) delete process.env["OPENAI_API_KEY"];
-			else process.env["OPENAI_API_KEY"] = originalOpenAiKey;
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-});