oh-my-opencode 4.5.12 → 4.7.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";
@@ -15,6 +15,7 @@ const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const AGGREGATE_EXPECTED_LABELS = new Map([
 	["hooks/hooks.json:SessionStart:0:0", "Loading Project Rules"],
 	["hooks/hooks.json:SessionStart:1:0", "Recording Session Telemetry"],
+	["hooks/hooks.json:SessionStart:2:0", "Checking Auto Update"],
 	["hooks/hooks.json:UserPromptSubmit:0:0", "Loading Project Rules"],
 	["hooks/hooks.json:UserPromptSubmit:1:0", "Checking Ultrawork Trigger"],
 	["hooks/hooks.json:UserPromptSubmit:2:0", "Checking Ulw-Loop Steering"],
@@ -46,18 +47,49 @@ 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;
+		if (!(await exists(join("components", entry.name, "package.json")))) 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 +100,7 @@ function collectCommandHooks(hooks, source, version) {
 				commandHooks.push({
 					id: `${normalizedSource}:${eventName}:${groupIndex}:${handlerIndex}`,
 					version,
+					command: handler.command,
 					statusMessage: handler.statusMessage,
 				});
 			});
@@ -88,6 +121,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 +149,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 +166,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 +189,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/migrate-codex-config.test.mjs

@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+
+import { ensureCodexReasoningConfig, migrateCodexConfig } from "../scripts/migrate-codex-config.mjs";
+
+test("#given stale root reasoning config #when ensuring config #then replaces stale values without duplicate keys", () => {
+	const result = ensureCodexReasoningConfig(
+		[
+			'model = "gpt-5.2"',
+			"model_context_window = 272000",
+			'model_reasoning_effort = "low"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+			"[features]",
+			"plugins = true",
+			"",
+		].join("\n"),
+	);
+
+	assert.equal(result.match(/^model\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^model_context_window\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^model_reasoning_effort\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^plan_mode_reasoning_effort\s*=/gm)?.length, 1);
+	assert.match(result, /model = "gpt-5\.5"/);
+	assert.match(result, /model_context_window = 400000/);
+	assert.match(result, /model_reasoning_effort = "high"/);
+	assert.match(result, /plan_mode_reasoning_effort = "xhigh"/);
+	assert.doesNotMatch(result, /gpt-5\.2/);
+	assert.match(result, /\[features\]/);
+});
+
+test("#given global and project-local stale Codex configs #when migrating #then both configs are forced to current defaults", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-migration-"));
+	const codexHome = join(root, "codex-home");
+	const project = join(root, "project", "nested");
+	const projectConfig = join(root, "project", ".codex", "config.toml");
+	await mkdir(codexHome, { recursive: true });
+	await mkdir(dirname(projectConfig), { recursive: true });
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.2"\n');
+	await writeFile(projectConfig, 'model = "gpt-5.2"\nmodel_context_window = 272000\n');
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: project,
+	});
+
+	assert.deepEqual(result.changed.sort(), [join(codexHome, "config.toml"), projectConfig].sort());
+	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /model = "gpt-5\.5"/);
+	assert.match(await readFile(projectConfig, "utf8"), /model_context_window = 400000/);
+});
+
+test("#given user-customized Codex model config #when migrating #then user values are preserved", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-custom-"));
+	const codexHome = join(root, "codex-home");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		join(codexHome, "config.toml"),
+		[
+			'model = "gpt-5.4"',
+			"model_context_window = 123456",
+			'model_reasoning_effort = "medium"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+		].join("\n"),
+	);
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: root,
+	});
+
+	const content = await readFile(join(codexHome, "config.toml"), "utf8");
+	assert.deepEqual(result.changed, []);
+	assert.match(content, /model = "gpt-5\.4"/);
+	assert.match(content, /model_context_window = 123456/);
+	assert.match(content, /model_reasoning_effort = "medium"/);
+	assert.match(content, /plan_mode_reasoning_effort = "medium"/);
+});
+
+test("#given managed catalog state #when catalog version advances #then only previously managed config is updated", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-catalog-state-"));
+	const codexHome = join(root, "codex-home");
+	const catalogPath = join(root, "catalog.json");
+	const statePath = join(root, "model-state.json");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		catalogPath,
+		JSON.stringify(
+			{
+				version: "test.v1",
+				current: {
+					model: "gpt-5.4",
+					model_context_window: 1000000,
+					model_reasoning_effort: "high",
+					plan_mode_reasoning_effort: "xhigh",
+				},
+				managedProfiles: [],
+			},
+			null,
+			2,
+		),
+	);
+
+	const first = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: catalogPath,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: statePath,
+		},
+		cwd: root,
+	});
+	await writeFile(
+		catalogPath,
+		JSON.stringify(
+			{
+				version: "test.v2",
+				current: {
+					model: "gpt-5.5",
+					model_context_window: 400000,
+					model_reasoning_effort: "high",
+					plan_mode_reasoning_effort: "xhigh",
+				},
+				managedProfiles: [],
+			},
+			null,
+			2,
+		),
+	);
+	const second = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: catalogPath,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: statePath,
+		},
+		cwd: root,
+	});
+
+	const content = await readFile(join(codexHome, "config.toml"), "utf8");
+	assert.deepEqual(first.changed, [join(codexHome, "config.toml")]);
+	assert.deepEqual(second.changed, [join(codexHome, "config.toml")]);
+	assert.match(content, /model = "gpt-5\.5"/);
+	assert.match(content, /model_context_window = 400000/);
+});

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,67 @@
+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 mkdir(join(root, "components", "stale-build-output", "dist"), { 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,12 +7,14 @@ 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",
 	"debugging",
 	"frontend-ui-ux",
 	"init-deep",
+	"lcx-report-bug",
 	"lsp",
 	"programming",
 	"refactor",
@@ -32,6 +34,7 @@ const componentSkillSources = [
 ];
 
 const codexCompatibilityEndMarkers = [
+	"Codex full-history forks inherit the parent agent type, model, and reasoning effort, so role-specific spawns with `agent_type` must 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",
 ];
@@ -152,10 +155,34 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 	assert.match(interfaceMetadata, /- "ulw-loop"/);
 });
 
+test("#given synced lcx-report-bug skill #when inspected #then it files LazyCodex bug issues from proven debugging evidence", async () => {
+	// given
+	const skillRoot = join(root, "skills", "lcx-report-bug");
+
+	// when
+	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
+	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
+
+	// then
+	assert.match(skill, /^---\r?\nname: lcx-report-bug\r?\n/m);
+	assert.match(skill, /code-yeongyu\/lazycodex/);
+	assert.match(skill, /\$omo:debugging/);
+	assert.match(skill, /gh issue create --repo code-yeongyu\/lazycodex/);
+	assert.match(skill, /Browser use fallback/);
+	assert.match(skill, /Computer use fallback/);
+	assert.match(skill, /## Issue Body Template/);
+	assert.match(interfaceMetadata, /display_name: "lcx-report-bug \(omo\)"/);
+	assert.match(interfaceMetadata, /- "lazycodex bug"/);
+});
+
 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 +191,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);