oh-my-opencode 4.18.1 → 4.19.0

package/packages/omo-codex/plugin/test/scaffold-plan.test.mjs

@@ -107,11 +107,73 @@ test("#given parseArgs #when the slug is missing or unsafe #then it throws, and
 	assert.equal(ok.intent, "unclear");
 	assert.equal(ok.reset, true);
 	assert.equal(ok.force, true);
+	assert.equal(ok.draftOnly, false);
+	assert.equal(ok.reviewRequired, false);
+	const draftOnly = parseArgs(["node", "s", "my-plan", "--draft-only"]);
+	assert.equal(draftOnly.draftOnly, true);
+	const reviewRequired = parseArgs(["node", "s", "my-plan", "--draft-only", "--review-required"]);
+	assert.equal(reviewRequired.reviewRequired, true);
 	const plain = parseArgs(["node", "s", "my-plan"]);
 	assert.equal(plain.reset, false);
 	assert.equal(plain.force, false);
 });
 
+test("#given an explicit review modifier at startup #when draft-only scaffold runs #then the first durable write contains the complete pending review request", async () => {
+	const { scaffold } = await import(scriptUrl);
+	const dir = await mkdtemp(join(tmpdir(), "ulwp-"));
+	try {
+		await scaffold(dir, { slug: "demo", intent: "clear", draftOnly: true, reviewRequired: true });
+		const draft = await readFile(join(dir, ".omo", "drafts", "demo.md"), "utf8");
+		assert.match(draft, /review_required: true/);
+		assert.match(draft, /plan_path: \.omo\/plans\/demo\.md/);
+		assert.match(draft, /pending-action: write and review \.omo\/plans\/demo\.md/);
+		assert.match(draft, /momus:\n\s+status: pending/);
+		assert.match(draft, /independent:\n\s+status: pending/);
+		await assert.rejects(() => readFile(join(dir, ".omo", "plans", "demo.md"), "utf8"), /ENOENT/);
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+	}
+});
+
+test("#given automatic review for non-Trivial UNCLEAR intent #when draft-only scaffold runs #then the first durable write contains the complete pending review request", async () => {
+	const { scaffold } = await import(scriptUrl);
+	const dir = await mkdtemp(join(tmpdir(), "ulwp-"));
+	try {
+		await scaffold(dir, { slug: "demo", intent: "unclear", draftOnly: true, reviewRequired: true });
+		const draft = await readFile(join(dir, ".omo", "drafts", "demo.md"), "utf8");
+		assert.match(draft, /intent: unclear/);
+		assert.match(draft, /review_required: true/);
+		assert.match(draft, /plan_path: \.omo\/plans\/demo\.md/);
+		assert.match(draft, /plan_sha256: null/);
+		assert.match(draft, /review_round_id: null/);
+		assert.match(draft, /pending-action: write and review \.omo\/plans\/demo\.md/);
+		assert.match(draft, /momus:\n\s+status: pending[\s\S]*?target: \.omo\/plans\/demo\.md[\s\S]*?result: null/);
+		assert.match(draft, /independent:\n\s+status: pending[\s\S]*?target: \.omo\/plans\/demo\.md[\s\S]*?result: null/);
+		await assert.rejects(() => readFile(join(dir, ".omo", "plans", "demo.md"), "utf8"), /ENOENT/);
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+	}
+});
+
+test("#given Trivial UNCLEAR pre-approval planning #when draft-only scaffold runs #then it creates a review-optional draft without creating a plan", async () => {
+	const { scaffold } = await import(scriptUrl);
+	const dir = await mkdtemp(join(tmpdir(), "ulwp-"));
+	try {
+		const first = await scaffold(dir, { slug: "demo", intent: "unclear", draftOnly: true });
+		assert.equal(first.length, 1);
+		assert.equal(first[0].status, "created");
+		assert.match(await readFile(join(dir, ".omo", "drafts", "demo.md"), "utf8"), /intent: unclear/);
+		assert.match(await readFile(join(dir, ".omo", "drafts", "demo.md"), "utf8"), /review_required: false/);
+		await assert.rejects(() => readFile(join(dir, ".omo", "plans", "demo.md"), "utf8"), /ENOENT/);
+
+		const afterApproval = await scaffold(dir, { slug: "demo", intent: "unclear" });
+		assert.equal(afterApproval[0].status, "exists");
+		assert.equal(afterApproval[1].status, "created");
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+	}
+});
+
 test("#given an already-scaffolded plan #when the script is re-run plain #then it is a no-op that preserves appended todos (resume-safe, no crash, no clobber)", async () => {
 	// given
 	const { scaffold } = await import(scriptUrl);

package/packages/omo-codex/plugin/test/subagent-limit-migration.test.mjs

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
 import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -6,7 +7,26 @@ import test from "node:test";
 
 import { migrateConfigFile } from "../scripts/migrate-codex-config.mjs";
 
-test("#given SessionStart config migration sees a low subagent cap #when migrating #then raises it to 1000", async () => {
+function parseTomlWithPython(config) {
+	const python = resolvePython();
+	const result = spawnSync(
+		python,
+		["-c", "import json, sys, tomllib; print(json.dumps(tomllib.loads(sys.stdin.read())))"],
+		{ encoding: "utf8", input: config },
+	);
+	assert.equal(result.status, 0, result.stderr);
+	return JSON.parse(result.stdout);
+}
+
+function resolvePython() {
+	for (const command of ["python3", "python"]) {
+		const result = spawnSync(command, ["-c", "import tomllib"], { encoding: "utf8" });
+		if (result.status === 0) return command;
+	}
+	assert.fail("Python with tomllib is required for TOML parse assertions");
+}
+
+test("#given SessionStart migration sees an inline-commented V2 cap #when migrating twice #then preserves the line and ordering byte-for-byte", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-migration-"));
 	const configPath = join(root, "config.toml");
 	await writeFile(
@@ -26,24 +46,240 @@ test("#given SessionStart config migration sees a low subagent cap #when migrati
 			"",
 			"[features.multi_agent_v2]",
 			"enabled = false",
-			"max_concurrent_threads_per_session = 6",
+			"usage_hint_enabled = false",
+			"max_concurrent_threads_per_session = 7 # user cap",
+			"show_tool_use = false",
 			"",
 		].join("\n"),
 	);
 
-	const result = await migrateConfigFile(configPath);
+	const firstResult = await migrateConfigFile(configPath);
+	const firstPass = await readFile(configPath, "utf8");
+	const secondResult = await migrateConfigFile(configPath);
+
+	const secondPass = await readFile(configPath, "utf8");
+	assert.equal(firstResult.changed, true);
+	assert.equal(secondResult.changed, false);
+	assert.equal(secondPass, firstPass);
+	assert.match(
+		secondPass,
+		/usage_hint_enabled = false\nmax_concurrent_threads_per_session = 7 # user cap\nshow_tool_use = false/,
+	);
+	assert.match(secondPass, /\[agents\][\s\S]*?max_threads = 1000/);
+	assert.match(secondPass, /max_depth = 4/);
+	assert.match(secondPass, /\[agents\.explorer\]\nconfig_file = "\.\/agents\/explorer\.toml"/);
+	assert.match(secondPass, /\[features\.multi_agent_v2\][\s\S]*?enabled = false/);
+	assert.doesNotMatch(secondPass, /^max_threads\s*=\s*6$/m);
+});
+
+for (const header of [
+	'["features"."multi_agent_v2"]',
+	"[ features . multi_agent_v2 ]",
+	'["features"."multi_agent_v\\u0032"]',
+]) {
+	test(`#given SessionStart migration sees equivalent V2 header ${header} #when migrating twice #then preserves one valid table and the explicit cap`, async () => {
+		const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-equivalent-header-"));
+		const configPath = join(root, "config.toml");
+		await writeFile(
+			configPath,
+			[
+				'model = "gpt-5.4"',
+				"",
+				header,
+				"usage_hint_enabled = false",
+				"max_concurrent_threads_per_session = 7 # user cap",
+				"show_tool_use = false",
+				"",
+			].join("\n"),
+		);
+
+		await migrateConfigFile(configPath);
+		const firstPass = await readFile(configPath, "utf8");
+		const parsed = parseTomlWithPython(firstPass);
+		const secondResult = await migrateConfigFile(configPath);
+		const secondPass = await readFile(configPath, "utf8");
+
+		assert.equal(parsed.features.multi_agent_v2.max_concurrent_threads_per_session, 7);
+		assert.equal(secondResult.changed, false);
+		assert.equal(secondPass, firstPass);
+		assert.equal((secondPass.match(/max_concurrent_threads_per_session\s*=/g) ?? []).length, 1);
+		assert.match(
+			secondPass,
+			/usage_hint_enabled = false\nmax_concurrent_threads_per_session = 7 # user cap\nshow_tool_use = false/,
+		);
+		assert.match(secondPass, new RegExp(header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+	});
+}
+
+for (const fixture of [
+	{
+		name: "quoted cap key",
+		lines: [
+			"[features.multi_agent_v2]",
+			'"max_concurrent_threads_per_session" = 7 # user cap',
+		],
+		preservedLine: '"max_concurrent_threads_per_session" = 7 # user cap',
+	},
+	{
+		name: "escaped quoted cap key",
+		lines: [
+			"[features.multi_agent_v2]",
+			'"max_concurrent_threads_per_sessio\\u006e" = 7 # user cap',
+		],
+		preservedLine: '"max_concurrent_threads_per_sessio\\u006e" = 7 # user cap',
+	},
+	{
+		name: "dotted cap key",
+		lines: [
+			"[features]",
+			"multi_agent_v2.max_concurrent_threads_per_session = 7 # user cap",
+		],
+		preservedLine: "multi_agent_v2.max_concurrent_threads_per_session = 7 # user cap",
+	},
+	{
+		name: "root-qualified dotted cap key",
+		lines: ["features.multi_agent_v2.max_concurrent_threads_per_session = 7 # user cap"],
+		preservedLine: "features.multi_agent_v2.max_concurrent_threads_per_session = 7 # user cap",
+	},
+]) {
+	test(`#given SessionStart migration sees a ${fixture.name} #when migrating twice #then preserves the semantic cap without duplication`, async () => {
+		const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-semantic-key-"));
+		const configPath = join(root, "config.toml");
+		await writeFile(configPath, ['model = "gpt-5.4"', "", ...fixture.lines, ""].join("\n"));
+
+		await migrateConfigFile(configPath);
+		const firstPass = await readFile(configPath, "utf8");
+		const parsed = parseTomlWithPython(firstPass);
+		const secondResult = await migrateConfigFile(configPath);
+		const secondPass = await readFile(configPath, "utf8");
+
+		assert.equal(parsed.features.multi_agent_v2.max_concurrent_threads_per_session, 7);
+		assert.equal(secondResult.changed, false);
+		assert.equal(secondPass, firstPass);
+		assert.match(secondPass, new RegExp(fixture.preservedLine.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+		assert.doesNotMatch(secondPass, /^max_concurrent_threads_per_session = 16$/m);
+		if (fixture.name === "root-qualified dotted cap key") {
+			assert.equal(parsed.features.multi_agent_v2.enabled, false);
+		}
+	});
+}
+
+test("#given multiline string contains V2 cap lookalikes #when SessionStart migrates #then writes the absent semantic default", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-multiline-lookalike-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.4"',
+			'notes = """',
+			"[features.multi_agent_v2]",
+			"max_concurrent_threads_per_session = 7",
+			'"""',
+			"",
+		].join("\n"),
+	);
 
+	await migrateConfigFile(configPath);
 	const content = await readFile(configPath, "utf8");
-	assert.equal(result.changed, true);
-	assert.match(content, /\[agents\][\s\S]*?max_threads = 1000/);
-	assert.match(content, /max_depth = 4/);
-	assert.match(content, /\[agents\.explorer\]\nconfig_file = "\.\/agents\/explorer\.toml"/);
-	assert.match(content, /\[features\.multi_agent_v2\][\s\S]*?enabled = false/);
-	assert.match(content, /max_concurrent_threads_per_session = 1000/);
-	assert.doesNotMatch(content, /^max_threads\s*=\s*6$/m);
+	const parsed = parseTomlWithPython(content);
+
+	assert.match(parsed.notes, /max_concurrent_threads_per_session = 7/);
+	assert.equal(parsed.features.multi_agent_v2.max_concurrent_threads_per_session, 16);
+});
+
+test("#given V2 section multiline value contains a cap lookalike #when SessionStart migrates #then writes the absent default", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-section-multiline-lookalike-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.4"',
+			"[features.multi_agent_v2]",
+			'notes = """',
+			"max_concurrent_threads_per_session = 7",
+			'"""',
+			"",
+		].join("\n"),
+	);
+
+	await migrateConfigFile(configPath);
+	const parsed = parseTomlWithPython(await readFile(configPath, "utf8"));
+
+	assert.equal(parsed.features.multi_agent_v2.max_concurrent_threads_per_session, 16);
 });
 
-test("#given gpt-5.6 session model with no models_cache #when migrating #then does not write agents.max_threads", async () => {
+test("#given V2 root-dotted disable and cap #when gpt-5.6 SessionStart migrates #then removes disable and V1 agents cap", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-root-dotted-v2-cleanup-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.6-terra"',
+			"features.multi_agent_v2.max_concurrent_threads_per_session = 7",
+			"features.multi_agent_v2.enabled = false",
+			"",
+			"[agents]",
+			"max_threads = 1000",
+			"",
+		].join("\n"),
+	);
+
+	await migrateConfigFile(configPath, { sessionModel: "gpt-5.6-terra" });
+	const content = await readFile(configPath, "utf8");
+	const parsed = parseTomlWithPython(content);
+
+	assert.equal(parsed.features.multi_agent_v2.max_concurrent_threads_per_session, 7);
+	assert.equal(parsed.features.multi_agent_v2.enabled, undefined);
+	assert.equal(parsed.agents, undefined);
+});
+
+test("#given quoted dotted V1 keys under features #when SessionStart migrates #then replaces enabled without a duplicate", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-quoted-dotted-v1-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.4"',
+			"",
+			"[features]",
+			'"multi_agent_v2".enabled = true',
+			'"multi_agent_v2".max_concurrent_threads_per_session = 7',
+			"",
+		].join("\n"),
+	);
+
+	await migrateConfigFile(configPath);
+	const content = await readFile(configPath, "utf8");
+	const parsed = parseTomlWithPython(content);
+
+	assert.equal(parsed.features.multi_agent_v2.enabled, false);
+	assert.equal(parsed.features.multi_agent_v2.max_concurrent_threads_per_session, 7);
+	assert.equal((content.match(/enabled\s*=/g) ?? []).length, 1);
+});
+
+test("#given multiline string closes after an escaped quote #when SessionStart migrates #then preserves the following explicit cap", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-overlapping-closer-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.4"',
+			'notes = """abc\\\""""',
+			"[features.multi_agent_v2]",
+			"max_concurrent_threads_per_session = 7",
+			"",
+		].join("\n"),
+	);
+
+	await migrateConfigFile(configPath);
+	const content = await readFile(configPath, "utf8");
+	const parsed = parseTomlWithPython(content);
+
+	assert.equal(parsed.features.multi_agent_v2.max_concurrent_threads_per_session, 7);
+	assert.equal((content.match(/^\[features\.multi_agent_v2\]$/gm) ?? []).length, 1);
+});
+
+test("#given gpt-5.6 session model with no models_cache and an explicit V2 cap #when migrating #then removes agents.max_threads but preserves the cap", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-gpt56-nocache-"));
 	const configPath = join(root, "config.toml");
 	await writeFile(
@@ -58,7 +294,7 @@ test("#given gpt-5.6 session model with no models_cache #when migrating #then do
 			"",
 			"[features.multi_agent_v2]",
 			"enabled = false",
-			"max_concurrent_threads_per_session = 1000",
+			"max_concurrent_threads_per_session = 6",
 			"",
 		].join("\n"),
 	);
@@ -73,7 +309,28 @@ test("#given gpt-5.6 session model with no models_cache #when migrating #then do
 	assert.doesNotMatch(content, /^\s*max_threads\s*=/m);
 	assert.doesNotMatch(content, /^\s*enabled\s*=\s*false/m);
 	assert.match(content, /max_depth = 4/);
-	assert.match(content, /max_concurrent_threads_per_session = 1000/);
+	assert.match(content, /max_concurrent_threads_per_session = 6/);
+});
+
+test("#given SessionStart config migration has no V2 cap #when migrating #then writes the conservative managed default", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-missing-cap-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.4"',
+			"",
+			"[features.multi_agent_v2]",
+			"enabled = false",
+			"",
+		].join("\n"),
+	);
+
+	await migrateConfigFile(configPath);
+
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /max_concurrent_threads_per_session = 16/);
+	assert.doesNotMatch(content, /max_concurrent_threads_per_session = 1000/);
 });
 
 test("#given config without any model #when migrating #then does not introduce agents.max_threads", async () => {
@@ -89,7 +346,7 @@ test("#given config without any model #when migrating #then does not introduce a
 	const content = await readFile(configPath, "utf8");
 	assert.doesNotMatch(content, /^\s*max_threads\s*=/m);
 	assert.match(content, /max_depth = 4/);
-	assert.match(content, /max_concurrent_threads_per_session = 1000/);
+	assert.match(content, /max_concurrent_threads_per_session = 16/);
 });
 
 test("#given config without any model but an existing low cap #when migrating #then still raises the existing cap", async () => {

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

@@ -241,6 +241,9 @@ test("#given start-work skill #when synced for Codex #then the difficulty-tier d
 	assert.match(content, /lazycodex-worker-medium/);
 	assert.match(content, /Delegation by difficulty/);
 	assert.match(content, /Global Review and Debugging Gate/);
+	assert.match(content, /full commit SHA/);
+	assert.match(content, /re-read the ledger record/);
+	assert.match(content, /exact lane\/SHA pair/);
 	assert.doesNotMatch(content, /works the same on both surfaces/);
 });
 
@@ -256,6 +259,10 @@ test("#given review-work skill #when some lanes do not finish #then aggregate re
 	assert.match(content, /Do not spin in repeated/);
 	assert.match(content, /bare REJECT\/FAIL token without findings is not a verdict/);
 	assert.match(content, /cites the violated goal criterion/);
+	assert.match(content, /append a durable task-evidence record/);
+	assert.match(content, /full commit SHA/);
+	assert.match(content, /re-read that record/);
+	assert.match(content, /exact lane\/SHA pair/);
 	assert.match(content, /Do not use `multi_agent_v1\.send_input` as an interrupt/);
 });
 

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

@@ -32,10 +32,11 @@ export const expectedSkills = [
 	"visual-qa",
 ];
 
-export const hiddenSharedSkills = ["ultraresearch"];
-
 export const componentSkillSources = [
 	["comment-checker", "components/comment-checker/skills/comment-checker"],
+	["lcx-contribute-bug-fix", "components/lcx/skills/lcx-contribute-bug-fix"],
+	["lcx-doctor", "components/lcx/skills/lcx-doctor"],
+	["lcx-report-bug", "components/lcx/skills/lcx-report-bug"],
 	["lsp", "components/lsp/skills/lsp"],
 	["rules", "components/rules/skills/rules"],
 	["teammode", "components/teammode/skills/teammode"],
@@ -77,9 +78,10 @@ const startWorkOriginalCompletion = `When all top-level checkboxes in \`## TODOs
 const startWorkCodexCompletion = `When all top-level checkboxes in \`## TODOs\` and \`## Final Verification Wave\` are complete:
 
 1. Run the plan's final verification commands.
-2. Complete the **Global Review and Debugging Gate** before any completion claim, PR creation, PR handoff, branch handoff, or merge. The gate's pass binds to the commit SHA it reviewed and covers every later checkpoint at that same SHA — never re-run it on an already-passed SHA; re-run only when new commits land:
+2. Complete the **Global Review and Debugging Gate** before any completion claim, PR creation, PR handoff, branch handoff, or merge:
    - Invoke the \`review-work\` skill with the final diff, changed files, user goal, constraints, run command, and verification evidence. All five review lanes must return PASS. A timeout, missing deliverable, ack-only child, \`BLOCKED:\`, or inconclusive lane is a gate failure, not approval.
-   - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append the ruled-out or confirmed result to \`.omo/start-work/ledger.jsonl\`.
+   - Each passing review lane binds to the exact full commit SHA it reviewed. Immediately append a durable record to \`.omo/start-work/ledger.jsonl\` with the lane name, full SHA, PASS verdict, and report artifact/source. Before same-SHA reuse after any continuation or compaction, re-read the ledger record and require the exact lane/SHA pair; memory, chat history, or an unstamped report is not coverage. New commits require fresh applicable lane coverage.
+   - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append a separate durable record with the audit name, exact full SHA, verdict, and evidence artifact/source to \`.omo/start-work/ledger.jsonl\`. Reuse it only after re-reading an exact audit/SHA match.
    - If any review lane or debugging hypothesis fails, invoke the \`debugging\` skill, confirm root cause with runtime evidence, add the minimal failing test or reproduction, fix it, rerun the affected verification, then rerun the Global Review and Debugging Gate.
    - Evidence hygiene is mandatory: redact or mask secrets and sensitive user data before writing \`.omo/start-work/ledger.jsonl\`, a PR body, or a handoff. Never include raw tokens, credentials, auth headers, cookies, API keys, env dumps, private logs, or PII; use concise summaries, lengths, hashes, or short non-sensitive prefixes instead.
    - If the work includes creating, updating, or handing off a PR, refresh \`git status\` and the PR/branch state from the task-owned worktree after the gate, and include only redacted review/debugging evidence in the PR body or handoff.
@@ -91,26 +93,40 @@ const startWorkOriginalHardRule = "- No completion claim while an applicable ult
 
 const startWorkCodexHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No `ORCHESTRATION COMPLETE`, final response, PR creation, PR handoff, or merge before the Global Review and Debugging Gate passes with recorded evidence.\n- No PR/branch implementation or review in the main worktree; create or use a task-owned git worktree first.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
 
-const reviewWorkCodexGatePattern =
-	/\nWhen `review-work` is used as a final implementation, PR, or `\$start-work`\ngate, it is blocking\. A timeout, missing deliverable, ack-only response,\nexplicit `BLOCKED:`, or inconclusive lane is not a pass\. Treat that lane as\nfailed, investigate the underlying uncertainty with the `debugging` skill when\nruntime behavior may be wrong, fix with evidence, and rerun the affected lane\nbefore claiming completion, creating or handing off a PR, or merging\.\n\nA rejecting lane must name its blockers inline in its final message — each\nblocker cites the violated goal criterion or requirement plus an evidence\npointer\. A bare REJECT\/FAIL token without findings is not a verdict; treat it\nas an inconclusive lane \(one bounded respawn, then record it inconclusive with\nthat reason\)\.\n\nWhen reviewing a PR or branch, collect diff, file contents, and verification\nresults from a dedicated review worktree attached to that branch\. Never\ncheckout, test, or edit the review branch in the main worktree\.\n\nReview evidence must be safe to share\. Redact or mask secrets and sensitive\nuser data before including evidence in logs, PR bodies, or handoffs\. Never\ninclude raw tokens, credentials, auth headers, cookies, API keys, env dumps,\nprivate logs, or PII; summarize with lengths, hashes, and short non-sensitive\nprefixes when identity is needed\.\n/;
+const reviewWorkCodexGate = `
+When \`review-work\` is used as a final implementation, PR, or \`$start-work\`
+gate, it is blocking. A timeout, missing deliverable, ack-only response,
+explicit \`BLOCKED:\`, or inconclusive lane is not a pass. Treat that lane as
+failed, investigate the underlying uncertainty with the \`debugging\` skill when
+runtime behavior may be wrong, fix with evidence, and rerun the affected lane
+before claiming completion, creating or handing off a PR, or merging.
+
+After each lane reaches PASS, immediately append a durable task-evidence record
+to the active ledger with the lane name, exact full commit SHA, PASS verdict,
+and report artifact/source. Before reusing coverage after continuation or
+compaction, re-read that record and require the exact lane/SHA pair. Memory,
+chat history, or an unstamped report is not coverage; a new commit requires
+fresh applicable lane records.
+
+A rejecting lane must name its blockers inline in its final message — each
+blocker cites the violated goal criterion or requirement plus an evidence
+pointer. A bare REJECT/FAIL token without findings is not a verdict; treat it
+as an inconclusive lane (one bounded respawn, then record it inconclusive with
+that reason).
+
+When reviewing a PR or branch, collect diff, file contents, and verification
+results from a dedicated review worktree attached to that branch. Never
+checkout, test, or edit the review branch in the main worktree.
+
+Review evidence must be safe to share. Redact or mask secrets and sensitive
+user data before including evidence in logs, PR bodies, or handoffs. Never
+include raw tokens, credentials, auth headers, cookies, API keys, env dumps,
+private logs, or PII; summarize with lengths, hashes, and short non-sensitive
+prefixes when identity is needed.
+`;
+const reviewWorkCodexGatePattern = new RegExp(reviewWorkCodexGate.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
 
 export function removeCodexSkillOverlays(skillName, content) {
-	if (skillName === "ulw-research") {
-		return content
-			.replace(
-				", any 'ulw' research wording,",
-				", the legacy alias 'ultraresearch', any 'ulw' research wording,",
-			)
-			.replace(
-				"the word \"ulw-research\" (also `/ulw-research`, `$ulw-research`), ",
-				"the word \"ulw-research\" (also `/ulw-research`, `$ulw-research`), the legacy alias \"ultraresearch\" (also `/ultraresearch`, `$ultraresearch`), ",
-			)
-			.replace(
-				"answer those normally, and mention that `ulw-research` is available when a question would clearly benefit from it.",
-				"answer those normally, and mention that `ulw-research` is available (legacy alias: `ultraresearch`) when a question would clearly benefit from it.",
-			)
-			.replace("# ULW-Research Synthesis: <query>", "# Ultraresearch Synthesis: <query>");
-	}
 	if (skillName === "start-work") {
 		return content
 			.replace(startWorkCodexCompletion, startWorkOriginalCompletion)

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

@@ -9,7 +9,6 @@ import {
 	assertPackagedContentMatches,
 	componentSkillSources,
 	expectedSkills,
-	hiddenSharedSkills,
 	listSkillFiles,
 	removeCodexCompatibilityGuidance,
 	removeCodexSkillOverlays,
@@ -113,7 +112,6 @@ test("#given shared skill package source #when aggregate Codex shared skills are
 	// when / then
 	for (const skillName of sharedSkillNames) {
 		if (componentSkillNames.has(skillName)) continue;
-		if (hiddenSharedSkills.includes(skillName)) continue;
 		const sharedContent = await readFile(join(sharedSkillsRoot, skillName, "SKILL.md"), "utf8");
 		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
 		assert.equal(
@@ -213,11 +211,8 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 test("#given shipped Codex skill payloads #when legacy ultraresearch alias is inspected #then it is not packaged", async () => {
 	// given
 	const skillsRoot = join(root, "skills");
-	const skillRoot = join(skillsRoot, "ultraresearch");
 
 	// then
-	await assert.rejects(readFile(join(skillRoot, "SKILL.md"), "utf8"), { code: "ENOENT" });
-	await assert.rejects(readFile(join(skillRoot, "agents", "openai.yaml"), "utf8"), { code: "ENOENT" });
 	await assertNoLegacyResearchAliasInTree(skillsRoot, "skills");
 	for (const [skillName, sourcePath] of componentSkillSources) {
 		await assertNoLegacyResearchAliasInTree(join(root, sourcePath), `components/${skillName}`);