oh-my-opencode 4.7.5 → 4.8.0

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

@@ -1,10 +1,23 @@
 import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, utimes, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
 
-import { resolveAutoUpdatePlan, runAutoUpdateCheck } from "../scripts/auto-update.mjs";
+import { resolveAutoUpdatePlan, resolveLazyCodexUpdatePlan, runAutoUpdateCheck } from "../scripts/auto-update.mjs";
+import { resolveSpawnInvocation } from "../scripts/spawn-command.mjs";
+
+function autoUpdateEnv(root, extra = {}) {
+	return {
+		CODEX_HOME: join(root, "codex-home"),
+		LAZYCODEX_CURRENT_VERSION: "1.0.0",
+		LAZYCODEX_LATEST_VERSION: "1.0.1",
+		LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
+		LAZYCODEX_AUTO_UPDATE_STATE_PATH: join(root, "state.json"),
+		LAZYCODEX_AUTO_UPDATE_LOG_PATH: join(root, "auto-update.log"),
+		...extra,
+	};
+}
 
 test("#given auto update is disabled #when resolving plan #then no command is scheduled", () => {
 	const plan = resolveAutoUpdatePlan({
@@ -19,14 +32,85 @@ test("#given auto update is disabled #when resolving plan #then no command is sc
 
 test("#given stale state #when resolving plan #then installer update command is scheduled", () => {
 	const plan = resolveAutoUpdatePlan({
-		env: {},
+		env: { LAZYCODEX_CURRENT_VERSION: "1.0.0", LAZYCODEX_LATEST_VERSION: "1.0.1" },
 		now: 90_000_000,
 		lastCheckedAt: 0,
 	});
 
 	assert.equal(plan.shouldRun, true);
 	assert.deepEqual(plan.command, "npx");
-	assert.deepEqual(plan.args, ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--skip-auth"]);
+	assert.deepEqual(plan.args, ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--codex-autonomous"]);
+});
+
+test("#given Windows npm shims #when resolving spawn commands #then cmd shims are used", () => {
+	assert.deepEqual(resolveSpawnInvocation("npm", ["install"], "win32"), {
+		command: "cmd.exe",
+		args: ["/d", "/s", "/c", "npm.cmd", "install"],
+	});
+	assert.deepEqual(resolveSpawnInvocation("npx", ["--yes", "lazycodex-ai@latest"], "win32"), {
+		command: "cmd.exe",
+		args: ["/d", "/s", "/c", "npx.cmd", "--yes", "lazycodex-ai@latest"],
+	});
+	assert.deepEqual(resolveSpawnInvocation("node", ["script.mjs"], "win32"), {
+		command: "node",
+		args: ["script.mjs"],
+	});
+	assert.deepEqual(resolveSpawnInvocation("npx", ["--yes"], "darwin"), {
+		command: "npx",
+		args: ["--yes"],
+	});
+});
+
+test("#given current version #when resolving update plan #then skips installer", () => {
+	const plan = resolveLazyCodexUpdatePlan({
+		currentVersion: "1.0.1",
+		latestVersion: "1.0.1",
+	});
+
+	assert.equal(plan.shouldUpdate, false);
+	assert.equal(plan.reason, "up-to-date");
+});
+
+test("#given latest version is newer #when resolving update plan #then schedules installer", () => {
+	const plan = resolveLazyCodexUpdatePlan({
+		currentVersion: "1.0.0",
+		latestVersion: "1.0.1",
+	});
+
+	assert.equal(plan.shouldUpdate, true);
+	assert.deepEqual(plan.command, "npx");
+	assert.deepEqual(plan.args, ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--codex-autonomous"]);
+});
+
+test("#given current version is a prerelease of latest #when resolving update plan #then schedules stable installer", () => {
+	const plan = resolveLazyCodexUpdatePlan({
+		currentVersion: "1.0.1-beta.1",
+		latestVersion: "1.0.1",
+	});
+
+	assert.equal(plan.shouldUpdate, true);
+	assert.deepEqual(plan.args, ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--codex-autonomous"]);
+});
+
+test("#given malformed latest version #when resolving update plan #then fails closed without scheduling", () => {
+	const plan = resolveLazyCodexUpdatePlan({
+		currentVersion: "1.0.0",
+		latestVersion: "latest",
+	});
+
+	assert.equal(plan.shouldUpdate, false);
+	assert.equal(plan.reason, "unknown-latest");
+});
+
+test("#given current version #when resolving auto update plan #then no command is scheduled", () => {
+	const plan = resolveAutoUpdatePlan({
+		env: { LAZYCODEX_CURRENT_VERSION: "1.0.1", LAZYCODEX_LATEST_VERSION: "1.0.1" },
+		now: 90_000_000,
+		lastCheckedAt: 0,
+	});
+
+	assert.equal(plan.shouldRun, false);
+	assert.equal(plan.reason, "up-to-date");
 });
 
 test("#given recent state #when resolving plan #then update is throttled", () => {
@@ -40,31 +124,47 @@ test("#given recent state #when resolving plan #then update is throttled", () =>
 	assert.equal(plan.reason, "throttled");
 });
 
+test("#given installed lazycodex version snapshot #when resolving auto update plan #then uses distribution version", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-version-"));
+	const versionPath = join(root, "lazycodex-install.json");
+	await writeFile(versionPath, JSON.stringify({ packageName: "lazycodex-ai", version: "1.0.1" }));
+
+	const plan = resolveAutoUpdatePlan({
+		env: {
+			LAZYCODEX_INSTALLED_VERSION_PATH: versionPath,
+			LAZYCODEX_LATEST_VERSION: "1.0.1",
+		},
+		now: 90_000_000,
+		lastCheckedAt: 0,
+	});
+
+	assert.equal(plan.shouldRun, false);
+	assert.equal(plan.reason, "up-to-date");
+});
+
 test("#given test command override #when running check #then records state and launches command", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-"));
 	const logPath = join(root, "spawn.log");
-	const updateLogPath = join(root, "auto-update.log");
-	const statePath = join(root, "state.json");
-	const codexHome = join(root, "codex-home");
+	const env = autoUpdateEnv(root, {
+		LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "0",
+		LAZYCODEX_AUTO_UPDATE_COMMAND: process.execPath,
+		LAZYCODEX_AUTO_UPDATE_ARGS_JSON: JSON.stringify(["-e", `require("node:fs").writeFileSync(${JSON.stringify(logPath)}, "ok")`]),
+		LAZYCODEX_AUTO_UPDATE_WAIT: "1",
+	});
 
 	const result = await runAutoUpdateCheck({
-		env: {
-			CODEX_HOME: codexHome,
-			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
-			LAZYCODEX_AUTO_UPDATE_STATE_PATH: statePath,
-			LAZYCODEX_AUTO_UPDATE_LOG_PATH: updateLogPath,
-			LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "0",
-			LAZYCODEX_AUTO_UPDATE_COMMAND: process.execPath,
-			LAZYCODEX_AUTO_UPDATE_ARGS_JSON: JSON.stringify(["-e", `require("node:fs").writeFileSync(${JSON.stringify(logPath)}, "ok")`]),
-			LAZYCODEX_AUTO_UPDATE_WAIT: "1",
-		},
+		env,
 		now: 123_456,
 	});
 
 	assert.equal(result.started, true);
-	assert.equal(JSON.parse(await readFile(statePath, "utf8")).lastCheckedAt, 123_456);
+	assert.deepEqual(JSON.parse(await readFile(env.LAZYCODEX_AUTO_UPDATE_STATE_PATH, "utf8")), {
+		lastCheckedAt: 123_456,
+		lastAttemptedAt: 123_456,
+		lastStatus: "success",
+	});
 	assert.equal(await readFile(logPath, "utf8"), "ok");
-	const updateLog = (await readFile(updateLogPath, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
+	const updateLog = (await readFile(env.LAZYCODEX_AUTO_UPDATE_LOG_PATH, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
 	assert.deepEqual(updateLog, [
 		{
 			timestamp: "1970-01-01T00:02:03.456Z",
@@ -78,43 +178,104 @@ test("#given test command override #when running check #then records state and l
 			status: 0,
 		},
 	]);
-	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /model = "gpt-5\.5"/);
+	assert.match(await readFile(join(env.CODEX_HOME, "config.toml"), "utf8"), /model = "gpt-5\.5"/);
+});
+
+test("#given failed waited update #when retry window passes #then next update is not blocked by success throttle", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-retry-"));
+	const successPath = join(root, "success.log");
+	const baseEnv = autoUpdateEnv(root, {
+		LAZYCODEX_AUTO_UPDATE_WAIT: "1",
+		LAZYCODEX_AUTO_UPDATE_COMMAND: process.execPath,
+	});
+
+	const failed = await runAutoUpdateCheck({
+		env: {
+			...baseEnv,
+			LAZYCODEX_AUTO_UPDATE_ARGS_JSON: JSON.stringify(["-e", "process.exit(1)"]),
+		},
+		now: 123_456,
+	});
+	assert.equal(failed.started, true);
+	assert.equal(failed.status, 1);
+	assert.deepEqual(JSON.parse(await readFile(baseEnv.LAZYCODEX_AUTO_UPDATE_STATE_PATH, "utf8")), {
+		lastAttemptedAt: 123_456,
+		lastStatus: "failed",
+	});
+
+	const retried = await runAutoUpdateCheck({
+		env: {
+			...baseEnv,
+			LAZYCODEX_AUTO_UPDATE_ARGS_JSON: JSON.stringify(["-e", `require("node:fs").writeFileSync(${JSON.stringify(successPath)}, "ok")`]),
+		},
+		now: 123_456 + 30 * 60 * 1_000 + 1,
+	});
+
+	assert.equal(retried.started, true);
+	assert.equal(retried.status, 0);
+	assert.equal(await readFile(successPath, "utf8"), "ok");
 });
 
 test("#given active lock #when running check #then skips concurrent update", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-lock-"));
-	const statePath = join(root, "state.json");
 	const lockPath = join(root, "state.json.lock");
-	const codexHome = join(root, "codex-home");
 	await writeFile(lockPath, "locked\n");
 
 	const result = await runAutoUpdateCheck({
-		env: {
-			CODEX_HOME: codexHome,
-			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
-			LAZYCODEX_AUTO_UPDATE_STATE_PATH: statePath,
+		env: autoUpdateEnv(root, {
 			LAZYCODEX_AUTO_UPDATE_LOCK_PATH: lockPath,
 			LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "0",
 			LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS: "600000",
-		},
+		}),
 		now: 123_456,
 	});
 
 	assert.equal(result.started, false);
 	assert.equal(result.reason, "locked");
-	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /model_context_window = 400000/);
+	assert.match(await readFile(join(root, "codex-home", "config.toml"), "utf8"), /model_context_window = 400000/);
+});
+
+test("#given stale lock #when running check #then removes lock and runs update", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-stale-lock-"));
+	const lockPath = join(root, "state.json.lock");
+	const successPath = join(root, "success.log");
+	await writeFile(lockPath, "locked\n");
+	await utimes(lockPath, new Date(0), new Date(0));
+	const env = autoUpdateEnv(root, {
+		LAZYCODEX_AUTO_UPDATE_LOCK_PATH: lockPath,
+		LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "0",
+		LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS: "600000",
+		LAZYCODEX_AUTO_UPDATE_WAIT: "1",
+		LAZYCODEX_AUTO_UPDATE_COMMAND: process.execPath,
+		LAZYCODEX_AUTO_UPDATE_ARGS_JSON: JSON.stringify(["-e", `require("node:fs").writeFileSync(${JSON.stringify(successPath)}, "ok")`]),
+	});
+
+	const result = await runAutoUpdateCheck({
+		env,
+		now: 1_000_000,
+	});
+
+	assert.equal(result.started, true);
+	assert.equal(result.status, 0);
+	assert.equal(await readFile(successPath, "utf8"), "ok");
+	assert.deepEqual(JSON.parse(await readFile(env.LAZYCODEX_AUTO_UPDATE_STATE_PATH, "utf8")), {
+		lastCheckedAt: 1_000_000,
+		lastAttemptedAt: 1_000_000,
+		lastStatus: "success",
+	});
 });
 
 test("#given throttled updater and stale Codex config #when running check #then config migration still runs", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-migration-"));
 	const statePath = join(root, "state.json");
+	const updateLogPath = join(root, "auto-update.log");
 	const codexHome = join(root, "codex-home");
 	await writeFile(statePath, JSON.stringify({ lastCheckedAt: 99_999 }, null, 2));
 	await mkdir(codexHome, { recursive: true });
 	await writeFile(
 		join(codexHome, "config.toml"),
 		[
-			'model = "gpt-5.2"',
+			'model = "gpt-5.5"',
 			"model_context_window = 272000",
 			'model_reasoning_effort = "low"',
 			'plan_mode_reasoning_effort = "medium"',
@@ -130,6 +291,7 @@ test("#given throttled updater and stale Codex config #when running check #then
 			CODEX_HOME: codexHome,
 			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
 			LAZYCODEX_AUTO_UPDATE_STATE_PATH: statePath,
+			LAZYCODEX_AUTO_UPDATE_LOG_PATH: updateLogPath,
 		},
 		now: 100_000,
 	});

package/packages/omo-codex/plugin/test/component-bin-names.test.mjs

@@ -13,7 +13,7 @@ const EXPECTED_COMPONENT_BINS = new Map([
 	["start-work-continuation", "omo-start-work-continuation"],
 	["telemetry", "omo-telemetry"],
 	["ultrawork", "omo-ultrawork"],
-	["ulw-loop", "omo"],
+	["ulw-loop", "omo-ulw-loop"],
 ]);
 
 const EXPECTED_USAGE_PREFIXES = new Map([

package/packages/omo-codex/plugin/test/global-review-debug-gate.test.mjs

@@ -0,0 +1,29 @@
+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)));
+
+test("#given start-work continuation directive #when inspected #then final handoff requires review and debugging gate", async () => {
+	const text = await readFile(join(pluginRoot, "components", "start-work-continuation", "directive.md"), "utf8");
+
+	assert.match(text, /Global Review and Debugging Gate/);
+	assert.match(text, /review-work/);
+	assert.match(text, /debugging/);
+	assert.match(text, /Do not print `ORCHESTRATION COMPLETE`/);
+	assert.match(text, /Do not create a PR, PR handoff, or branch handoff/);
+	assert.match(text, /redact.*secrets.*PII/s);
+});
+
+test("#given Hephaestus baseline rule #when inspected #then significant implementation and PR handoff require the same gate", async () => {
+	const text = await readFile(join(pluginRoot, "components", "rules", "bundled-rules", "hephaestus.md"), "utf8");
+
+	assert.match(text, /Global Review and Debugging Gate/);
+	assert.match(text, /significant implementation work/);
+	assert.match(text, /review-work/);
+	assert.match(text, /debugging/);
+	assert.match(text, /PR handoff/);
+	assert.match(text, /redact.*secrets.*PII/s);
+});

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

@@ -11,6 +11,7 @@ import {
 } from "../scripts/hook-status-message.mjs";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const repoRoot = join(root, "..", "..", "..");
 
 const AGGREGATE_EXPECTED_LABELS = new Map([
 	["hooks/hooks.json:SessionStart:0:0", "Loading Project Rules"],
@@ -49,6 +50,18 @@ async function readJson(relativePath) {
 	return JSON.parse(await readFile(join(root, relativePath), "utf8"));
 }
 
+async function readRepoJson(relativePath) {
+	return JSON.parse(await readFile(join(repoRoot, relativePath), "utf8"));
+}
+
+async function readPluginVersion() {
+	return (await readJson(".codex-plugin/plugin.json")).version;
+}
+
+async function readComponentVersion(componentName) {
+	return (await readJson(join("components", componentName, "package.json"))).version;
+}
+
 async function exists(relativePath) {
 	try {
 		await access(join(root, relativePath));
@@ -66,8 +79,8 @@ async function readComponentHookManifests() {
 		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) });
+		const version = await readComponentVersion(entry.name);
+		manifests.push({ source, version, hooks: await readJson(source) });
 	}
 	return manifests.sort((left, right) => left.source.localeCompare(right.source));
 }
@@ -91,16 +104,16 @@ function collectCommandHooks(hooks, source, version) {
 	return commandHooks;
 }
 
-test("#given hook status label #when formatting #then prefixes LazyCodex with version", () => {
+test("#given hook status label #when formatting #then prefixes LazyCodex with current version", async () => {
 	// given
-	const version = "0.1.0";
+	const version = (await readRepoJson("package.json")).version;
 	const label = "Checking Comments";
 
 	// when
 	const message = formatLazyCodexHookStatusMessage(version, label);
 
 	// then
-	assert.equal(message, "LazyCodex(0.1.0): Checking Comments");
+	assert.equal(message, `LazyCodex(${version}): Checking Comments`);
 });
 
 test("#given hook status label with blank version #when formatting #then prefixes LazyCodex with local version", () => {
@@ -115,9 +128,9 @@ test("#given hook status label with blank version #when formatting #then prefixe
 	assert.equal(message, "LazyCodex(local): Checking Comments");
 });
 
-test("#given loose legacy status label #when normalizing #then removes OMO wording and title-cases label", () => {
+test("#given loose legacy status label #when normalizing #then removes OMO wording and title-cases label", async () => {
 	// given
-	const version = "0.1.0";
+	const version = (await readRepoJson("package.json")).version;
 	const label = "  checking   OMO comments  ";
 
 	// when
@@ -126,12 +139,12 @@ test("#given loose legacy status label #when normalizing #then removes OMO wordi
 
 	// then
 	assert.equal(normalized, "Checking Comments");
-	assert.equal(message, "LazyCodex(0.1.0): Checking Comments");
+	assert.equal(message, `LazyCodex(${version}): Checking Comments`);
 });
 
 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 aggregateVersion = await readPluginVersion();
 	const aggregateHooks = await readJson("hooks/hooks.json");
 
 	// when
@@ -145,7 +158,7 @@ test("#given aggregate comment-checker hook #when status is inspected #then it u
 
 test("#given aggregate and component hooks #when status messages are inspected #then all use the LazyCodex formatter", async () => {
 	// given
-	const aggregateVersion = (await readJson(".codex-plugin/plugin.json")).version;
+	const aggregateVersion = await readPluginVersion();
 	const aggregateHooks = await readJson("hooks/hooks.json");
 	const componentManifests = await readComponentHookManifests();
 

package/packages/omo-codex/plugin/test/lcx-bug-skills.test.mjs

@@ -0,0 +1,81 @@
+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 synced lcx-report-bug skill #when inspected #then it files LazyCodex bug issues with generated labels", 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, /openai\/codex/);
+	assert.match(skill, /\/tmp\/openai-codex-source/);
+	assert.match(skill, /\$omo:debugging/);
+	assert.match(skill, /Repository Decision/);
+	assert.match(skill, /TARGET_REPO="code-yeongyu\/lazycodex" # or openai\/codex/);
+	assert.match(skill, /LABEL_ARGS=\(\)/);
+	assert.match(skill, /gh label create lazycodex-generated.*--force/);
+	assert.match(skill, /gh issue create --repo "\$TARGET_REPO".*"\$\{LABEL_ARGS\[@\]\}"/);
+	assert.match(skill, /gh pr create --repo "\$TARGET_REPO".*"\$\{LABEL_ARGS\[@\]\}"/);
+	assert.match(skill, /lazycodex-generated/);
+	assert.match(skill, /This issue or PR was generated by LazyCodex/);
+	assert.match(skill, /Tag: lazycodex-generated/);
+	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"/);
+	assert.match(interfaceMetadata, /- "openai codex bug"/);
+});
+
+test("#given synced lcx-contribute-bug-fix skill #when inspected #then it contributes LazyCodex bug-fix PRs from fresh temp workspaces", async () => {
+	// given
+	const skillRoot = join(root, "skills", "lcx-contribute-bug-fix");
+
+	// when
+	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
+	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
+	const script = await readFile(join(skillRoot, "scripts", "create-pr-body.mjs"), "utf8");
+
+	// then
+	assert.match(skill, /^---\r?\nname: lcx-contribute-bug-fix\r?\n/m);
+	assert.match(skill, /Contribute a verified bug-fix PR/);
+	assert.match(skill, /fresh `\/tmp` clone\/worktree/);
+	assert.match(skill, /\/tmp\/lazycodex-fix-/);
+	assert.match(skill, /git worktree add/);
+	assert.match(skill, /apply `lazycodex-generated` when label management is available/);
+	assert.match(skill, /git add -A/);
+	assert.match(skill, /git commit -m/);
+	assert.match(skill, /git log --oneline "origin\/\$BASE_BRANCH\.\.HEAD"/);
+	assert.match(skill, /gh repo fork "\$TARGET_REPO" --remote --remote-name fork/);
+	assert.match(skill, /PUSH_REMOTE/);
+	assert.match(skill, /lazycodex-generated/);
+	assert.match(skill, /LABEL_ARGS=\(\)/);
+	assert.match(skill, /gh label create lazycodex-generated.*--force/);
+	assert.match(skill, /gh pr create --repo "\$TARGET_REPO".*"\$\{LABEL_ARGS\[@\]\}"/);
+	assert.match(skill, /--head "\$PR_HEAD"/);
+	assert.doesNotMatch(skill, /a PR without the `lazycodex-generated` label/);
+	assert.match(skill, /scripts\/create-pr-body\.mjs/);
+	assert.match(skill, /## Problem Situation/);
+	assert.match(skill, /## Reproduction Logs/);
+	assert.match(skill, /## Approach/);
+	assert.match(skill, /## Why I Am Confident/);
+	assert.match(skill, /## Risks/);
+	assert.match(skill, /## User-Visible Behavior Changes/);
+	assert.match(skill, /Clean up/);
+	assert.match(interfaceMetadata, /display_name: "lcx-contribute-bug-fix \(omo\)"/);
+	assert.match(interfaceMetadata, /- "contribute a bug fix"/);
+	assert.match(interfaceMetadata, /- "fix bug pr"/);
+	assert.match(script, /createLazyCodexBugFixPrBody/);
+	assert.match(script, /Problem Situation/);
+	assert.match(script, /Why I Am Confident/);
+});

package/packages/omo-codex/plugin/test/lcx-contribute-bug-fix-template.test.mjs

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+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 scriptPath = join(root, "skills", "lcx-contribute-bug-fix", "scripts", "create-pr-body.mjs");
+
+test("#given complete bug-fix evidence #when creating a PR body #then required LazyCodex sections and label are emitted", async () => {
+	// given
+	const { createLazyCodexBugFixPrBody } = await import(`file://${scriptPath}`);
+	const input = {
+		title: "Fix Codex skill sync drift",
+		targetRepository: "code-yeongyu/lazycodex",
+		problem: "Skill sync omitted a shared skill from the aggregate plugin.",
+		reproductionLogs: "npm test -- --test-name-pattern sync-skills failed before the fix.",
+		approach: "Add the missing shared skill source and sync the aggregate plugin.",
+		confidence: "The failing sync test now passes and the aggregate skill matches the source.",
+		risks: "Low risk; this changes only packaged skill instructions.",
+		userVisibleBehaviorChanges: "Users can ask LazyCodex to contribute a bug-fix PR directly.",
+		verification: ["npm test -- --test-name-pattern lcx-contribute-bug-fix", "npm run sync:skills"],
+	};
+
+	// when
+	const body = createLazyCodexBugFixPrBody(input);
+
+	// then
+	assert.match(body, /^## Problem Situation/m);
+	assert.match(body, /## Reproduction Logs/);
+	assert.match(body, /## Approach/);
+	assert.match(body, /## Why I Am Confident/);
+	assert.match(body, /## Risks/);
+	assert.match(body, /## User-Visible Behavior Changes/);
+	assert.match(body, /## Verification/);
+	assert.match(body, /lazycodex-generated/);
+	assert.match(body, /This PR was debugged, implemented, and created with \[LazyCodex\]/);
+});
+
+test("#given missing bug-fix evidence #when creating a PR body #then the script rejects the incomplete payload", async () => {
+	// given
+	const { createLazyCodexBugFixPrBody } = await import(`file://${scriptPath}`);
+
+	// when
+	const action = () =>
+		createLazyCodexBugFixPrBody({
+			title: "Fix Codex skill sync drift",
+			targetRepository: "code-yeongyu/lazycodex",
+			problem: "Skill sync omitted a shared skill from the aggregate plugin.",
+			reproductionLogs: "",
+			approach: "Add the missing shared skill source and sync the aggregate plugin.",
+			confidence: "The failing sync test now passes.",
+			risks: "Low risk.",
+			userVisibleBehaviorChanges: "Users get a new skill.",
+			verification: ["npm test"],
+		});
+
+	// then
+	assert.throws(action, /reproductionLogs must be a non-empty string/);
+});
+
+test("#given a JSON payload path #when running the PR body script #then markdown is written to the requested file", async () => {
+	// given
+	const workspace = await mkdtemp(join(tmpdir(), "lcx-pr-body-test-"));
+	const inputPath = join(workspace, "input.json");
+	const outputPath = join(workspace, "body.md");
+	await writeFile(
+		inputPath,
+		JSON.stringify({
+			title: "Fix Codex skill sync drift",
+			targetRepository: "code-yeongyu/lazycodex",
+			problem: "Skill sync omitted a shared skill from the aggregate plugin.",
+			reproductionLogs: "node --test failed before the fix.",
+			approach: "Add the missing shared skill source and sync the aggregate plugin.",
+			confidence: "The failing sync test now passes.",
+			risks: "Low risk.",
+			userVisibleBehaviorChanges: "Users get a direct bug-fix PR skill.",
+			verification: ["node --test test/lcx-contribute-bug-fix-template.test.mjs"],
+		}),
+		"utf8",
+	);
+
+	// when
+	const { spawnSync } = await import("node:child_process");
+	const result = spawnSync(process.execPath, [scriptPath, inputPath, outputPath], { encoding: "utf8" });
+
+	// then
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(await readFile(outputPath, "utf8"), /## User-Visible Behavior Changes/);
+});