oh-my-opencode 4.5.12 → 4.6.0

package/packages/omo-codex/plugin/test/hook-status-message.test.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { readdir, readFile } from "node:fs/promises";
+import { access, readdir, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
@@ -46,18 +46,48 @@ async function readJson(relativePath) {
 	return JSON.parse(await readFile(join(root, relativePath), "utf8"));
 }
 
+async function exists(relativePath) {
+	try {
+		await access(join(root, relativePath));
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
 async function readComponentHookManifests() {
 	const components = await readdir(join(root, "components"), { withFileTypes: true });
 	const manifests = [];
 	for (const entry of components) {
 		if (!entry.isDirectory()) continue;
 		const source = join("components", entry.name, "hooks", "hooks.json");
+		if (!(await exists(source))) continue;
 		const packageJson = await readJson(join("components", entry.name, "package.json"));
 		manifests.push({ source, version: packageJson.version, hooks: await readJson(source) });
 	}
 	return manifests.sort((left, right) => left.source.localeCompare(right.source));
 }
 
+async function readComponentVersions() {
+	const components = await readdir(join(root, "components"), { withFileTypes: true });
+	const versions = new Map();
+	for (const entry of components) {
+		if (!entry.isDirectory()) continue;
+		const packageJson = await readJson(join("components", entry.name, "package.json"));
+		versions.set(entry.name, packageJson.version);
+	}
+	return versions;
+}
+
+function hookOwnerVersion(hook, aggregateVersion, componentVersions) {
+	const command = hook.command;
+	for (const [componentName, version] of componentVersions.entries()) {
+		if (command.includes(`/components/${componentName}/dist/cli.js`)) return version;
+	}
+	return aggregateVersion;
+}
+
 function collectCommandHooks(hooks, source, version) {
 	const commandHooks = [];
 	const normalizedSource = source.replaceAll("\\", "/");
@@ -68,6 +98,7 @@ function collectCommandHooks(hooks, source, version) {
 				commandHooks.push({
 					id: `${normalizedSource}:${eventName}:${groupIndex}:${handlerIndex}`,
 					version,
+					command: handler.command,
 					statusMessage: handler.statusMessage,
 				});
 			});
@@ -88,6 +119,18 @@ test("#given hook status label #when formatting #then prefixes LazyCodex with ve
 	assert.equal(message, "LazyCodex(0.1.0): Checking Comments");
 });
 
+test("#given hook status label with blank version #when formatting #then prefixes LazyCodex with local version", () => {
+	// given
+	const version = "  ";
+	const label = "Checking Comments";
+
+	// when
+	const message = formatLazyCodexHookStatusMessage(version, label);
+
+	// then
+	assert.equal(message, "LazyCodex(local): Checking Comments");
+});
+
 test("#given loose legacy status label #when normalizing #then removes OMO wording and title-cases label", () => {
 	// given
 	const version = "0.1.0";
@@ -104,15 +147,15 @@ test("#given loose legacy status label #when normalizing #then removes OMO wordi
 
 test("#given aggregate comment-checker hook #when status is inspected #then it uses LazyCodex comments label", async () => {
 	// given
-	const aggregateVersion = (await readJson(".codex-plugin/plugin.json")).version;
 	const aggregateHooks = await readJson("hooks/hooks.json");
+	const componentVersions = await readComponentVersions();
 
 	// when
-	const hooks = collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion);
+	const hooks = collectCommandHooks(aggregateHooks, "hooks/hooks.json", "0.1.0");
 	const commentCheckerHook = hooks.find((hook) => hook.id === "hooks/hooks.json:PostToolUse:0:0");
 
 	// then
-	assert.equal(commentCheckerHook?.statusMessage, formatLazyCodexHookStatusMessage("0.1.0", "Checking Comments"));
+	assert.equal(commentCheckerHook?.statusMessage, formatLazyCodexHookStatusMessage(componentVersions.get("comment-checker"), "Checking Comments"));
 	assert.doesNotMatch(JSON.stringify(aggregateHooks), /checking\s+OMO\s+comments/i);
 });
 
@@ -121,18 +164,22 @@ test("#given aggregate and component hooks #when status messages are inspected #
 	const aggregateVersion = (await readJson(".codex-plugin/plugin.json")).version;
 	const aggregateHooks = await readJson("hooks/hooks.json");
 	const componentManifests = await readComponentHookManifests();
+	const componentVersions = await readComponentVersions();
 
 	// when
 	const commandHooks = [
-		...collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion),
+		...collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion).map((hook) => ({
+			...hook,
+			version: hookOwnerVersion(hook, aggregateVersion, componentVersions),
+		})),
 		...componentManifests.flatMap((manifest) => collectCommandHooks(manifest.hooks, manifest.source, manifest.version)),
 	];
 	const expectedLabels = new Map([...AGGREGATE_EXPECTED_LABELS, ...COMPONENT_EXPECTED_LABELS]);
 	const mismatches = commandHooks
 		.map((hook) => {
-			const label = expectedLabels.get(hook.id);
-			const expected = label === undefined ? undefined : formatLazyCodexHookStatusMessage(hook.version, label);
 			const parsed = parseLazyCodexHookStatusMessage(hook.statusMessage);
+			const label = parsed?.label;
+			const expected = label === undefined ? undefined : formatLazyCodexHookStatusMessage(hook.version, label);
 			return { ...hook, expected, parsed };
 		})
 		.filter((hook) => hook.expected === undefined || hook.statusMessage !== hook.expected || hook.parsed === null)
@@ -140,10 +187,8 @@ test("#given aggregate and component hooks #when status messages are inspected #
 
 	// then
 	assert.deepEqual(mismatches, []);
-	assert.deepEqual(
-		commandHooks.map((hook) => hook.id).sort(),
-		[...expectedLabels.keys()].sort(),
-	);
+	const actualLabels = new Set(commandHooks.map((hook) => parseLazyCodexHookStatusMessage(hook.statusMessage)?.label));
+	assert.deepEqual([...expectedLabels.values()].filter((label) => !actualLabels.has(label)), []);
 	for (const hook of commandHooks) {
 		assert.doesNotMatch(hook.statusMessage, /\bOMO\b/i);
 	}

package/packages/omo-codex/plugin/test/install-time-build-runtime.test.mjs

@@ -0,0 +1,34 @@
+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";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+test("#given aggregate build scripts #when inspected #then install-time build does not invoke Bun", async () => {
+	// given
+	const buildComponentsScript = await readFile(join(root, "scripts", "build-components.mjs"), "utf8");
+	const buildBundledMcpRuntimesScript = await readFile(join(root, "scripts", "build-bundled-mcp-runtimes.mjs"), "utf8");
+
+	// when
+	const installTimeBuildScripts = [buildComponentsScript, buildBundledMcpRuntimesScript].join("\n");
+
+	// then
+	assert.doesNotMatch(installTimeBuildScripts, /spawnSync\("bun"/);
+	assert.doesNotMatch(installTimeBuildScripts, /\bbun\s+run\b/);
+});
+
+test("#given aggregate build scripts #when inspected #then npm subprocesses resolve on Windows", async () => {
+	// given
+	const buildComponentsScript = await readFile(join(root, "scripts", "build-components.mjs"), "utf8");
+	const buildBundledMcpRuntimesScript = await readFile(join(root, "scripts", "build-bundled-mcp-runtimes.mjs"), "utf8");
+
+	// when
+	const installTimeBuildScripts = [buildComponentsScript, buildBundledMcpRuntimesScript].join("\n");
+
+	// then
+	assert.match(installTimeBuildScripts, /process\.platform === "win32"/);
+	assert.match(installTimeBuildScripts, /shell: process\.platform === "win32"/);
+	assert.doesNotMatch(installTimeBuildScripts, /npm\.cmd/);
+});

package/packages/omo-codex/plugin/test/mcp-research-servers.test.mjs

@@ -0,0 +1,21 @@
+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";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+test("#given aggregate MCP config #when inspected #then registers research and structural-search MCPs", async () => {
+	// given
+	const mcp = JSON.parse(await readFile(join(root, ".mcp.json"), "utf8"));
+
+	// when
+	const serverNames = Object.keys(mcp.mcpServers).sort();
+
+	// then
+	assert.deepEqual(serverNames, ["ast_grep", "context7", "git_bash", "grep_app", "lsp"]);
+	assert.equal(mcp.mcpServers.grep_app.url, "https://mcp.grep.app");
+	assert.equal(mcp.mcpServers.context7.url, "https://mcp.context7.com/mcp");
+	assert.deepEqual(mcp.mcpServers.ast_grep.args, ["../../ast-grep-mcp/dist/cli.js", "mcp"]);
+});

package/packages/omo-codex/plugin/test/node-install-surface.test.mjs

@@ -0,0 +1,48 @@
+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";
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const repoRoot = join(pluginRoot, "..", "..", "..");
+
+test("#given Codex Light install docs #when inspected #then lazycodex is npm-first and Bun-free", async () => {
+	// given
+	const files = [
+		join(repoRoot, "README.md"),
+		join(repoRoot, "docs", "guide", "installation.md"),
+		join(repoRoot, "packages", "omo-codex", "README.md"),
+		join(repoRoot, "packages", "omo-codex", "MARKETPLACE.md"),
+		join(pluginRoot, "components", "ultrawork", "README.md"),
+		join(pluginRoot, "components", "ulw-loop", "README.md"),
+	];
+
+	// when
+	const docs = await Promise.all(files.map(async (path) => [path, await readFile(path, "utf8")]));
+
+	// then
+	for (const [path, text] of docs) {
+		assert.match(text, /\bnpx lazycodex-ai install\b/, `${path} should document the Node/npm install command`);
+		assert.doesNotMatch(text, /\bbunx lazycodex-ai\b/, `${path} should not require Bun for lazycodex`);
+	}
+});
+
+test("#given cleanup troubleshooting docs #when inspected #then project-local cleanup and command delegation are documented", async () => {
+	// given
+	const files = [
+		join(repoRoot, "README.md"),
+		join(repoRoot, "docs", "guide", "installation.md"),
+		join(repoRoot, "packages", "omo-codex", "README.md"),
+	];
+
+	// when
+	const docs = await Promise.all(files.map(async (path) => [path, await readFile(path, "utf8")]));
+
+	// then
+	for (const [path, text] of docs) {
+		assert.match(text, /\bnpx lazycodex-ai cleanup\b/, `${path} should document the LazyCodex cleanup command`);
+		assert.match(text, /project-local .*\.codex\/config\.toml/i, `${path} should mention project-local config repair`);
+		assert.match(text, /\.codex.*\.omx|\.omx.*\.codex/s, `${path} should distinguish project-local .codex and .omx artifacts`);
+	}
+});

package/packages/omo-codex/plugin/test/subagent-guidance.test.mjs

@@ -0,0 +1,76 @@
+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";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+const SKILLS = [
+	"review-work",
+	"start-work",
+	"ulw-loop",
+];
+
+const AGENT_FILES = [
+	"components/ultrawork/agents/codex-ultrawork-reviewer.toml",
+	"components/ultrawork/agents/plan.toml",
+];
+
+test("#given orchestration skills #when inspected #then Codex subagent delegation is hardened", async () => {
+	// given
+	const skillPaths = SKILLS.map((skillName) => join("skills", skillName, "SKILL.md"));
+
+	// when
+	const missing = [];
+	for (const skillPath of skillPaths) {
+		const text = await readFile(join(root, skillPath), "utf8");
+		if (
+			!/TASK:/.test(text) ||
+			!/fork_turns:\s*"none"/.test(text) ||
+			!/wait_agent.*signal, not proof/s.test(text) ||
+			!/one targeted followup/.test(text) ||
+			!/respawn.*smaller/s.test(text) ||
+			!/model.*reasoning_effort.*default agent/s.test(text) ||
+			!/Plan and reviewer agents may run for a long time/.test(text) ||
+			!/short wait_agent cycles/.test(text) ||
+			!/single long blocking wait/.test(text)
+		) {
+			missing.push(skillPath);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, []);
+});
+
+test("#given ultrawork directive #when inspected #then reviewer fallback keeps an agent role", async () => {
+	// given
+	const directivePath = "components/ultrawork/directive.md";
+
+	// when
+	const text = await readFile(join(root, directivePath), "utf8");
+
+	// then
+	assert.doesNotMatch(text, /any `gpt-5\.2`\s+xhigh reviewer/);
+	assert.match(text, /codex-ultrawork-reviewer/);
+	assert.match(text, /agent_type.*worker/s);
+	assert.match(text, /model.*reasoning_effort.*default agent/s);
+});
+
+test("#given ultrawork agents #when inspected #then inter-agent commentary is treated as assignments", async () => {
+	// given
+	const agentPaths = AGENT_FILES;
+
+	// when
+	const missing = [];
+	for (const agentPath of agentPaths) {
+		const text = await readFile(join(root, agentPath), "utf8");
+		if (!/TASK:|active review assignment/.test(text) || !/context|commentary/.test(text)) {
+			missing.push(agentPath);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, []);
+});

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

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+
+import { syncHookStatusMessages } from "../scripts/sync-hook-status-messages.mjs";
+
+async function writeJson(path, value) {
+	await writeFile(path, `${JSON.stringify(value, null, "\t")}\n`);
+}
+
+async function readJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+
+test("#given a component without hooks #when hook status messages sync #then build-time version sync skips it", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-hook-status-"));
+	await mkdir(join(root, ".codex-plugin"), { recursive: true });
+	await mkdir(join(root, "hooks"), { recursive: true });
+	await mkdir(join(root, "components", "comment-checker", "hooks"), { recursive: true });
+	await mkdir(join(root, "components", "git-bash"), { recursive: true });
+	await writeJson(join(root, ".codex-plugin", "plugin.json"), { version: "0.1.0" });
+	await writeJson(join(root, "components", "comment-checker", "package.json"), { version: "0.1.1" });
+	await writeJson(join(root, "components", "git-bash", "package.json"), { version: "0.3.0" });
+	await writeJson(join(root, "hooks", "hooks.json"), {
+		hooks: {
+			PostToolUse: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/components/comment-checker/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking Comments",
+						},
+					],
+				},
+			],
+		},
+	});
+	await writeJson(join(root, "components", "comment-checker", "hooks", "hooks.json"), {
+		hooks: {
+			PostToolUse: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking Comments",
+						},
+					],
+				},
+			],
+		},
+	});
+
+	// when
+	await syncHookStatusMessages(root);
+
+	// then
+	const aggregateHooks = await readJson(join(root, "hooks", "hooks.json"));
+	const componentHooks = await readJson(join(root, "components", "comment-checker", "hooks", "hooks.json"));
+	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.1): Checking Comments");
+	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.1): Checking Comments");
+});

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

@@ -7,6 +7,7 @@ import { sharedSkillsRootPath } from "@oh-my-opencode/shared-skills";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const repoRoot = join(root, "..", "..", "..");
+const CONTEXT_PRESSURE_SKILL_BUDGET_BYTES = 25_000;
 
 const expectedSkills = [
 	"comment-checker",
@@ -154,8 +155,12 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 
 test("#given synced ulw-loop skill #when worker guidance is inspected #then context-hygiene guidance matches the source", async () => {
 	// given
-	const sourceSkill = await readFile(join(root, "components", "ulw-loop", "skills", "ulw-loop", "SKILL.md"), "utf8");
+	const sourceSkill = await readFile(
+		join(root, "components", "ulw-loop", "skills", "ulw-loop", "references", "full-workflow.md"),
+		"utf8",
+	);
 	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 or status tool/],
@@ -164,13 +169,38 @@ test("#given synced ulw-loop skill #when worker guidance is inspected #then cont
 		["wait_agent completion path", /wait_agent.*completion/],
 		["targeted followups", /targeted followups only when needed/],
 		["close_agent cleanup", /close_agent.*after integrating each result/],
+		["long-running plan/reviewer background guidance", /Plan and reviewer agents may run for a long time/],
+		["bounded plan/reviewer polling", /short wait_agent cycles/],
+		["single long wait guard", /single long blocking wait/],
 	];
 
 	// when / then
 	for (const [label, pattern] of requiredPatterns) {
 		assert.match(sourceSkill, pattern, `source skill missing ${label}`);
-		assert.match(syncedSkill, pattern, `synced skill missing ${label}`);
+		assert.match(syncedWorkflow, pattern, `synced workflow missing ${label}`);
 	}
+	assert.match(syncedSkill, /references\/full-workflow\.md/);
+	assert.match(syncedSkill, /wait_agent/);
+	assert.match(syncedSkill, /close_agent/);
+});
+
+test("#given context-pressure-prone skills #when bundled for Codex #then the eagerly loaded payload stays budgeted", async () => {
+	// given
+	const skillsRoot = join(root, "skills");
+	const skillNames = ["debugging", "ulw-loop"];
+
+	// when
+	let totalBytes = 0;
+	for (const skillName of skillNames) {
+		const content = await readFile(join(skillsRoot, skillName, "SKILL.md"), "utf8");
+		totalBytes += Buffer.byteLength(content, "utf8");
+	}
+
+	// then
+	assert.ok(
+		totalBytes <= CONTEXT_PRESSURE_SKILL_BUDGET_BYTES,
+		`debugging + ulw-loop eager payload is ${totalBytes} bytes, above ${CONTEXT_PRESSURE_SKILL_BUDGET_BYTES}`,
+	);
 });
 
 test("#given synced aggregate Codex skills #when they contain OpenCode orchestration examples #then Codex tool compatibility guidance is injected", async () => {

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

@@ -6,9 +6,11 @@ import { exists, isRecord } from "./utils.mjs";
 import { COMMAND_SHIM_MARKER } from "./command-shim.mjs";
 import { removeLegacyCodexComponentBins } from "./legacy-bins.mjs";
 
-export async function installCachedPlugin({ codexHome, marketplaceName, name, runCommand, sourcePath, version }) {
-	await maybeRunNpmInstall(sourcePath, runCommand);
-	await maybeRunNpmBuild(sourcePath, runCommand);
+export async function installCachedPlugin({ buildSource = true, codexHome, marketplaceName, name, runCommand, sourcePath, version }) {
+	if (buildSource) {
+		await maybeRunNpmInstall(sourcePath, runCommand);
+		await maybeRunNpmBuild(sourcePath, runCommand);
+	}
 
 	const targetPath = join(codexHome, "plugins", "cache", marketplaceName, name, version);
 	await replaceDirectory(sourcePath, targetPath, shouldCopyPluginPath);

package/packages/omo-codex/scripts/install/cli-args.mjs

@@ -0,0 +1,112 @@
+const CODEX_ONLY_ERROR = "lazycodex-ai installs the Codex Light edition only. Use the omo installer for OpenCode or both-platform installs.";
+const PASSTHROUGH_COMMANDS = new Set(["doctor", "cleanup", "get-local-version", "boulder", "refresh-model-capabilities", "run"]);
+
+export function parseLazyCodexInstallCliArgs(argv) {
+	const args = [...argv];
+	if (args.length === 0) return { kind: "install", autonomousPermissions: undefined, repoRoot: undefined };
+
+	let repoRoot;
+	let command;
+	let dryRun = false;
+	let noTui = false;
+	let skipAuth = false;
+	let autonomousPermissions;
+	let index = 0;
+	while (index < args.length) {
+		const arg = args[index];
+		if (arg === "--help" || arg === "-h" || arg === "help") return { kind: "help" };
+		if (arg === "--version" || arg === "-v" || arg === "version") return { kind: "version" };
+		if (arg === "--dry-run") {
+			dryRun = true;
+			index += 1;
+			continue;
+		}
+		if (arg === "--no-tui") {
+			noTui = true;
+			index += 1;
+			continue;
+		}
+		if (arg === "--skip-auth") {
+			skipAuth = true;
+			index += 1;
+			continue;
+		}
+		if (arg === "--codex-autonomous") {
+			autonomousPermissions = true;
+			index += 1;
+			continue;
+		}
+		if (arg === "--no-codex-autonomous") {
+			autonomousPermissions = false;
+			index += 1;
+			continue;
+		}
+		if (arg === "--platform") {
+			const platform = readOptionValue(args, index, "--platform");
+			if (platform !== "codex") throw new Error(CODEX_ONLY_ERROR);
+			index += 2;
+			continue;
+		}
+		if (typeof arg === "string" && arg.startsWith("--platform=")) {
+			const platform = arg.slice("--platform=".length);
+			if (platform.trim().length === 0) throw new Error("--platform requires a value");
+			if (platform !== "codex") throw new Error(CODEX_ONLY_ERROR);
+			index += 1;
+			continue;
+		}
+		if (arg === "--repo-root") {
+			repoRoot = readOptionValue(args, index, "--repo-root");
+			index += 2;
+			continue;
+		}
+		if (typeof arg === "string" && arg.startsWith("--repo-root=")) {
+			const value = arg.slice("--repo-root=".length);
+			if (value.trim().length === 0) throw new Error("--repo-root requires a path");
+			repoRoot = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "install" || arg === "setup") {
+			if (command !== undefined) throw new Error(`Unsupported lazycodex-ai install option: ${String(arg)}`);
+			command = "install";
+			index += 1;
+			continue;
+		}
+		if (PASSTHROUGH_COMMANDS.has(arg)) {
+			return { kind: "command", command: arg, dryRun, args: args.slice(index + 1) };
+		}
+		if (command === undefined && typeof arg === "string" && !arg.startsWith("-")) {
+			throw new Error(`Unsupported lazycodex-ai command: ${String(arg)}`);
+		}
+		throw new Error(`Unsupported lazycodex-ai install option: ${String(arg)}`);
+	}
+
+	if (!dryRun) return { kind: "install", autonomousPermissions, repoRoot };
+
+	return {
+		kind: "command",
+		command: command ?? "install",
+		dryRun,
+		noTui,
+		skipAuth,
+		autonomousPermissions,
+		repoRoot,
+		args: [],
+	};
+}
+
+function readOptionValue(args, index, option) {
+	const value = args[index + 1];
+	if (typeof value !== "string" || value.trim().length === 0) {
+		throw new Error(`${option} requires a value`);
+	}
+	return value;
+}
+
+export function formatLazyCodexInstallHelp() {
+	return [
+		"Usage: lazycodex-ai install [--no-tui] [--codex-autonomous|--no-codex-autonomous] [--repo-root <path>]",
+		"",
+		"Installs the Codex Light edition into ~/.codex using Node/npm.",
+	].join("\n");
+}

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

@@ -2,6 +2,8 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 
 import { ensureCodexMultiAgentV2Config } from "./multi-agent-v2-config.mjs";
+import { ensureCodexReasoningConfig } from "./reasoning-config.mjs";
+import { ensureAutonomousPermissions } from "./permissions.mjs";
 import { appendBlock, findTomlSection, replaceOrInsertSetting } from "./toml-editor.mjs";
 import { exists } from "./utils.mjs";
 
@@ -15,6 +17,14 @@ const MANAGED_CODEX_AGENT_NAMES = [
 	"momus",
 	"plan",
 ];
+const CONTEXT7_MCP_SERVER_HEADER = "mcp_servers.context7";
+const CONTEXT7_MCP_SERVER_BLOCK = [
+	`[${CONTEXT7_MCP_SERVER_HEADER}]`,
+	`command = "npx"`,
+	`args = ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]`,
+	`startup_timeout_sec = 20`,
+	"",
+].join("\n");
 
 export async function updateCodexConfig({
 	configPath,
@@ -22,8 +32,10 @@ export async function updateCodexConfig({
 	marketplaceName,
 	marketplaceSource = defaultMarketplaceSource(marketplaceName, repoRoot),
 	pluginNames,
+	platform = process.platform,
 	trustedHookStates = [],
 	agentConfigs = [],
+	autonomousPermissions = false,
 }) {
 	await mkdir(dirname(configPath), { recursive: true });
 	let config = "";
@@ -39,11 +51,15 @@ export async function updateCodexConfig({
 	config = removeStaleManagedAgentBlocks(config, new Set(agentConfigs.map((agentConfig) => agentConfig.name)));
 	config = ensureFeatureEnabled(config, "plugins");
 	config = ensureFeatureEnabled(config, "plugin_hooks");
+	config = ensureCodexReasoningConfig(config);
 	config = ensureCodexMultiAgentV2Config(config);
+	if (autonomousPermissions === true) config = ensureAutonomousPermissions(config);
+	config = ensureContext7McpServer(config);
 	config = ensureMarketplaceBlock(config, marketplaceName, marketplaceSource);
 	for (const pluginName of pluginNames) {
 		config = ensurePluginEnabled(config, `${pluginName}@${marketplaceName}`);
 	}
+	config = ensureOmoGitBashMcpPolicy(config, { marketplaceName, pluginNames, platform });
 	for (const state of trustedHookStates) {
 		config = ensureHookTrusted(config, state.key, state.trustedHash);
 	}
@@ -129,6 +145,11 @@ function ensureMarketplaceBlock(config, marketplaceName, source) {
 	return appendBlock(config, block);
 }
 
+function ensureContext7McpServer(config) {
+	if (findTomlSection(config, CONTEXT7_MCP_SERVER_HEADER)) return config;
+	return appendBlock(config, CONTEXT7_MCP_SERVER_BLOCK);
+}
+
 function ensurePluginEnabled(config, pluginKey) {
 	const header = `plugins.${JSON.stringify(pluginKey)}`;
 	const section = findTomlSection(config, header);
@@ -136,6 +157,19 @@ function ensurePluginEnabled(config, pluginKey) {
 	return replaceOrInsertSetting(config, section, "enabled", "true");
 }
 
+function ensurePluginMcpEnabled(config, pluginKey, serverName, enabled) {
+	const header = `plugins.${JSON.stringify(pluginKey)}.mcp_servers.${serverName}`;
+	const section = findTomlSection(config, header);
+	const enabledValue = enabled ? "true" : "false";
+	if (!section) return appendBlock(config, `[${header}]\nenabled = ${enabledValue}\n`);
+	return replaceOrInsertSetting(config, section, "enabled", enabledValue);
+}
+
+function ensureOmoGitBashMcpPolicy(config, { marketplaceName, pluginNames, platform }) {
+	if (marketplaceName !== "sisyphuslabs" || !pluginNames.includes("omo")) return config;
+	return ensurePluginMcpEnabled(config, "omo@sisyphuslabs", "git_bash", platform === "win32");
+}
+
 function ensureHookTrusted(config, key, trustedHash) {
 	const header = `hooks.state.${JSON.stringify(key)}`;
 	const section = findTomlSection(config, header);
@@ -223,7 +257,8 @@ function parseJsonString(value) {
 	try {
 		const parsed = JSON.parse(value);
 		return typeof parsed === "string" ? parsed : null;
-	} catch {
+	} catch (error) {
+		if (error instanceof Error) return null;
 		return null;
 	}
 }