oh-my-opencode 4.8.0 → 4.9.0

package/packages/omo-codex/plugin/test/sync-skills.test.mjs

@@ -4,109 +4,18 @@ import { dirname, join } from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
 import { sharedSkillsRootPath } from "@oh-my-opencode/shared-skills";
+import {
+	CONTEXT_PRESSURE_SKILL_BUDGET_BYTES,
+	assertPackagedContentMatches,
+	componentSkillSources,
+	expectedSkills,
+	listSkillFiles,
+	removeCodexCompatibilityGuidance,
+	removeCodexSkillOverlays,
+} from "./sync-skills-test-support.mjs";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const repoRoot = join(root, "..", "..", "..");
-const CONTEXT_PRESSURE_SKILL_BUDGET_BYTES = 25_000;
-
-const expectedSkills = [
-	"comment-checker",
-	"debugging",
-	"frontend-ui-ux",
-	"git-master",
-	"init-deep",
-	"lcx-contribute-bug-fix",
-	"lcx-report-bug",
-	"lsp",
-	"programming",
-	"refactor",
-	"remove-ai-slops",
-	"review-work",
-	"rules",
-	"start-work",
-	"ultraresearch",
-	"ulw-loop",
-	"ulw-plan",
-	"visual-qa",
-];
-
-const componentSkillSources = [
-	["comment-checker", "components/comment-checker/skills/comment-checker"],
-	["lsp", "components/lsp/skills/lsp"],
-	["rules", "components/rules/skills/rules"],
-	["ulw-loop", "components/ulw-loop/skills/ulw-loop"],
-	["ulw-plan", "components/ultrawork/skills/ulw-plan"],
-];
-
-const codexCompatibilityEndMarkers = [
-	"For work likely to exceed one wait cycle, require the child to send `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A `wait_agent` timeout only means no new mailbox update arrived. Treat a running child or latest `WORKING:` message as alive. Do not use `list_agents` as a polling loop. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.\n\n",
-	"Codex full-history forks inherit parent context, so role-specific behavior must be described in a self-contained `message` and usually should use a non-full-history fork mode such as `fork_turns=\"none\"`. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\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.\n\n",
-	"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.\n\n",
-];
-
-function removeCodexCompatibilityGuidance(content) {
-	const start = content.indexOf("## Codex Harness Tool Compatibility\n\n");
-	if (start === -1) return content;
-	const endMarker = codexCompatibilityEndMarkers.find((marker) => content.indexOf(marker, start) !== -1);
-	assert.notEqual(endMarker, undefined, "Codex compatibility guidance block is missing its terminator");
-	const end = content.indexOf(endMarker, start);
-	assert.notEqual(end, -1, "Codex compatibility guidance block is missing its terminator");
-	return `${content.slice(0, start)}${content.slice(end + endMarker.length)}`;
-}
-
-const startWorkOriginalCompletion = `When all top-level checkboxes in \`## TODOs\` and \`## Final Verification Wave\` are complete:
-
-1. Run the plan's final verification commands.
-2. If worktree mode was used, sync \`.omo/\` state back to the main repo, merge or hand off exactly as requested, and remove the worktree only after successful merge or explicit handoff.
-3. Remove or mark the Boulder work as completed.
-4. Print an \`ORCHESTRATION COMPLETE\` block with the plan path, verification commands, artifacts, and cleanup receipts.`;
-
-const startWorkCodexCompletion = `When all top-level checkboxes in \`## TODOs\` and \`## Final Verification Wave\` are complete:
-
-1. Run the plan's final verification commands.
-2. Complete the **Global Review and Debugging Gate** before any completion claim, PR handoff, or branch handoff:
-   - Invoke the \`review-work\` skill with the final diff, changed files, user goal, constraints, run command, and verification evidence. All five review lanes must return PASS. A timeout, missing deliverable, ack-only child, \`BLOCKED:\`, or inconclusive lane is a gate failure, not approval.
-   - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append the ruled-out or confirmed result to \`.omo/start-work/ledger.jsonl\`.
-   - If any review lane or debugging hypothesis fails, invoke the \`debugging\` skill, confirm root cause with runtime evidence, add the minimal failing test or reproduction, fix it, rerun the affected verification, then rerun the Global Review and Debugging Gate.
-   - Evidence hygiene is mandatory: redact or mask secrets and sensitive user data before writing \`.omo/start-work/ledger.jsonl\`, a PR body, or a handoff. Never include raw tokens, credentials, auth headers, cookies, API keys, env dumps, private logs, or PII; use concise summaries, lengths, hashes, or short non-sensitive prefixes instead.
-   - If the work includes creating, updating, or handing off a PR, refresh \`git status\` and the PR/branch state after the gate, and include only redacted review/debugging evidence in the PR body or handoff.
-3. If worktree mode was used, sync \`.omo/\` state back to the main repo, merge or hand off exactly as requested, and remove the worktree only after successful merge or explicit handoff.
-4. Remove or mark the Boulder work as completed.
-5. Print an \`ORCHESTRATION COMPLETE\` block with the plan path, verification commands, Global Review and Debugging Gate verdict, artifacts, and cleanup receipts.`;
-
-const startWorkOriginalHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
-
-const startWorkCodexHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No `ORCHESTRATION COMPLETE`, final response, PR creation, or PR handoff before the Global Review and Debugging Gate passes with recorded evidence.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
-
-const reviewWorkCodexGatePattern =
-	/\nWhen `review-work` is used as a final implementation, PR, or `\$start-work`\ngate, it is blocking\. A timeout, missing deliverable, ack-only response,\nexplicit `BLOCKED:`, or inconclusive lane is not a pass\. Treat that lane as\nfailed, investigate the underlying uncertainty with the `debugging` skill when\nruntime behavior may be wrong, fix with evidence, and rerun the affected lane\nbefore claiming completion or handing off a PR\.\n\nReview evidence must be safe to share\. Redact or mask secrets and sensitive\nuser data before including evidence in logs, PR bodies, or handoffs\. Never\ninclude raw tokens, credentials, auth headers, cookies, API keys, env dumps,\nprivate logs, or PII; summarize with lengths, hashes, and short non-sensitive\nprefixes when identity is needed\.\n/;
-
-function removeCodexSkillOverlays(skillName, content) {
-	if (skillName === "start-work") {
-		return content
-			.replace(startWorkCodexCompletion, startWorkOriginalCompletion)
-			.replace(startWorkCodexHardRule, startWorkOriginalHardRule);
-	}
-	if (skillName === "review-work") {
-		return content.replace(reviewWorkCodexGatePattern, "");
-	}
-	return content;
-}
-
-async function listSkillFiles(dir) {
-	const entries = await readdir(dir, { withFileTypes: true });
-	const files = [];
-	for (const entry of entries) {
-		if (entry.isDirectory()) {
-			const nested = await listSkillFiles(join(dir, entry.name));
-			for (const nestedPath of nested) files.push(join(entry.name, nestedPath));
-		} else {
-			files.push(entry.name);
-		}
-	}
-	return files.sort();
-}
 
 async function readPackagedSkillFile(...segments) {
 	const path = join(root, "skills", ...segments);
@@ -114,12 +23,6 @@ async function readPackagedSkillFile(...segments) {
 	return { path, content };
 }
 
-function assertPackagedContentMatches({ path, content }, requirements) {
-	for (const [label, pattern] of requirements) {
-		assert.match(content, pattern, `${path} missing packaged skill contract: ${label}`);
-	}
-}
-
 test("#given synced aggregate Codex skills #when inspected #then component and shared skills are present", async () => {
 	// given
 	const skillsRoot = join(root, "skills");
@@ -225,7 +128,6 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 
 	// then
 	assert.match(skill, /^---\r?\nname: ulw-loop\r?\n/m);
-	assert.match(skill, /Goal-like loop that uses ultrawork mode to decompose work into systematic, evidence-bound steps\./);
 	assert.match(interfaceMetadata, /display_name: "ulw-loop \(omo\)"/);
 	assert.doesNotMatch(interfaceMetadata, /ulw-loop \/ ulw-loop/);
 	assert.match(interfaceMetadata, /short_description: "Goal-like ultrawork loop for systematic decomposition"/);
@@ -273,15 +175,12 @@ test("#given synced ulw-loop skill #when worker guidance is inspected #then cont
 	const syncedSkill = await readFile(join(root, "skills", "ulw-loop", "SKILL.md"), "utf8");
 	const syncedWorkflow = await readFile(join(root, "skills", "ulw-loop", "references", "full-workflow.md"), "utf8");
 	const requiredPatterns = [
-		["list_agents polling guard", /list_agents/],
-		["status polling warning", /polling loop/],
-		["large payload replay risk", /replay large payloads/],
+		["multi_agent_v1.wait_agent ref", /multi_agent_v1\.wait_agent/],
 		["local spawned-name tracking", /Track spawned agent names locally/],
 		["wait_agent mailbox path", /wait_agent.*mailbox signals/],
 		["progress status contract", /WORKING:/],
-		["single list_agents reassurance", /single `list_agents`/],
 		["long-running plan/reviewer background guidance", /Plan and reviewer agents may run for a long time/],
-		["bounded plan/reviewer polling", /short wait_agent cycles/],
+		["bounded plan/reviewer polling", /multi_agent_v1\.wait_agent.*cycles/],
 		["single long wait guard", /single long blocking wait/],
 		["git-master checkpointing", /git-master/],
 		["touched-path commit-style probe", /touched-path commit history/],

package/packages/omo-codex/plugin/test/sync-version.test.mjs

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { manifestTargets, resolveAuthoritativeVersion, syncVersion } from "../scripts/sync-version.mjs";
+
+async function makeTempDir() {
+	return mkdtemp(join(tmpdir(), "omo-codex-sync-version-"));
+}
+
+async function writeJson(path, value) {
+	await mkdir(join(path, ".."), { recursive: true });
+	await writeFile(path, `${JSON.stringify(value, null, "\t")}\n`);
+}
+
+async function readJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+
+async function scaffoldPlugin(repoRoot, rootVersion) {
+	await writeJson(join(repoRoot, "package.json"), { name: "oh-my-opencode", version: rootVersion });
+	const pluginRoot = join(repoRoot, "packages", "omo-codex", "plugin");
+	await writeJson(join(repoRoot, "packages", "omo-codex", "package.json"), { name: "@oh-my-opencode/omo-codex", version: "0.1.0" });
+	await writeJson(join(pluginRoot, "package.json"), { name: "@sisyphuslabs/omo-codex-plugin", version: "0.1.0" });
+	await writeJson(join(pluginRoot, ".codex-plugin", "plugin.json"), { name: "omo", version: "0.1.0" });
+	await writeJson(join(pluginRoot, "components", "rules", "package.json"), { name: "@code-yeongyu/codex-rules", version: "0.1.0" });
+	await writeJson(join(pluginRoot, "components", "rules", ".codex-plugin", "plugin.json"), { hooks: "./hooks/hooks.json" });
+	return pluginRoot;
+}
+
+test("#given LAZYCODEX_RELEASE_VERSION env #when resolving authoritative version #then the env value wins", async () => {
+	const version = await resolveAuthoritativeVersion({ env: { LAZYCODEX_RELEASE_VERSION: "9.9.9" }, repoRoot: "/nonexistent" });
+	assert.equal(version, "9.9.9");
+});
+
+test("#given no env override #when resolving authoritative version #then root package.json version is used", async () => {
+	const repoRoot = await makeTempDir();
+	await writeJson(join(repoRoot, "package.json"), { name: "oh-my-opencode", version: "4.8.1" });
+	const version = await resolveAuthoritativeVersion({ env: {}, repoRoot });
+	assert.equal(version, "4.8.1");
+});
+
+test("#given drifted Codex manifests #when syncing version from root #then all versioned manifests match and version-less files are left alone", async () => {
+	const repoRoot = await makeTempDir();
+	const pluginRoot = await scaffoldPlugin(repoRoot, "4.8.1");
+
+	const result = await syncVersion({ pluginRoot, env: {}, repoRoot });
+
+	assert.equal(result.version, "4.8.1");
+	for (const target of manifestTargets(pluginRoot, [join(pluginRoot, "components", "rules", "package.json")])) {
+		assert.equal((await readJson(target)).version, "4.8.1", `expected ${target} to be stamped`);
+	}
+	// the version-less component plugin.json must not gain a version field
+	const versionlessManifest = await readJson(join(pluginRoot, "components", "rules", ".codex-plugin", "plugin.json"));
+	assert.equal("version" in versionlessManifest, false);
+});
+
+test("#given already coherent manifests #when syncing again #then nothing is rewritten", async () => {
+	const repoRoot = await makeTempDir();
+	const pluginRoot = await scaffoldPlugin(repoRoot, "4.8.1");
+
+	await syncVersion({ pluginRoot, env: {}, repoRoot });
+	const second = await syncVersion({ pluginRoot, env: {}, repoRoot });
+
+	assert.equal(second.changed.length, 0);
+});

package/packages/omo-codex/plugin/test/ultraresearch-skill-contract.test.mjs

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { sharedSkillsRootPath } from "@oh-my-opencode/shared-skills";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+async function readUltraresearchCopies() {
+	const sharedPath = join(sharedSkillsRootPath(), "ultraresearch", "SKILL.md");
+	const packagedPath = join(root, "skills", "ultraresearch", "SKILL.md");
+	return [
+		{ label: "shared", path: sharedPath, content: await readFile(sharedPath, "utf8") },
+		{ label: "packaged", path: packagedPath, content: await readFile(packagedPath, "utf8") },
+	];
+}
+
+function frontmatterDescription(content) {
+	const match = content.match(/^---\r?\n[\s\S]*?\bdescription:\s*"([\s\S]*?)"\r?\n[\s\S]*?---/);
+	assert.notEqual(match, null, "SKILL.md frontmatter description not found");
+	return match[1];
+}
+
+test("#given ultraresearch skill #when scanned for non-English content #then it contains no Hangul", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.doesNotMatch(
+			copy.content,
+			/[ᄀ-ᇿ㄰-㆏가-힣]/,
+			`${copy.label} copy contains Hangul characters`,
+		);
+	}
+});
+
+test("#given ultraresearch description #when activation policy is inspected #then it gates on explicit research demands only", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		const description = frontmatterDescription(copy.content);
+		assert.match(description, /explicit/i, `${copy.label}: description must gate activation on explicit demand`);
+		assert.match(
+			description,
+			/ultra-precise investigation/i,
+			`${copy.label}: description must name the ultra-precise investigation trigger`,
+		);
+		assert.match(description, /\bresearch\b/i, `${copy.label}: description must name the research trigger`);
+	}
+});
+
+test("#given ultraresearch body #when authority is inspected #then it takes precedence over exploration-bounding instructions", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.match(
+			copy.content,
+			/exploration-bounding|exploration (?:caps|budgets|limits)/i,
+			`${copy.label}: body must name the exploration-bounding instructions it overrides`,
+		);
+		assert.match(
+			copy.content,
+			/supersede|override|do(?:es)? not (?:bind|apply)/i,
+			`${copy.label}: body must state precedence while the mode is active`,
+		);
+	}
+});
+
+test("#given ultraresearch worker protocol #when EXPAND flow is inspected #then markers travel as message text and workers never write files", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.match(copy.content, /EXPAND/, `${copy.label}: body must keep the EXPAND marker protocol`);
+		assert.match(
+			copy.content,
+			/(?:reply|message|response) text|end (?:its|the|your) (?:reply|response|final message)/i,
+			`${copy.label}: EXPAND markers must be returned as message text`,
+		);
+		assert.match(
+			copy.content,
+			/read-only|cannot write files|never ask (?:a )?worker(?:s)? to write/i,
+			`${copy.label}: body must state the read-only worker constraint`,
+		);
+		assert.doesNotMatch(
+			copy.content,
+			/APPEND (?:your )?findings to \$SESSION_DIR/i,
+			`${copy.label}: workers must not be instructed to append session-dir files`,
+		);
+	}
+});
+
+test("#given ultraresearch journaling #when ownership is inspected #then the orchestrator owns the session journal", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.match(
+			copy.content,
+			/orchestrator[\s\S]{0,200}journal|journal[\s\S]{0,200}orchestrator/i,
+			`${copy.label}: body must assign session-journal writes to the orchestrator`,
+		);
+		assert.match(copy.content, /SESSION_DIR/, `${copy.label}: body must keep the session directory protocol`);
+	}
+});
+
+test("#given ultraresearch expansion loop #when stop rules are inspected #then convergence rules and a depth cap are stated", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.match(copy.content, /converg/i, `${copy.label}: body must define convergence`);
+		assert.match(copy.content, /depth/i, `${copy.label}: body must define an expansion depth cap`);
+		assert.match(
+			copy.content,
+			/minimum (?:of )?(?:2|two) expansion waves|at least (?:2|two) expansion waves/i,
+			`${copy.label}: body must require a minimum of two expansion waves before convergence`,
+		);
+	}
+});
+
+test("#given ultraresearch under ultrawork #when coexistence is inspected #then marker and done-definition conflicts are resolved", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.match(copy.content, /ultrawork|\bulw\b/i, `${copy.label}: body must address ultrawork coexistence`);
+		assert.match(
+			copy.content,
+			/first(?:-| )line/i,
+			`${copy.label}: body must resolve the first-line activation marker conflict`,
+		);
+	}
+});
+
+test("#given ultraresearch worker sizing #when spawn guidance is inspected #then capable-model and high-effort routing is stated", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.match(
+			copy.content,
+			/capable model|high(?:est)? (?:reasoning )?effort/i,
+			`${copy.label}: body must route research workers to a capable model or high effort`,
+		);
+	}
+});

package/packages/omo-codex/plugin/test/ulw-plan-skill.test.mjs

@@ -16,7 +16,7 @@ test("#given ulw-plan skill #when inspected #then it is a Codex-native planner t
 	// then
 	assert.match(skill, /^---\r?\nname: ulw-plan\r?\n/m);
 	assert.match(skill, /references\/full-workflow\.md/);
-	assert.match(skill, /spawn_agent\(\{[^)]*"fork_turns":"none"/);
+	assert.match(skill, /multi_agent_v1\.spawn_agent\(\{[^)]*"fork_context":false/);
 	assert.doesNotMatch(skill, opencodeOnlyToolPattern);
 });
 
@@ -37,7 +37,7 @@ test("#given ulw-plan full workflow reference #when inspected #then it documents
 	// then
 	assert.match(workflow, /\.omo\/plans\/<slug>\.md/);
 	assert.match(workflow, /[Aa]pproval gate/);
-	assert.match(workflow, /spawn_agent\(\{[^)]*"fork_turns":"none"/);
+	assert.match(workflow, /multi_agent_v1\.spawn_agent\(\{[^)]*"fork_context":false/);
 	assert.doesNotMatch(workflow, opencodeOnlyToolPattern);
 	assert.doesNotMatch(workflow, /Proceeding to plan generation/);
 });

package/packages/omo-codex/scripts/install/bin-dir.mjs

@@ -0,0 +1,20 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export function resolveCodexInstallerBinDir(options = {}) {
+	const homeDir = resolve(options.homeDir ?? homedir());
+	const env = options.env ?? process.env;
+	const explicitBinDir = nonEmptyEnvValue(env, "CODEX_LOCAL_BIN_DIR");
+	if (explicitBinDir !== undefined) return explicitBinDir;
+
+	const codexHome = resolve(options.codexHome ?? nonEmptyEnvValue(env, "CODEX_HOME") ?? join(homeDir, ".codex"));
+	const defaultCodexHome = resolve(join(homeDir, ".codex"));
+	return codexHome === defaultCodexHome ? join(homeDir, ".local", "bin") : join(codexHome, "bin");
+}
+
+export function nonEmptyEnvValue(env, key) {
+	const value = env[key];
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? undefined : trimmed;
+}

package/packages/omo-codex/scripts/install/bin-links.mjs

@@ -22,16 +22,17 @@ export async function linkCachedPluginBins({ binDir, pluginRoot, platform = proc
 export async function linkRootRuntimeBin({ binDir, codexHome, repoRoot, platform = process.platform }) {
 	const cliPath = join(repoRoot, "dist", "cli", "index.js");
 	if (!(await isFile(cliPath))) return null;
+	const nodeCliPath = join(repoRoot, "dist", "cli-node", "index.js");
 
 	await mkdir(binDir, { recursive: true });
 	if (platform === "win32") {
 		const linkPath = join(binDir, "omo.cmd");
-		await replaceRuntimeWrapper(linkPath, windowsRuntimeWrapper(cliPath, codexHome, binDir));
+		await replaceRuntimeWrapper(linkPath, windowsRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath));
 		return { name: "omo", path: linkPath, target: cliPath };
 	}
 
 	const linkPath = join(binDir, "omo");
-	await replaceRuntimeWrapper(linkPath, posixRuntimeWrapper(cliPath, codexHome, binDir));
+	await replaceRuntimeWrapper(linkPath, posixRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath));
 	await chmod(linkPath, 0o755);
 	return { name: "omo", path: linkPath, target: cliPath };
 }
@@ -162,24 +163,46 @@ async function existingNonRuntimeWrapper(path) {
 	}
 }
 
-function posixRuntimeWrapper(cliPath, codexHome, binDir) {
+function posixRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
 	const ulwLoopBin = join(binDir, "omo-ulw-loop");
+	const nodeCli = escapePosixDoubleQuoted(nodeCliPath);
 	return [
 		"#!/bin/sh",
 		`# ${RUNTIME_WRAPPER_MARKER}`,
 		`export CODEX_HOME="\${CODEX_HOME:-${escapePosixDoubleQuoted(codexHome)}}"`,
 		'export OMO_SPARKSHELL_APP_SERVER_SOCKET="${OMO_SPARKSHELL_APP_SERVER_SOCKET:-$CODEX_HOME/app-server-control/app-server-control.sock}"',
-		'BUN_BINARY="${BUN_BINARY:-bun}"',
 		'if [ "$1" = "ulw-loop" ] && [ -x "' + escapePosixDoubleQuoted(ulwLoopBin) + '" ]; then',
 		"  shift",
 		'  exec "' + escapePosixDoubleQuoted(ulwLoopBin) + '" "$@"',
 		"fi",
+		`if [ "\${OMO_RUNTIME:-}" = "node" ] && [ -f "${nodeCli}" ]; then`,
+		`  exec node "${nodeCli}" "$@"`,
+		"fi",
+		'BUN_BINARY="${BUN_BINARY:-}"',
+		'if [ -z "$BUN_BINARY" ] && command -v bun >/dev/null 2>&1; then',
+		"  BUN_BINARY=bun",
+		"fi",
+		'if [ -z "$BUN_BINARY" ]; then',
+		'  for omo_bun_candidate in "$HOME/.bun/bin/bun" /opt/homebrew/bin/bun /usr/local/bin/bun; do',
+		'    if [ -x "$omo_bun_candidate" ]; then',
+		'      BUN_BINARY="$omo_bun_candidate"',
+		"      break",
+		"    fi",
+		"  done",
+		"fi",
+		'if [ -z "$BUN_BINARY" ]; then',
+		`  if [ -f "${nodeCli}" ] && command -v node >/dev/null 2>&1; then`,
+		`    exec node "${nodeCli}" "$@"`,
+		"  fi",
+		`  echo "omo: bun runtime not found (checked PATH, ~/.bun/bin, /opt/homebrew/bin, /usr/local/bin) and the node fallback CLI is missing at ${nodeCli}; install bun from https://bun.sh, or reinstall omo and force the fallback with OMO_RUNTIME=node" >&2`,
+		"  exit 127",
+		"fi",
 		`exec "$BUN_BINARY" "${escapePosixDoubleQuoted(cliPath)}" "$@"`,
 		"",
 	].join("\n");
 }
 
-function windowsRuntimeWrapper(cliPath, codexHome, binDir) {
+function windowsRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
 	const ulwLoopBin = join(binDir, "omo-ulw-loop.cmd");
 	return [
 		"@echo off",
@@ -191,7 +214,21 @@ function windowsRuntimeWrapper(cliPath, codexHome, binDir) {
 		`  "${ulwLoopBin}" %*`,
 		"  exit /b %ERRORLEVEL%",
 		")",
-		`if defined BUN_BINARY ("%BUN_BINARY%" "${cliPath}" %*) else bun "${cliPath}" %*`,
+		`if "%OMO_RUNTIME%"=="node" if exist "${nodeCliPath}" (`,
+		`  node "${nodeCliPath}" %*`,
+		"  exit /b %ERRORLEVEL%",
+		")",
+		'if not defined BUN_BINARY where bun >nul 2>nul && set "BUN_BINARY=bun"',
+		'if not defined BUN_BINARY if exist "%USERPROFILE%\\.bun\\bin\\bun.exe" set "BUN_BINARY=%USERPROFILE%\\.bun\\bin\\bun.exe"',
+		"if not defined BUN_BINARY (",
+		`  if exist "${nodeCliPath}" (`,
+		`    node "${nodeCliPath}" %*`,
+		"    exit /b %ERRORLEVEL%",
+		"  )",
+		`  echo omo: bun runtime not found and the node fallback CLI is missing at ${nodeCliPath}; install bun from https://bun.sh or reinstall omo and force OMO_RUNTIME=node 1>&2`,
+		"  exit /b 127",
+		")",
+		`"%BUN_BINARY%" "${cliPath}" %*`,
 		"",
 	].join("\r\n");
 }

package/packages/omo-codex/scripts/install/cache.mjs

@@ -2,6 +2,8 @@ import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "nod
 import { realpathSync } from "node:fs";
 import { cp, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 
+import { stampGitBashMcpEnv } from "./git-bash-mcp-env.mjs";
+import { assertHookCommandTargets } from "./hook-targets.mjs";
 import { createCachedMcpRuntimeArgRewriter } from "./mcp-runtime-cache.mjs";
 import { exists, isRecord } from "./utils.mjs";
 export { linkCachedPluginBins, linkRootRuntimeBin } from "./bin-links.mjs";
@@ -20,7 +22,9 @@ export async function installCachedPlugin({ buildSource = true, codexHome, marke
 		await rewriteCachedPackageLocalFileDependencies(tempPath, sourcePath);
 		await maybeRunNpmInstall(tempPath, runCommand, ["ci", "--omit=dev"]);
 		await rewriteCachedMcpManifest(tempPath, sourcePath);
+		await stampGitBashMcpEnv({ pluginRoot: tempPath });
 		await rewriteCachedManifestRoot(tempPath, tempPath, targetPath);
+		await assertHookCommandTargets(tempPath);
 		await promoteDirectory(tempPath, targetPath, renameDirectory);
 	} catch (error) {
 		await rm(tempPath, { recursive: true, force: true });

package/packages/omo-codex/scripts/install/config.mjs

@@ -29,6 +29,7 @@ export async function updateCodexConfig({
 	trustedHookStates = [],
 	agentConfigs = [],
 	autonomousPermissions = false,
+	gitBashEnabled = false,
 }) {
 	await mkdir(dirname(configPath), { recursive: true });
 	let config = "";
@@ -53,7 +54,7 @@ export async function updateCodexConfig({
 	for (const pluginName of pluginNames) {
 		config = ensurePluginEnabled(config, `${pluginName}@${marketplaceName}`);
 	}
-	config = ensureOmoBuiltinMcpPolicies(config, { marketplaceName, pluginNames, platform });
+	config = ensureOmoBuiltinMcpPolicies(config, { marketplaceName, pluginNames, platform, gitBashEnabled });
 	for (const state of trustedHookStates) {
 		config = ensureHookTrusted(config, state.key, state.trustedHash);
 	}
@@ -154,10 +155,10 @@ function ensurePluginMcpEnabled(config, pluginKey, serverName, enabled) {
 	return replaceOrInsertSetting(config, section, "enabled", enabledValue);
 }
 
-function ensureOmoBuiltinMcpPolicies(config, { marketplaceName, pluginNames, platform }) {
+function ensureOmoBuiltinMcpPolicies(config, { marketplaceName, pluginNames, platform, gitBashEnabled }) {
 	if (marketplaceName !== "sisyphuslabs" || !pluginNames.includes("omo")) return config;
 	let nextConfig = ensurePluginMcpEnabled(config, "omo@sisyphuslabs", "context7", true);
-	nextConfig = ensurePluginMcpEnabled(nextConfig, "omo@sisyphuslabs", "git_bash", platform === "win32");
+	nextConfig = ensurePluginMcpEnabled(nextConfig, "omo@sisyphuslabs", "git_bash", platform === "win32" && gitBashEnabled === true);
 	return nextConfig;
 }
 
@@ -253,3 +254,4 @@ function parseJsonString(value) {
 		return null;
 	}
 }
+

package/packages/omo-codex/scripts/install/delegated-command.mjs

@@ -4,7 +4,11 @@ export async function runDelegatedOmoCommand(parsed, options) {
 		options.log(`${invocation.command} ${invocation.args.join(" ")}`);
 		return;
 	}
-	await options.runCommand(invocation.command, invocation.args, { cwd: options.cwd });
+	// The lazycodex wrapper sets OMO_INVOCATION_NAME=lazycodex to route into this
+	// Codex installer path. The delegated `omo` process must NOT inherit that name,
+	// otherwise it re-enters the lazycodex installer and recurses forever.
+	const env = { ...process.env, OMO_INVOCATION_NAME: "omo" };
+	await options.runCommand(invocation.command, invocation.args, { cwd: options.cwd, env });
 }
 
 export function buildDelegatedOmoInvocation(parsed) {

package/packages/omo-codex/scripts/install/git-bash-mcp-env.mjs

@@ -0,0 +1,28 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { exists, isRecord } from "./utils.mjs";
+
+const GIT_BASH_ENV_KEY = "OMO_CODEX_GIT_BASH_PATH";
+
+// Codex spawns plugin MCP servers with a restricted environment, so a user's
+// OMO_CODEX_GIT_BASH_PATH never reaches the git_bash server unless the cached
+// manifest forwards it explicitly.
+export async function stampGitBashMcpEnv({ pluginRoot, env = process.env, platform = process.platform }) {
+	if (platform !== "win32") return false;
+	const override = typeof env[GIT_BASH_ENV_KEY] === "string" ? env[GIT_BASH_ENV_KEY].trim() : "";
+	if (override === "") return false;
+
+	const manifestPath = join(pluginRoot, ".mcp.json");
+	if (!(await exists(manifestPath))) return false;
+	const parsed = JSON.parse(await readFile(manifestPath, "utf8"));
+	if (!isRecord(parsed) || !isRecord(parsed.mcpServers) || !isRecord(parsed.mcpServers.git_bash)) return false;
+
+	const server = parsed.mcpServers.git_bash;
+	const serverEnv = isRecord(server.env) ? server.env : {};
+	if (serverEnv[GIT_BASH_ENV_KEY] === override) return false;
+
+	server.env = { ...serverEnv, [GIT_BASH_ENV_KEY]: override };
+	await writeFile(manifestPath, `${JSON.stringify(parsed, null, "\t")}\n`);
+	return true;
+}

package/packages/omo-codex/scripts/install/git-bash.mjs

@@ -8,13 +8,13 @@ const PROGRAM_FILES_X86_GIT_BASH = "C:\\Program Files (x86)\\Git\\bin\\bash.exe"
 const WINGET_INSTALL_ARGS = ["install", "--id", "Git.Git", "-e", "--source", "winget"];
 
 export function resolveGitBash({ platform, env, exists, where }) {
-	if (platform !== "win32") return { found: true, path: null, source: "not-required" };
+	if (platform !== "win32") return { found: true, path: null, source: "not-required", checkedPaths: [] };
 
 	const checkedPaths = [];
 	const envPath = nonEmptyEnvValue(env, GIT_BASH_ENV_KEY);
 	if (envPath !== undefined) {
 		checkedPaths.push(envPath);
-		if (isBashExePath(envPath) && exists(envPath)) return { found: true, path: envPath, source: "env" };
+		if (isBashExePath(envPath) && exists(envPath)) return { found: true, path: envPath, source: "env", checkedPaths };
 		return missingGitBash(checkedPaths);
 	}
 
@@ -23,14 +23,15 @@ export function resolveGitBash({ platform, env, exists, where }) {
 		{ path: PROGRAM_FILES_X86_GIT_BASH, source: "program-files-x86" },
 	]) {
 		checkedPaths.push(candidate.path);
-		if (exists(candidate.path)) return { found: true, path: candidate.path, source: candidate.source };
+		if (exists(candidate.path)) return { found: true, path: candidate.path, source: candidate.source, checkedPaths };
 	}
 
 	for (const pathCandidate of where("bash")) {
 		const candidate = pathCandidate.trim();
 		if (candidate.length === 0) continue;
 		checkedPaths.push(candidate);
-		if (isBashExePath(candidate) && exists(candidate)) return { found: true, path: candidate, source: "path" };
+		if (isKnownNonGitBashLauncher(candidate)) continue;
+		if (isBashExePath(candidate) && exists(candidate)) return { found: true, path: candidate, source: "path", checkedPaths };
 	}
 
 	return missingGitBash(checkedPaths);
@@ -86,6 +87,13 @@ function isBashExePath(path) {
 	return path.toLowerCase().endsWith("bash.exe");
 }
 
+const NON_GIT_BASH_LAUNCHER_DIR_SEGMENTS = ["\\windows\\system32\\", "\\microsoft\\windowsapps\\"];
+
+function isKnownNonGitBashLauncher(path) {
+	const normalized = path.replaceAll("/", "\\").toLowerCase();
+	return NON_GIT_BASH_LAUNCHER_DIR_SEGMENTS.some((segment) => normalized.includes(segment));
+}
+
 function whereCommand(command) {
 	try {
 		return execFileSync("where", [command], { encoding: "utf8" })