oh-my-opencode 4.5.12 → 4.6.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

@@ -55,6 +55,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 +86,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 +109,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/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/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;

package/packages/omo-codex/plugin/scripts/sync-hook-status-messages.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { access, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
+
+import { formatLazyCodexHookStatusMessage, normalizeLazyCodexHookStatusLabel } from "./hook-status-message.mjs";
+
+const defaultRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+async function exists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function readJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+
+async function writeJson(path, value) {
+	await writeFile(path, `${JSON.stringify(value, null, "\t")}\n`);
+}
+
+async function readPackageVersion(path) {
+	const packageJson = await readJson(path);
+	return packageJson.version;
+}
+
+async function readComponentVersions(root) {
+	const componentsRoot = join(root, "components");
+	const entries = await readdir(componentsRoot, { withFileTypes: true });
+	const versions = new Map();
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		versions.set(entry.name, await readPackageVersion(join(componentsRoot, entry.name, "package.json")));
+	}
+	return versions;
+}
+
+function componentVersionForCommand(command, componentVersions, fallbackVersion) {
+	for (const [componentName, version] of componentVersions.entries()) {
+		if (command.includes(`/components/${componentName}/dist/cli.js`)) return version;
+	}
+	return fallbackVersion;
+}
+
+function syncHooksJson(hooksJson, versionForCommand) {
+	for (const groups of Object.values(hooksJson.hooks)) {
+		for (const group of groups) {
+			for (const hook of group.hooks) {
+				if (hook.type !== "command") continue;
+				const label = normalizeLazyCodexHookStatusLabel(hook.statusMessage);
+				hook.statusMessage = formatLazyCodexHookStatusMessage(versionForCommand(hook.command), label);
+			}
+		}
+	}
+}
+
+async function syncComponentHooks(root, componentName, version) {
+	const hooksPath = join(root, "components", componentName, "hooks", "hooks.json");
+	if (!(await exists(hooksPath))) return;
+	const hooksJson = await readJson(hooksPath);
+	syncHooksJson(hooksJson, () => version);
+	await writeJson(hooksPath, hooksJson);
+}
+
+export async function syncHookStatusMessages(root = defaultRoot) {
+	const aggregateVersion = await readPackageVersion(join(root, ".codex-plugin", "plugin.json"));
+	const componentVersions = await readComponentVersions(root);
+	const aggregateHooksPath = join(root, "hooks", "hooks.json");
+	const aggregateHooks = await readJson(aggregateHooksPath);
+	syncHooksJson(aggregateHooks, (command) => componentVersionForCommand(command, componentVersions, aggregateVersion));
+	await writeJson(aggregateHooksPath, aggregateHooks);
+
+	for (const [componentName, version] of componentVersions.entries()) {
+		await syncComponentHooks(root, componentName, version);
+	}
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	await syncHookStatusMessages();
+}

package/packages/omo-codex/plugin/skills/review-work/SKILL.md

@@ -18,6 +18,26 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 
 When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.
 
+## Codex Subagent Reliability
+
+Every `spawn_agent` message must be self-contained. Start with
+`TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and
+`VERIFY`. State that it is an executable assignment, not a context
+handoff. Role selection requires `agent_type`; `model` +
+`reasoning_effort` alone creates a default agent, not a reviewer or
+worker. Prefer `fork_turns: "none"` unless full history is truly
+required; paste only the review context that worker needs.
+
+Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+
+Use `wait_agent` for completion signals, but treat `wait_agent` as a
+mailbox signal, not proof of completion, content, or errors. After two
+waits with no substantive result, send one targeted followup:
+`TASK STILL ACTIVE: return <deliverable> or BLOCKED: <reason>`. If the
+child stays silent or ack-only, mark that review lane inconclusive, do
+not count it as PASS or approval, close if safe, and respawn a smaller
+`fork_turns: "none"` reviewer with the missing deliverable.
+
 # Review Work - 5-Agent Parallel Review Orchestrator
 
 Launch 5 specialized sub-agents in parallel to review completed implementation work from every angle. All 5 must pass for the review to pass. If even ONE fails, the review fails.
@@ -493,9 +513,12 @@ OUTPUT FORMAT:
 
 ## Phase 2: Wait & Collect
 
-After launching all 5 agents in one turn, **end your response**. Wait for system notifications as each agent completes.
+After launching all 5 agents in one turn, wait for completions in bounded
+cycles. Do not treat a timeout, ack-only reply, or empty child result as
+a PASS.
 
-As each completes, collect via `background_output(task_id="bg_...")`. Store each verdict:
+As each completes, collect via the Codex mapping above (`wait_agent`,
+then the child's substantive final result). Store each verdict:
 
 | Agent | Verdict | Notes |
 |-------|---------|-------|
@@ -506,6 +529,8 @@ As each completes, collect via `background_output(task_id="bg_...")`. Store each
 | 5. Context Mining | pending | - |
 
 Do NOT deliver the final report until ALL 5 have completed.
+If a lane remains silent after the reliability followup, record it as
+inconclusive and respawn a smaller reviewer/worker for that exact lane.
 
 ---
 

package/packages/omo-codex/plugin/skills/start-work/SKILL.md

@@ -20,6 +20,26 @@ This skill ports the OpenCode `/start-work` flow onto Codex. Any OpenCode-only t
 
 When translating `load_skills=[...]`, name the skills inside the spawned agent's `message`. If a code block below conflicts with this section, this section wins.
 
+## Codex Subagent Reliability
+
+Every `spawn_agent` message must be self-contained. Start with
+`TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and
+`VERIFY`. State that it is an executable assignment, not a context
+handoff. Role selection requires `agent_type`; `model` +
+`reasoning_effort` alone creates a default agent, not a reviewer or
+worker. Prefer `fork_turns: "none"` unless full history is truly
+required; paste only the context the child needs.
+
+Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+
+Use `wait_agent` for completion signals, but treat `wait_agent` as a
+mailbox signal, not proof of completion, content, or errors. After two
+waits with no substantive result, send one targeted followup:
+`TASK STILL ACTIVE: return <deliverable> or BLOCKED: <reason>`. If the
+child stays silent or ack-only, record the result as inconclusive, do
+not count it as pass/review approval, close if safe, and respawn a
+smaller `fork_turns: "none"` task with the missing deliverable.
+
 # start-work
 
 Execute a Prometheus work plan until every top-level checkbox is complete. This skill pairs with the Codex `Stop` / `SubagentStop` continuation hook in `components/start-work-continuation`, which re-injects the next turn while `.omo/boulder.json` says the current `codex:<session_id>` still has unchecked plan work.