oh-my-opencode 4.19.2 → 4.19.3

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

@@ -1,10 +1,15 @@
 import { describe, expect, it } from "bun:test";
-import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { 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 Node support", () => {
 	it("#given an unsupported local Node and a PATH CodeGraph command with auto provisioning disabled #when worker runs #then it skips without touching the workspace", async () => {
 		// given
@@ -52,7 +57,7 @@ describe("CodeGraph SessionStart worker Node support", () => {
 		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-provision-home-"));
 		const binPath = join(homeDir, ".omo", "codegraph", "bin", "codegraph");
 		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-		const provisionCalls: Array<{ readonly installDir?: string; readonly lockDir: string; readonly version: "1.4.1" }> = [];
+		const provisionCalls: Array<{ readonly installDir?: string; readonly lockDir: string; readonly version: "1.5.0" }> = [];
 		const outcomes: unknown[] = [];
 
 		try {
@@ -78,19 +83,17 @@ describe("CodeGraph SessionStart worker Node support", () => {
 					resolveCommand: () => ({ argsPrefix: [], command: "/usr/local/bin/codegraph", exists: true, source: "path" }),
 					runCommand: (_projectRoot, command, args) => {
 						calls.push({ args, command });
-						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
+						writeProjectDatabase(workspace);
+						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
 					},
 				},
 			});
 
 			// then
 			expect(result).toEqual({ action: "initialized" });
-			expect(calls).toEqual([
-				{ args: ["status", "--json"], command: binPath },
-				{ args: ["init"], command: binPath },
-			]);
+			expect(calls).toEqual([{ args: ["init"], command: binPath }]);
 			expect(provisionCalls).toEqual([
-				{ installDir: join(homeDir, ".omo", "codegraph"), lockDir: join(homeDir, ".omo", "codegraph", ".locks"), version: "1.4.1" },
+				{ installDir: join(homeDir, ".omo", "codegraph"), lockDir: join(homeDir, ".omo", "codegraph", ".locks"), version: "1.5.0" },
 			]);
 			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
 		} finally {
@@ -99,6 +102,62 @@ describe("CodeGraph SessionStart worker Node support", () => {
 		}
 	});
 
+	it("#given bundled CodeGraph and a stale managed install #when the worker runs #then it upgrades and uses the managed runtime", async () => {
+		// given
+		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-managed-upgrade-"));
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-managed-upgrade-home-"));
+		const installDir = join(homeDir, ".omo", "codegraph");
+		const binPath = join(installDir, "bin", "codegraph");
+		mkdirSync(join(installDir, "bin"), { recursive: true });
+		mkdirSync(join(installDir, ".provisioned"), { recursive: true });
+		writeFileSync(binPath, "stale codegraph\n");
+		writeFileSync(
+			join(installDir, ".provisioned", "codegraph-1.4.1.json"),
+			`${JSON.stringify({ binPath, version: "1.4.1" })}\n`,
+		);
+		const provisionCalls: unknown[] = [];
+		const commandCalls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
+
+		try {
+			// when
+			const result = await runCodegraphSessionStartWorker({
+				cwd: workspace,
+				env: { HOME: homeDir },
+				nodeVersion: "22.14.0",
+				deps: {
+					ensureGitignored: () => true,
+					ensureProvisioned: (options) => {
+						provisionCalls.push(options);
+						return Promise.resolve({ binPath, provisioned: true });
+					},
+					managedInstallExists: () => 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: ["codegraph.js"], command: "/opt/node22/bin/node", exists: true, source: "bundled" }),
+					resolveManagedBin: () => null,
+					runCommand: (_projectRoot, command, args) => {
+						commandCalls.push({ args, command });
+						writeProjectDatabase(workspace);
+						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
+					},
+				},
+			});
+
+			// then
+			expect(result).toEqual({ action: "initialized" });
+			expect(provisionCalls).toEqual([{ installDir, lockDir: join(installDir, ".locks"), version: "1.5.0" }]);
+			expect(commandCalls).toEqual([{ args: ["init"], command: binPath }]);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+			rmSync(homeDir, { recursive: true, force: true });
+		}
+	});
+
 	it("#given an unsupported local Node but bundled CodeGraph resolves through CODEGRAPH_NODE_BIN #when worker runs #then it bootstraps with the compatible runtime", async () => {
 		// given
 		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-"));
@@ -129,17 +188,15 @@ describe("CodeGraph SessionStart worker Node support", () => {
 					resolveCommand: () => ({ argsPrefix: ["codegraph.js"], command: nodeBin, exists: true, source: "bundled" }),
 					runCommand: (_projectRoot, command, args) => {
 						calls.push({ args, command });
-						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
+						writeProjectDatabase(workspace);
+						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
 					},
 				},
 			});
 
 			// then
 			expect(result).toEqual({ action: "initialized" });
-			expect(calls).toEqual([
-				{ args: ["codegraph.js", "status", "--json"], command: nodeBin },
-				{ args: ["codegraph.js", "init"], command: nodeBin },
-			]);
+			expect(calls).toEqual([{ args: ["codegraph.js", "init"], command: nodeBin }]);
 			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "bundled", timedOut: false }]);
 		} finally {
 			rmSync(workspace, { recursive: true, force: true });

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

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { probeCodegraphProject } from "../src/session-start-project.ts";
+
+describe("CodeGraph SessionStart project probe", () => {
+	it("#given the exact project directory has a CodeGraph database #when probing #then it is initialized", () => {
+		// given
+		const projectRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-probe-exact-"));
+		try {
+			mkdirSync(join(projectRoot, ".codegraph"), { recursive: true });
+			writeFileSync(join(projectRoot, ".codegraph", "codegraph.db"), "fixture");
+
+			// when
+			const result = probeCodegraphProject(projectRoot);
+
+			// then
+			expect(result).toEqual({ kind: "initialized" });
+		} finally {
+			rmSync(projectRoot, { recursive: true, force: true });
+		}
+	});
+
+	it("#given an ancestor directory has a CodeGraph database #when probing a nested project #then the ancestor covers it", () => {
+		// given
+		const ancestorRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-probe-ancestor-"));
+		const projectRoot = join(ancestorRoot, "apps", "server");
+		try {
+			mkdirSync(join(ancestorRoot, ".codegraph"), { recursive: true });
+			mkdirSync(projectRoot, { recursive: true });
+			writeFileSync(join(ancestorRoot, ".codegraph", "codegraph.db"), "fixture");
+
+			// when
+			const result = probeCodegraphProject(projectRoot);
+
+			// then
+			expect(result).toEqual({ ancestorRoot: realpathSync(ancestorRoot), kind: "nested-root" });
+		} finally {
+			rmSync(ancestorRoot, { recursive: true, force: true });
+		}
+	});
+
+	it("#given neither the project nor its ancestors have a CodeGraph database #when probing #then it is definitively uninitialized", () => {
+		// given
+		const projectRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-probe-missing-"));
+		try {
+			// when
+			const result = probeCodegraphProject(projectRoot);
+
+			// then
+			expect(result).toEqual({ kind: "uninitialized" });
+		} finally {
+			rmSync(projectRoot, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -0,0 +1,104 @@
+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

@@ -15,7 +15,7 @@ describe("CodeGraph SessionStart trust boundary", () => {
 		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", "config.jsonc"), JSON.stringify({ codegraph: { enabled: true, install_dir: attackerInstallDir } }));
+			writeFileSync(join(workspace, ".omo", "omo.jsonc"), JSON.stringify({ codegraph: { enabled: true, install_dir: attackerInstallDir } }));
 
 			// when
 			const result = await runCodegraphSessionStartWorker({
@@ -45,7 +45,9 @@ describe("CodeGraph SessionStart trust boundary", () => {
 					},
 					runCommand: (_projectRoot, _command, _args, options) => {
 						calls.push({ env: options.env });
-						return Promise.resolve({ exitCode: 0, stdout: calls.length === 2 ? '{"initialized":false}' : "", timedOut: false });
+						mkdirSync(join(workspace, ".codegraph"), { recursive: true });
+						writeFileSync(join(workspace, ".codegraph", "codegraph.db"), "fixture");
+						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
 					},
 				},
 			});

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

@@ -0,0 +1,116 @@
+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

@@ -6,6 +6,11 @@ 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
@@ -47,9 +52,11 @@ describe("CodeGraph SessionStart worker flow", () => {
 						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 });
-						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
+						writeProjectDatabase(workspace);
+						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
 					},
 				},
 			});
@@ -57,7 +64,6 @@ describe("CodeGraph SessionStart worker flow", () => {
 			// then
 			expect(result).toEqual({ action: "initialized" });
 			expect(calls.map((call) => ({ args: [...call.args], command: call.command }))).toEqual([
-				{ args: ["status", "--json"], command: binPath },
 				{ args: ["init"], command: binPath },
 			]);
 			expect(calls[0]?.env["CODEGRAPH_INSTALL_DIR"]).toBe(installDir);
@@ -74,11 +80,11 @@ describe("CodeGraph SessionStart worker flow", () => {
 		const command = "C:\\Users\\test\\.omo\\codegraph\\bin\\codegraph.cmd";
 
 		// when
-		const invocation = resolveCodegraphCommandInvocation(command, ["status", "--json"], "win32");
+		const invocation = resolveCodegraphCommandInvocation(command, ["init"], "win32");
 
 		// then
 		expect(invocation).toEqual({
-			args: ["/d", "/s", "/c", command, "status", "--json"],
+			args: ["/d", "/s", "/c", command, "init"],
 			command: "cmd.exe",
 		});
 	});
@@ -88,11 +94,11 @@ describe("CodeGraph SessionStart worker flow", () => {
 		const command = "C:\\Users\\test\\.omo\\codegraph\\bin\\codegraph.cjs";
 
 		// when
-		const invocation = resolveCodegraphCommandInvocation(command, ["status", "--json"], "win32");
+		const invocation = resolveCodegraphCommandInvocation(command, ["init"], "win32");
 
 		// then
 		expect(invocation).toEqual({
-			args: [command, "status", "--json"],
+			args: [command, "init"],
 			command: process.execPath,
 		});
 	});
@@ -108,51 +114,47 @@ describe("CodeGraph SessionStart worker flow", () => {
 		expect(invocation).toEqual({ args: ["sync"], command });
 	});
 
-	it("#given resolved CodeGraph status #when worker runs #then it runs status before init or sync", async () => {
-		for (const scenario of [
-			{ action: "initialized", args: [["status", "--json"], ["init"]], stdout: '{"initialized":false}' },
-			{ action: "synced", args: [["status", "--json"], ["sync"]], stdout: '{"initialized":true}' },
-		] as const) {
-			// given
-			const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-status-"));
-			const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-status-home-"));
-			const calls: { readonly args: readonly string[]; readonly command: 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, command, env: options.env });
-							return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? scenario.stdout : "", timedOut: false });
-						},
+	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: scenario.action });
-				expect(calls.map((call) => [...call.args])).toEqual(scenario.args.map((args) => [...args]));
-				expect(calls[0]?.env["CODEGRAPH_INSTALL_DIR"]).toBe("/tmp/codegraph-install");
-				expect(outcomes).toEqual([{ action: scenario.action, exitCode: 0, projectRoot: workspace, source: "path", timedOut: false }]);
-			} finally {
-				rmSync(workspace, { recursive: true, force: true });
-				rmSync(homeDir, { recursive: true, force: true });
-			}
+			// 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 });
 		}
 	});
 
@@ -182,13 +184,14 @@ describe("CodeGraph SessionStart worker flow", () => {
 					resolveCommand: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
 					runCommand: (_projectRoot, command, args, options) => {
 						calls.push({ args, command, env: options.env });
-						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":true}' : "", timedOut: false });
+						writeProjectDatabase(workspace);
+						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
 					},
 				},
 			});
 
 			// then
-			expect(result).toEqual({ action: "synced" });
+			expect(result).toEqual({ action: "initialized" });
 			expect(calls.length).toBeGreaterThan(0);
 			for (const call of calls) {
 				expect(call.env["CODEGRAPH_NO_DAEMON"]).toBe("1");
@@ -211,7 +214,8 @@ describe("CodeGraph SessionStart worker flow", () => {
 			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');`,
-				"process.stdout.write('{\"initialized\":true}');",
+				"fs.mkdirSync('.codegraph', { recursive: true });",
+				"fs.writeFileSync('.codegraph/codegraph.db', 'fixture');",
 			].join("");
 
 			// when
@@ -238,15 +242,12 @@ describe("CodeGraph SessionStart worker flow", () => {
 			});
 
 			// then
-			expect(result).toEqual({ action: "synced" });
+			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") },
-				{ install: join(homeDir, ".omo", "codegraph") },
-			]);
+			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;

package/packages/omo-codex/plugin/components/comment-checker/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "(OmO 4.19.2) Checking Comments"
+						"statusMessage": "(OmO 4.19.3) Checking Comments"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/comment-checker/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "4.19.2",
+	"version": "4.19.3",
 	"description": "Codex plugin that runs comment-checker after edit-like PostToolUse hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",