oh-my-opencode 4.7.5 → 4.8.1

package/packages/omo-codex/plugin/test/migrate-codex-config.test.mjs

@@ -4,12 +4,13 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
 
+import { disableMultiAgentV2IfForced } from "../scripts/migrate-codex-config/multi-agent-v2-guard.mjs";
 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 = "gpt-5.5"',
 			"model_context_window = 272000",
 			'model_reasoning_effort = "low"',
 			'plan_mode_reasoning_effort = "medium"',
@@ -32,6 +33,29 @@ test("#given stale root reasoning config #when ensuring config #then replaces st
 	assert.match(result, /\[features\]/);
 });
 
+test("#given section settings reuse managed root keys #when ensuring config #then section settings are preserved", () => {
+	const result = ensureCodexReasoningConfig(
+		[
+			'model = "gpt-5.5"',
+			"model_context_window = 272000",
+			"",
+			"[model_providers.openai]",
+			'model = "provider-scoped-value"',
+			"model_context_window = 123456",
+			"",
+			"[profiles.review]",
+			'model_reasoning_effort = "medium"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+		].join("\n"),
+	);
+
+	assert.match(result, /^model = "gpt-5\.5"$/m);
+	assert.match(result, /^model_context_window = 400000$/m);
+	assert.match(result, /\[model_providers\.openai\]\nmodel = "provider-scoped-value"\nmodel_context_window = 123456/);
+	assert.match(result, /\[profiles\.review\]\nmodel_reasoning_effort = "medium"\nplan_mode_reasoning_effort = "medium"/);
+});
+
 test("#given project .codex is a symlink #when migrating #then project config is skipped", async (t) => {
 	if (!(await canCreateSymlink("dir"))) t.skip("symbolic links are unavailable in this environment");
 
@@ -47,8 +71,8 @@ test("#given project .codex is a symlink #when migrating #then project config is
 	await mkdir(projectCodexDirectory, { recursive: true });
 	await mkdir(dirname(projectConfigTarget), { recursive: true });
 	await mkdir(projectNested, { recursive: true });
-	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.2"\n');
-	await writeFile(projectConfigTarget, 'model = "gpt-5.2"\nmodel_context_window = 272000\n');
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.5"\nmodel_context_window = 272000\n');
+	await writeFile(projectConfigTarget, 'model = "gpt-5.4"\nmodel_context_window = 272000\n');
 	await rm(join(project, ".codex"), { recursive: true, force: true });
 	await symlink(projectCodexDirectory, join(project, ".codex"), "dir");
 
@@ -61,7 +85,7 @@ test("#given project .codex is a symlink #when migrating #then project config is
 	});
 
 	assert.deepEqual(result.changed, [join(codexHome, "config.toml")]);
-	assert.match(await readFile(projectConfig, "utf8"), /model = "gpt-5\.2"/);
+	assert.match(await readFile(projectConfig, "utf8"), /model = "gpt-5\.4"/);
 });
 
 test("#given project config.toml is a symlink #when migrating #then project config is skipped", async (t) => {
@@ -76,8 +100,8 @@ test("#given project config.toml is a symlink #when migrating #then project conf
 
 	await mkdir(codexHome, { recursive: true });
 	await mkdir(projectConfigDirectory, { recursive: true });
-	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.2"\n');
-	await writeFile(realConfigSource, 'model = "gpt-5.2"\nmodel_context_window = 272000\n');
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.5"\nmodel_context_window = 272000\n');
+	await writeFile(realConfigSource, 'model = "gpt-5.4"\nmodel_context_window = 272000\n');
 	await symlink(realConfigSource, projectConfig, "file");
 
 	const result = await migrateCodexConfig({
@@ -89,7 +113,7 @@ test("#given project config.toml is a symlink #when migrating #then project conf
 	});
 
 	assert.deepEqual(result.changed, [join(codexHome, "config.toml")]);
-	assert.match(await readFile(realConfigSource, "utf8"), /model = "gpt-5\.2"/);
+	assert.match(await readFile(realConfigSource, "utf8"), /model = "gpt-5\.4"/);
 });
 
 test("#given global and project-local stale Codex configs #when migrating #then both configs are forced to current defaults", async () => {
@@ -99,8 +123,8 @@ test("#given global and project-local stale Codex configs #when migrating #then
 	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');
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.5"\nmodel_context_window = 272000\n');
+	await writeFile(projectConfig, 'model = "gpt-5.5"\nmodel_context_window = 272000\n');
 
 	const result = await migrateCodexConfig({
 		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
@@ -112,6 +136,51 @@ test("#given global and project-local stale Codex configs #when migrating #then
 	assert.match(await readFile(projectConfig, "utf8"), /model_context_window = 400000/);
 });
 
+test("#given model catalog is unavailable and stale 272k config #when migrating #then fallback catalog still upgrades it", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-fallback-catalog-"));
+	const codexHome = join(root, "codex-home");
+	const missingCatalog = join(root, "missing-model-catalog.json");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.5"\nmodel_context_window = 272000\n');
+
+	const result = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: missingCatalog,
+			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, [join(codexHome, "config.toml")]);
+	assert.match(content, /model = "gpt-5\.5"/);
+	assert.match(content, /model_context_window = 400000/);
+});
+
+test("#given model catalog is malformed and stale config #when migrating #then fallback catalog still upgrades it", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-malformed-catalog-"));
+	const codexHome = join(root, "codex-home");
+	const catalogPath = join(root, "model-catalog.json");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(catalogPath, "{not-json");
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.5"\nmodel_context_window = 272000\n');
+
+	const result = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: catalogPath,
+			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, [join(codexHome, "config.toml")]);
+	assert.match(content, /model = "gpt-5\.5"/);
+	assert.match(content, /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");
@@ -140,6 +209,43 @@ test("#given user-customized Codex model config #when migrating #then user value
 	assert.match(content, /plan_mode_reasoning_effort = "medium"/);
 });
 
+test("#given managed config state is malformed #when migrating #then migration ignores stale state safely", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-malformed-state-"));
+	const codexHome = join(root, "codex-home");
+	const statePath = join(root, "model-state.json");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(statePath, "[broken-json");
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.5"\nmodel_context_window = 272000\n');
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: statePath },
+		cwd: root,
+	});
+
+	const content = await readFile(join(codexHome, "config.toml"), "utf8");
+	const state = JSON.parse(await readFile(statePath, "utf8"));
+	assert.deepEqual(result.changed, [join(codexHome, "config.toml")]);
+	assert.match(content, /model_context_window = 400000/);
+	assert.equal(state.files[join(codexHome, "config.toml")].managed, true);
+});
+
+test("#given managed config state path has surrounding whitespace #when migrating #then trimmed state path is used", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-trimmed-state-"));
+	const codexHome = join(root, "codex-home");
+	const statePath = join(root, "model-state.json");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.5"\nmodel_context_window = 272000\n');
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: `  ${statePath}  ` },
+		cwd: root,
+	});
+
+	const state = JSON.parse(await readFile(statePath, "utf8"));
+	assert.deepEqual(result.changed, [join(codexHome, "config.toml")]);
+	assert.equal(state.files[join(codexHome, "config.toml")].managed, true);
+});
+
 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");
@@ -205,6 +311,135 @@ test("#given managed catalog state #when catalog version advances #then only pre
 	assert.match(content, /model_context_window = 400000/);
 });
 
+test("#given config already matches current catalog #when catalog version advances for role-only changes #then managed state is preserved", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-current-managed-"));
+	const codexHome = join(root, "codex-home");
+	const catalogPath = join(root, "catalog.json");
+	const statePath = join(root, "model-state.json");
+	const configPath = join(codexHome, "config.toml");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.5"',
+			"model_context_window = 400000",
+			'model_reasoning_effort = "high"',
+			'plan_mode_reasoning_effort = "xhigh"',
+			"",
+		].join("\n"),
+	);
+	await writeFile(
+		catalogPath,
+		JSON.stringify(
+			{
+				version: "test.role-only",
+				current: {
+					model: "gpt-5.5",
+					model_context_window: 400000,
+					model_reasoning_effort: "high",
+					plan_mode_reasoning_effort: "xhigh",
+				},
+				roles: { verifier: { model: "gpt-5.5", model_reasoning_effort: "high" } },
+				managedProfiles: [],
+			},
+			null,
+			2,
+		),
+	);
+
+	const result = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: catalogPath,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: statePath,
+		},
+		cwd: root,
+	});
+
+	const state = JSON.parse(await readFile(statePath, "utf8"));
+	assert.deepEqual(result.changed, []);
+	assert.equal(state.files[configPath].managed, true);
+	assert.equal(state.files[configPath].catalogVersion, "test.role-only");
+});
+
+test("#given installer-forced multi_agent_v2 enabled #when migrating config #then disables it so runtime decides per model", () => {
+	const config = [
+		'model = "gpt-5.5"',
+		'model_reasoning_effort = "high"',
+		"",
+		"[features.multi_agent_v2]",
+		"enabled = true",
+		"max_concurrent_threads_per_session = 10000",
+		"",
+	].join("\n");
+
+	const result = disableMultiAgentV2IfForced(config);
+
+	assert.match(result, /enabled = false/);
+	assert.doesNotMatch(result, /enabled = true/);
+	assert.match(result, /max_concurrent_threads_per_session = 10000/);
+});
+
+test("#given no multi_agent_v2 section #when migrating config #then returns config unchanged", () => {
+	const config = [
+		'model = "gpt-5.5"',
+		'model_reasoning_effort = "high"',
+		"",
+		"[features]",
+		"plugins = true",
+		"",
+	].join("\n");
+
+	const result = disableMultiAgentV2IfForced(config);
+
+	assert.equal(result, config);
+});
+
+test("#given multi_agent_v2 already disabled #when migrating config #then returns config unchanged", () => {
+	const config = [
+		'model = "gpt-5.5"',
+		'model_reasoning_effort = "high"',
+		"",
+		"[features.multi_agent_v2]",
+		"enabled = false",
+		"max_concurrent_threads_per_session = 10000",
+		"",
+	].join("\n");
+
+	const result = disableMultiAgentV2IfForced(config);
+
+	assert.equal(result, config);
+});
+
+test("#given global config with forced multi_agent_v2 #when full migration runs #then disables it on disk", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-multi-agent-v2-guard-"));
+	const codexHome = join(root, "codex-home");
+	await mkdir(codexHome, { recursive: true });
+	const configPath = join(codexHome, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.5"',
+			'model_reasoning_effort = "high"',
+			"",
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"max_concurrent_threads_per_session = 10000",
+			"",
+		].join("\n"),
+	);
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: root,
+	});
+
+	assert.deepEqual(result.changed, [configPath]);
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /enabled = false/);
+	assert.doesNotMatch(content, /enabled = true/);
+});
+
 async function canCreateSymlink(type) {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-symlink-capability-"));
 	const target = join(root, "target");

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

@@ -27,22 +27,3 @@ test("#given Codex Light install docs #when inspected #then lazycodex is npm-fir
 		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/start-work-skill.test.mjs

@@ -0,0 +1,107 @@
+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 = dirname(dirname(dirname(pluginRoot)));
+const startWorkSkillPaths = [
+	join(repoRoot, "packages", "shared-skills", "skills", "start-work", "SKILL.md"),
+];
+const packagedStartWorkSkillPath = join(pluginRoot, "skills", "start-work", "SKILL.md");
+const packagedReviewWorkSkillPath = join(pluginRoot, "skills", "review-work", "SKILL.md");
+const hephaestusRulePath = join(pluginRoot, "components", "rules", "bundled-rules", "hephaestus.md");
+const stopHookPath = join(
+	pluginRoot,
+	"components",
+	"start-work-continuation",
+	"src",
+	"codex-hook.ts",
+);
+
+test("#given start-work skill without selectable plan #when inspected #then bootstraps ulw-plan before execution", async () => {
+	// given
+	const missing = [];
+
+	// when
+	for (const skillPath of startWorkSkillPaths) {
+		const skill = await readFile(skillPath, "utf8");
+		if (
+			!/(?:no|zero)[^.]{0,120}(?:selectable|matching|existing|prometheus)?[^.]{0,120}plans?[^.]{0,160}(?:\$?ulw-plan|ulw-plan skill|spawn_agent\([^)]*ulw-plan)/is.test(
+				skill,
+			) ||
+			!/(?:bootstrap|create|generate|draft)[^.]{0,120}(?:plan|prometheus plan)[^.]{0,120}(?:before|prior to)[^.]{0,80}(?:execution|implementation|boulder)/is.test(
+				skill,
+			)
+		) {
+			missing.push(skillPath);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, []);
+});
+
+test("#given worker done claim #when start-work contract is inspected #then adversarial verification gates fully done", async () => {
+	// given
+	const missing = [];
+
+	// when
+	for (const skillPath of startWorkSkillPaths) {
+		const skill = await readFile(skillPath, "utf8");
+		if (
+			!/DoneClaim/i.test(skill) ||
+			!/worker done claim/i.test(skill) ||
+			!/stale_state/.test(skill) ||
+			!/misleading_success_output/.test(skill) ||
+			!/dirty_worktree/.test(skill) ||
+			!/Plan reread/i.test(skill) ||
+			!/Manual-QA/i.test(skill) ||
+			!/Adversarial QA/i.test(skill) ||
+			!/Cleanup/i.test(skill) ||
+			!/Only after verification passes/i.test(skill)
+		) {
+			missing.push(skillPath);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, []);
+});
+
+test("#given packaged start-work completion surfaces #when inspected #then global review and debugging gate blocks completion", async () => {
+	// given
+	const [startWorkSkill, reviewWorkSkill, hephaestusRule] = await Promise.all([
+		readFile(packagedStartWorkSkillPath, "utf8"),
+		readFile(packagedReviewWorkSkillPath, "utf8"),
+		readFile(hephaestusRulePath, "utf8"),
+	]);
+
+	// then
+	assert.match(startWorkSkill, /Global Review and Debugging Gate/);
+	assert.match(startWorkSkill, /\breview-work\b/);
+	assert.match(startWorkSkill, /\bdebugging\b/);
+	assert.match(startWorkSkill, /inconclusive/i);
+	assert.match(startWorkSkill, /redact|mask/i);
+	assert.match(startWorkSkill, /raw (?:tokens|credentials|auth headers|cookies)/i);
+	assert.match(startWorkSkill, /ORCHESTRATION COMPLETE/);
+	assert.match(reviewWorkSkill, /debugging/i);
+	assert.match(reviewWorkSkill, /inconclusive/i);
+	assert.match(hephaestusRule, /Global Review and Debugging Gate/);
+	assert.match(hephaestusRule, /redact.*secrets.*PII/s);
+});
+
+test("#given start-work continuation hook #when inspected #then it remains Boulder-only without planning bootstrap logic", async () => {
+	// given
+	const hook = await readFile(stopHookPath, "utf8");
+
+	// then
+	assert.match(hook, /readContinuationState/);
+	assert.match(hook, /START_WORK_CONTINUATION_DIRECTIVE/);
+	assert.match(hook, /decision:\s*"block"/);
+	assert.doesNotMatch(
+		hook,
+		/\bulw-plan\b|\bspawn_agent\b|\brequest_user_input\b|bootstrap|selectable plan|Phase 1|Create or update Boulder state/i,
+	);
+});

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

@@ -10,6 +10,7 @@ const SKILLS = [
 	"review-work",
 	"start-work",
 	"ulw-loop",
+	"ulw-plan",
 ];
 
 const AGENT_FILES = [
@@ -28,13 +29,16 @@ test("#given orchestration skills #when inspected #then Codex subagent delegatio
 		if (
 			!/TASK:/.test(text) ||
 			!/fork_turns:\s*"none"/.test(text) ||
-			!/wait_agent.*signal, not proof/s.test(text) ||
-			!/one targeted followup/.test(text) ||
+			!/wait_agent.*mailbox signals/s.test(text) ||
+			!/Fallback only when/.test(text) ||
 			!/respawn.*smaller/s.test(text) ||
-			!/model.*reasoning_effort.*default agent/s.test(text) ||
+			!/schema only accepts `task_name`, `message`, and `fork_turns`/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)
+			!/single long blocking wait/.test(text) ||
+			!/A timeout only means no new mailbox update arrived/i.test(text) ||
+			!/WORKING:/.test(text) ||
+			!/single `list_agents`/.test(text)
 		) {
 			missing.push(skillPath);
 		}
@@ -53,9 +57,67 @@ test("#given ultrawork directive #when inspected #then reviewer fallback keeps a
 
 	// 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);
+	assert.match(text, /self-contained reviewer/);
+	assert.match(text, /schema cannot select.*TOML-backed reviewer role/s);
+	assert.match(text, /paste the reviewer requirements into\s+the message/s);
+	assert.match(text, /timeout only means no new mailbox update arrived/i);
+	assert.match(text, /WORKING:/);
+	assert.match(text, /single `list_agents`/);
+});
+
+test("#given ultrawork directive #when inspected #then dependent subagent transitions are blocked", async () => {
+	// given
+	const directivePath = "components/ultrawork/directive.md";
+
+	// when
+	const text = await readFile(join(root, directivePath), "utf8");
+
+	// then
+	assert.match(text, /Subagent-dependent transition barrier/);
+	assert.match(text, /Do not mark.*update_plan.*completed.*active child/s);
+	assert.match(text, /Do not start dependent implementation.*audit.*research.*review.*integrated/s);
+	assert.match(text, /Do not write the final answer.*active child agents/s);
+	assert.match(text, /two silent waits.*TASK STILL ACTIVE/s);
+	assert.match(text, /four silent or ack-only checks.*inconclusive/s);
+});
+
+test("#given ultrawork directive #when inspected #then TOML-backed routing is treated as unverified when native spawn cannot select it", async () => {
+	// given
+	const directivePath = "components/ultrawork/directive.md";
+
+	// when
+	const text = await readFile(join(root, directivePath), "utf8");
+
+	// then
+	assert.match(text, /TOML-backed subagent routing compatibility/);
+	assert.match(text, /routing-unverified/);
+	assert.match(text, /schema accepts only `task_name`, `message`, and\s+`fork_turns`/s);
+	assert.match(text, /cannot select a TOML-backed role, model, reasoning\s+effort, or `service_tier`/s);
+	assert.match(text, /paste the\s+role requirements into the message/s);
+});
+
+test("#given ulw-loop workflow #when inspected #then stale review refresh keeps policy changes narrow", async () => {
+	// given
+	const workflowPaths = [
+		"components/ulw-loop/skills/ulw-loop/references/full-workflow.md",
+		"skills/ulw-loop/references/full-workflow.md",
+	];
+
+	// when
+	const missing = [];
+	for (const workflowPath of workflowPaths) {
+		const text = await readFile(join(root, workflowPath), "utf8");
+		if (
+			!/refresh current branch\/PR\/issue state/.test(text) ||
+			!/preserve existing ordering\/policy/.test(text) ||
+			!/separate compatibility detection from policy changes/.test(text)
+		) {
+			missing.push(workflowPath);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, []);
 });
 
 test("#given ultrawork agents #when inspected #then inter-agent commentary is treated as assignments", async () => {
@@ -74,3 +136,16 @@ test("#given ultrawork agents #when inspected #then inter-agent commentary is tr
 	// then
 	assert.deepEqual(missing, []);
 });
+
+test("#given reviewer receives a targeted still-active followup #when prompt is inspected #then it must fail loud", async () => {
+	// given
+	const reviewerPath = "components/ultrawork/agents/codex-ultrawork-reviewer.toml";
+
+	// when
+	const text = await readFile(join(root, reviewerPath), "utf8");
+
+	// then
+	assert.match(text, /TASK STILL ACTIVE:/);
+	assert.match(text, /BLOCKED: <reason>/);
+	assert.match(text, /instead of continuing silently/);
+});

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

@@ -14,15 +14,18 @@ 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 () => {
+test("#given source package versions and component without hooks #when hook status messages sync #then source versions are preserved", async () => {
 	// given
-	const root = await mkdtemp(join(tmpdir(), "omo-codex-hook-status-"));
+	const repoRoot = await mkdtemp(join(tmpdir(), "omo-codex-hook-status-"));
+	const root = join(repoRoot, "packages", "omo-codex", "plugin");
+	await mkdir(root, { recursive: true });
 	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", "lsp", "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(repoRoot, "package.json"), { version: "4.7.5" });
 	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", "lsp", "package.json"), { version: "0.2.0" });
@@ -35,12 +38,12 @@ test("#given a component without hooks #when hook status messages sync #then bui
 						{
 							type: "command",
 							command: 'node "${PLUGIN_ROOT}/components/comment-checker/dist/cli.js" hook post-tool-use',
-							statusMessage: "LazyCodex(0.1.0): Checking Comments",
+							statusMessage: "LazyCodex(stale): Checking Comments",
 						},
 						{
 							type: "command",
 							command: 'node "${PLUGIN_ROOT}/components/lsp/dist/cli.js" hook post-tool-use',
-							statusMessage: "LazyCodex(0.1.0): Checking LSP Diagnostics",
+							statusMessage: "LazyCodex(stale): Checking LSP Diagnostics",
 						},
 					],
 				},
@@ -55,7 +58,7 @@ test("#given a component without hooks #when hook status messages sync #then bui
 						{
 							type: "command",
 							command: 'node "${PLUGIN_ROOT}/dist/cli.js" hook post-tool-use',
-							statusMessage: "LazyCodex(0.1.0): Checking Comments",
+							statusMessage: "LazyCodex(stale): Checking Comments",
 						},
 					],
 				},
@@ -70,7 +73,7 @@ test("#given a component without hooks #when hook status messages sync #then bui
 						{
 							type: "command",
 							command: 'node "${PLUGIN_ROOT}/dist/cli.js" hook post-tool-use',
-							statusMessage: "LazyCodex(0.1.0): Checking LSP Diagnostics",
+							statusMessage: "LazyCodex(stale): Checking LSP Diagnostics",
 						},
 					],
 				},
@@ -90,3 +93,52 @@ test("#given a component without hooks #when hook status messages sync #then bui
 	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.1): Checking Comments");
 	assert.equal(lspHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.2.0): Checking LSP Diagnostics");
 });
+
+test("#given release version override #when hook status messages sync #then aggregate hooks use release version", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-hook-status-release-"));
+	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 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, "hooks", "hooks.json"), {
+		hooks: {
+			PostToolUse: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/components/comment-checker/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(stale): 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(stale): Checking Comments",
+						},
+					],
+				},
+			],
+		},
+	});
+
+	// when
+	await syncHookStatusMessages(root, { releaseVersion: "4.8.0" });
+
+	// 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(4.8.0): Checking Comments");
+	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(4.8.0): Checking Comments");
+});