oh-my-opencode 4.5.12 → 4.7.0

package/packages/omo-codex/plugin/components/ulw-loop/test/package-smoke.test.ts

@@ -1,5 +1,7 @@
 // biome-ignore-all format: smoke test pulls verbatim JSON for structural assertion.
-import { readFile, stat } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { chmod, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
@@ -14,6 +16,41 @@ async function readJson(relative: string): Promise<unknown> {
 	return JSON.parse(await readText(relative));
 }
 
+type ShellResult = {
+	readonly code: number | null;
+	readonly stdout: string;
+	readonly stderr: string;
+};
+
+function bootstrapScriptFrom(text: string): string {
+	const heading = text.indexOf("### 1. Create goals from the brief");
+	expect(heading).toBeGreaterThanOrEqual(0);
+	const blockStart = text.indexOf("```sh\n", heading);
+	expect(blockStart).toBeGreaterThanOrEqual(0);
+	const codeStart = blockStart + "```sh\n".length;
+	const blockEnd = text.indexOf("\n```", codeStart);
+	expect(blockEnd).toBeGreaterThan(codeStart);
+	return text.slice(codeStart, blockEnd);
+}
+
+async function runShell(script: string, env: NodeJS.ProcessEnv): Promise<ShellResult> {
+	return new Promise((resolvePromise, reject) => {
+		const child = spawn("/bin/sh", ["-c", script], { env });
+		const stdout: Buffer[] = [];
+		const stderr: Buffer[] = [];
+		child.stdout.on("data", (chunk: Buffer) => stdout.push(chunk));
+		child.stderr.on("data", (chunk: Buffer) => stderr.push(chunk));
+		child.on("error", reject);
+		child.on("close", (code) => {
+			resolvePromise({
+				code,
+				stdout: Buffer.concat(stdout).toString("utf8"),
+				stderr: Buffer.concat(stderr).toString("utf8"),
+			});
+		});
+	});
+}
+
 describe("package.json", () => {
 	it("declares ESM + npm + Node >=20", async () => {
 		const pkg = await readJson("package.json") as Record<string, unknown>;
@@ -102,13 +139,13 @@ describe("skills/ulw-loop/SKILL.md", () => {
 	});
 
 	it("references the success criteria and record-evidence vocabulary", async () => {
-		const text = await readText("skills/ulw-loop/SKILL.md");
+		const text = await readText("skills/ulw-loop/references/full-workflow.md");
 		expect(text.toLowerCase()).toMatch(/success criteria|successcriteria/);
 		expect(text.toLowerCase()).toContain("record-evidence");
 	});
 
 	it("#given omo is absent from PATH #when bootstrap instructions are read #then local cached CLI fallback is documented", async () => {
-		const text = await readText("skills/ulw-loop/SKILL.md");
+		const text = await readText("skills/ulw-loop/references/full-workflow.md");
 
 		expect(text).toContain("If `omo` is absent from PATH");
 		expect(text).toContain("ULW_LOOP_CLI");
@@ -116,7 +153,7 @@ describe("skills/ulw-loop/SKILL.md", () => {
 	});
 
 	it("#given empty PATH #when bootstrap instructions are read #then handles empty PATH without losing notepad bootstrap", async () => {
-		const text = await readText("skills/ulw-loop/SKILL.md");
+		const text = await readText("skills/ulw-loop/references/full-workflow.md");
 
 		expect(text).toContain("If PATH is empty");
 		expect(text).toContain("ULW_LOOP_NODE");
@@ -124,13 +161,57 @@ describe("skills/ulw-loop/SKILL.md", () => {
 		expect(text).not.toContain("ls -1");
 	});
 
+	it("#given PATH omo lacks ulw-loop #when bootstrap runs #then falls back to cached ulw-loop CLI", async () => {
+		const text = await readText("skills/ulw-loop/references/full-workflow.md");
+		const bootstrap = bootstrapScriptFrom(text);
+		const root = await mkdtemp(join(tmpdir(), "omo-ulw-loop-bootstrap-"));
+		try {
+			const badBin = join(root, "bad-bin");
+			const home = join(root, "home");
+			const codexHome = join(home, ".codex");
+			const cachedCli = join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "0.1.0", "components", "ulw-loop", "dist", "cli.js");
+			await mkdir(badBin, { recursive: true });
+			await mkdir(dirname(cachedCli), { recursive: true });
+			await writeFile(join(badBin, "omo"), "#!/bin/sh\nprintf '%s\\n' \"error: unknown command 'ulw-loop'\" >&2\nexit 1\n");
+			await chmod(join(badBin, "omo"), 0o755);
+			await writeFile(
+				cachedCli,
+				[
+					"#!/usr/bin/env node",
+					"const args = process.argv.slice(2);",
+					"if (args[0] === 'ulw-loop' && args[1] === 'help') process.exit(0);",
+					"if (args[0] === 'ulw-loop' && args[1] === 'status' && args.includes('--json')) {",
+					"  console.log(JSON.stringify({ ok: true, source: 'cached-ulw-loop' }));",
+					"  process.exit(0);",
+					"}",
+					"console.error('unexpected args: ' + args.join(' '));",
+					"process.exit(1);",
+					"",
+				].join("\n"),
+			);
+
+			const result = await runShell(`${bootstrap}\nomo ulw-loop status --json`, {
+				...process.env,
+				CODEX_HOME: codexHome,
+				HOME: home,
+				PATH: `${badBin}:${process.env["PATH"] ?? ""}`,
+			});
+
+			expect(result.code).toBe(0);
+			expect(result.stdout).toContain('"source":"cached-ulw-loop"');
+			expect(result.stderr).not.toContain("unknown command");
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
 	it("uses the .omo workspace path", async () => {
 		const text = await readText("skills/ulw-loop/SKILL.md");
 		expect(text).toContain(".omo/ulw-loop");
 	});
 
 	it("#given long Codex runs #when worker guidance is inspected #then avoids context-expensive agent polling", async () => {
-		const text = await readText("skills/ulw-loop/SKILL.md");
+		const text = await readText("skills/ulw-loop/references/full-workflow.md");
 
 		expect(text).toMatch(/list_agents/);
 		expect(text).toMatch(/polling or status tool/);
@@ -139,9 +220,25 @@ describe("skills/ulw-loop/SKILL.md", () => {
 		expect(text).toMatch(/wait_agent.*completion/);
 		expect(text).toMatch(/targeted followups only when needed/);
 		expect(text).toMatch(/close_agent.*after integrating each result/);
+		expect(text).toMatch(/Plan and reviewer agents may run for a long time/);
+		expect(text).toMatch(/short wait_agent cycles/);
+		expect(text).toMatch(/single long blocking wait/);
 		expect(text).toContain("Every worker message MUST carry");
 		expect(text).toContain("Each worker does strict TDD");
 	});
+
+	it("#given Codex subagent delegation #when worker guidance is inspected #then assignment ambiguity is hardened", async () => {
+		const text = await readText("skills/ulw-loop/SKILL.md");
+
+		expect(text).toMatch(/TASK:/);
+		expect(text).toMatch(/fork_turns:\s*"none"/);
+		expect(text).toMatch(/wait_agent.*signal, not proof/);
+		expect(text).toMatch(/one targeted followup/);
+		expect(text).toMatch(/respawn.*smaller/);
+		expect(text).toMatch(/Plan and reviewer agents may run for a long time/);
+		expect(text).toMatch(/short wait_agent cycles/);
+		expect(text).toMatch(/single long blocking wait/);
+	});
 });
 
 describe("source LOC budget", () => {

package/packages/omo-codex/plugin/hooks/hooks.json

@@ -20,6 +20,17 @@
 						"statusMessage": "LazyCodex(0.1.0): Recording Session Telemetry"
 					}
 				]
+			},
+			{
+				"matcher": "^startup$",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/scripts/auto-update.mjs\" hook session-start",
+						"timeout": 5,
+						"statusMessage": "LazyCodex(0.1.0): Checking Auto Update"
+					}
+				]
 			}
 		],
 		"UserPromptSubmit": [
@@ -55,6 +66,17 @@
 			}
 		],
 		"PreToolUse": [
+			{
+				"matcher": "^Bash$",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/components/git-bash/dist/cli.js\" hook pre-tool-use",
+						"timeout": 5,
+						"statusMessage": "LazyCodex(0.1.0): Recommending Git Bash Mcp"
+					}
+				]
+			},
 			{
 				"matcher": "^create_goal$",
 				"hooks": [
@@ -75,13 +97,13 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/comment-checker/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "LazyCodex(0.1.0): Checking Comments"
+						"statusMessage": "LazyCodex(0.1.1): Checking Comments"
 					},
 					{
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "LazyCodex(0.1.0): Checking LSP Diagnostics"
+						"statusMessage": "LazyCodex(0.2.0): Checking LSP Diagnostics"
 					}
 				]
 			},
@@ -98,6 +120,17 @@
 			}
 		],
 		"PostCompact": [
+			{
+				"matcher": "manual|auto",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/components/git-bash/dist/cli.js\" hook post-compact",
+						"timeout": 5,
+						"statusMessage": "LazyCodex(0.1.0): Resetting Git Bash Mcp Reminder"
+					}
+				]
+			},
 			{
 				"matcher": "manual|auto",
 				"hooks": [

package/packages/omo-codex/plugin/model-catalog.json

@@ -0,0 +1,49 @@
+{
+	"version": "2026-06-03.gpt-5.5-400k",
+	"current": {
+		"model": "gpt-5.5",
+		"model_context_window": 400000,
+		"model_reasoning_effort": "high",
+		"plan_mode_reasoning_effort": "xhigh"
+	},
+	"roles": {
+		"default": {
+			"model": "gpt-5.5",
+			"model_context_window": 400000,
+			"model_reasoning_effort": "high",
+			"plan_mode_reasoning_effort": "xhigh"
+		},
+		"verifier": {
+			"model": "gpt-5.5",
+			"model_reasoning_effort": "xhigh"
+		},
+		"worker": {
+			"model": "gpt-5.4",
+			"model_reasoning_effort": "high"
+		}
+	},
+	"managedProfiles": [
+		{
+			"version": "legacy.gpt-5.2",
+			"match": {
+				"model": "gpt-5.2"
+			}
+		},
+		{
+			"version": "legacy.gpt-5.4-1m",
+			"match": {
+				"model": "gpt-5.4",
+				"model_context_window": 1000000,
+				"model_reasoning_effort": "high",
+				"plan_mode_reasoning_effort": "xhigh"
+			}
+		},
+		{
+			"version": "legacy.gpt-5.5-272k",
+			"match": {
+				"model": "gpt-5.5",
+				"model_context_window": 272000
+			}
+		}
+	]
+}

package/packages/omo-codex/plugin/package-lock.json

@@ -9,6 +9,7 @@
 			"version": "0.1.0",
 			"workspaces": [
 				"components/comment-checker",
+				"components/git-bash",
 				"components/rules",
 				"components/lsp",
 				"components/telemetry",
@@ -61,6 +62,20 @@
 				"@code-yeongyu/comment-checker": "^0.8.0"
 			}
 		},
+		"components/git-bash": {
+			"name": "@sisyphuslabs/codex-git-bash-hook",
+			"version": "0.1.0",
+			"bin": {
+				"omo-git-bash-hook": "dist/cli.js"
+			},
+			"devDependencies": {
+				"@types/node": "^25.7.0",
+				"typescript": "^6.0.3"
+			},
+			"engines": {
+				"node": ">=20.0.0"
+			}
+		},
 		"components/lsp": {
 			"name": "@code-yeongyu/codex-lsp",
 			"version": "0.2.0",
@@ -765,6 +780,10 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/@sisyphuslabs/codex-git-bash-hook": {
+			"resolved": "components/git-bash",
+			"link": true
+		},
 		"node_modules/@standard-schema/spec": {
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",

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

@@ -7,6 +7,7 @@
 	"private": true,
 	"workspaces": [
 		"components/comment-checker",
+		"components/git-bash",
 		"components/rules",
 		"components/lsp",
 		"components/telemetry",
@@ -18,8 +19,9 @@
 		"@oh-my-opencode/shared-skills": "file:../../shared-skills"
 	},
 	"scripts": {
-		"build": "node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node ../scripts/sync-telemetry-component.mjs && node scripts/build-components.mjs",
+		"build": "node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node ../scripts/sync-telemetry-component.mjs && node scripts/build-components.mjs",
 		"check": "npm run build && npm test",
+		"sync:hooks": "node scripts/sync-hook-status-messages.mjs",
 		"sync:skills": "node scripts/sync-skills.mjs",
 		"test": "node --test test/*.test.mjs"
 	}

package/packages/omo-codex/plugin/scripts/auto-update.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import { spawn, spawnSync } from "node:child_process";
+import { mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { migrateCodexConfig } from "./migrate-codex-config.mjs";
+
+const DEFAULT_INTERVAL_MS = 24 * 60 * 60 * 1_000;
+const DEFAULT_LOCK_STALE_MS = 10 * 60 * 1_000;
+
+export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), lastCheckedAt } = {}) {
+	if (env.LAZYCODEX_AUTO_UPDATE_DISABLED === "1" || env.OMO_CODEX_AUTO_UPDATE_DISABLED === "1") {
+		return { shouldRun: false, reason: "disabled" };
+	}
+
+	const intervalMs = parsePositiveInteger(env.LAZYCODEX_AUTO_UPDATE_INTERVAL_MS, DEFAULT_INTERVAL_MS);
+	if (typeof lastCheckedAt === "number" && intervalMs > 0 && now - lastCheckedAt < intervalMs) {
+		return { shouldRun: false, reason: "throttled" };
+	}
+
+	return {
+		shouldRun: true,
+		command: resolveCommand(env),
+		args: resolveArgs(env),
+		env: {
+			...env,
+			LAZYCODEX_AUTO_UPDATE_DISABLED: "1",
+			OMO_CODEX_AUTO_UPDATE_DISABLED: "1",
+		},
+	};
+}
+
+export async function runAutoUpdateCheck({ env = process.env, now = Date.now() } = {}) {
+	await runConfigMigration({ env });
+	const statePath = resolveStatePath(env);
+	const state = await readState(statePath);
+	const plan = resolveAutoUpdatePlan({ env, now, lastCheckedAt: state.lastCheckedAt });
+	if (!plan.shouldRun) return { started: false, reason: plan.reason };
+
+	const lock = await acquireLock(resolveLockPath(env, statePath), now, env);
+	if (lock === null) return { started: false, reason: "locked" };
+	try {
+		await writeState(statePath, { lastCheckedAt: now });
+		if (env.LAZYCODEX_AUTO_UPDATE_WAIT === "1") {
+			const result = spawnSync(plan.command, plan.args, {
+				env: plan.env,
+				stdio: "ignore",
+			});
+			return { started: true, status: result.status ?? 0 };
+		}
+
+		const child = spawn(plan.command, plan.args, {
+			env: plan.env,
+			stdio: "ignore",
+			detached: true,
+		});
+		child.unref();
+		return { started: true };
+	} finally {
+		await lock.release();
+	}
+}
+
+async function runConfigMigration({ env }) {
+	if (env.LAZYCODEX_CONFIG_MIGRATION_DISABLED === "1" || env.OMO_CODEX_CONFIG_MIGRATION_DISABLED === "1") return;
+	try {
+		await migrateCodexConfig({ env });
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		return;
+	}
+}
+
+function resolveCommand(env) {
+	return env.LAZYCODEX_AUTO_UPDATE_COMMAND?.trim() || "npx";
+}
+
+function resolveArgs(env) {
+	if (env.LAZYCODEX_AUTO_UPDATE_ARGS_JSON) {
+		const parsed = JSON.parse(env.LAZYCODEX_AUTO_UPDATE_ARGS_JSON);
+		if (!Array.isArray(parsed) || parsed.some((value) => typeof value !== "string")) {
+			throw new TypeError("LAZYCODEX_AUTO_UPDATE_ARGS_JSON must be a JSON string array");
+		}
+		return parsed;
+	}
+	return ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--skip-auth"];
+}
+
+function resolveStatePath(env) {
+	if (env.LAZYCODEX_AUTO_UPDATE_STATE_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_STATE_PATH;
+	const dataRoot = env.PLUGIN_DATA?.trim() || join(homedir(), ".local", "share", "lazycodex");
+	return join(dataRoot, "auto-update.json");
+}
+
+function resolveLockPath(env, statePath) {
+	if (env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH;
+	return `${statePath}.lock`;
+}
+
+async function acquireLock(lockPath, now, env) {
+	await mkdir(dirname(lockPath), { recursive: true });
+	const staleMs = parsePositiveInteger(env.LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS, DEFAULT_LOCK_STALE_MS);
+	try {
+		const handle = await open(lockPath, "wx");
+		await handle.writeFile(`${now}\n`);
+		await handle.close();
+		return {
+			release: () => rm(lockPath, { force: true }),
+		};
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+		if (!(await removeStaleLock(lockPath, now, staleMs))) return null;
+		return acquireLock(lockPath, now, { ...env, LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS: "0" });
+	}
+}
+
+async function removeStaleLock(lockPath, now, staleMs) {
+	if (staleMs <= 0) return false;
+	try {
+		const lockStat = await stat(lockPath);
+		if (now - lockStat.mtimeMs < staleMs) return false;
+		await rm(lockPath, { force: true });
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return true;
+		throw error;
+	}
+}
+
+async function readState(statePath) {
+	try {
+		const raw = await readFile(statePath, "utf8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed === "object" && parsed !== null ? parsed : {};
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
+		return {};
+	}
+}
+
+async function writeState(statePath, state) {
+	await mkdir(dirname(statePath), { recursive: true });
+	await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function parsePositiveInteger(value, fallback) {
+	if (value === undefined || value === "") return fallback;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	runAutoUpdateCheck().catch((error) => {
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exit(0);
+	});
+}

package/packages/omo-codex/plugin/scripts/build-bundled-mcp-runtimes.mjs

@@ -18,6 +18,11 @@ const runtimes = [
 		packageRoot: join(repoPackagesRoot, "ast-grep-mcp"),
 		requiredOutputs: ["dist/cli.js"],
 	},
+	{
+		label: "git-bash-mcp",
+		packageRoot: join(repoPackagesRoot, "git-bash-mcp"),
+		requiredOutputs: ["dist/cli.js"],
+	},
 ];
 
 for (const runtime of runtimes) {
@@ -25,20 +30,30 @@ for (const runtime of runtimes) {
 }
 
 function buildRuntime(runtime) {
+	if (hasBundledDist(runtime)) {
+		console.log(`Using bundled ${runtime.label} dist`);
+		return;
+	}
+
 	if (!existsSync(join(runtime.packageRoot, "package.json"))) {
 		assertBundledDist(runtime);
 		console.log(`Using bundled ${runtime.label} dist`);
 		return;
 	}
 
-	const result = spawnSync("bun", ["run", "build"], {
+	const result = spawnSync("npm", ["run", "build"], {
 		cwd: runtime.packageRoot,
+		shell: process.platform === "win32",
 		stdio: "inherit",
 	});
 	if (result.error !== undefined) throw result.error;
 	if (result.status !== 0) process.exit(result.status ?? 1);
 }
 
+function hasBundledDist(runtime) {
+	return runtime.requiredOutputs.every((output) => existsSync(join(runtime.packageRoot, output)));
+}
+
 function assertBundledDist(runtime) {
 	const missingOutputs = runtime.requiredOutputs.filter((output) => !existsSync(join(runtime.packageRoot, output)));
 	if (missingOutputs.length === 0) return;

package/packages/omo-codex/plugin/scripts/build-components.mjs

@@ -14,8 +14,9 @@ for (const workspace of workspaces) {
 	if (typeof workspacePackageJson.scripts?.build !== "string") continue;
 
 	console.log(`Building ${workspace}`);
-	const result = spawnSync("bun", ["run", "--cwd", workspace, "build"], {
+	const result = spawnSync("npm", ["run", "--workspace", workspace, "build"], {
 		cwd: root,
+		shell: process.platform === "win32",
 		stdio: "inherit",
 	});
 	if (result.error !== undefined) throw result.error;