oh-my-opencode 4.18.2 → 4.19.1

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-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"],
@@ -126,22 +127,6 @@ 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}`);