oh-my-opencode 4.13.0 → 4.14.0

package/packages/omo-codex/plugin/test/bootstrap-binlinks.test.mjs

@@ -1,20 +1,27 @@
 import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
 import { lstat, mkdir, mkdtemp, readdir, readFile, readlink, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, sep } from "node:path";
+import { dirname, join, sep } from "node:path";
 import test from "node:test";
+import { promisify } from "node:util";
 
 const CLI_URL = new URL("../components/bootstrap/dist/cli.js", import.meta.url);
 const { runBootstrapWorker, runWorkerSetup } = await import(CLI_URL.href);
 
 const MARKETPLACE_SOURCE_LINE = 'source = "https://github.com/code-yeongyu/lazycodex.git"';
 const COMPONENT_BIN_NAME = "omo-toolbox";
+const execFileAsync = promisify(execFile);
 const OMO_CLI_DEGRADED_ENTRY = {
 	component: "omo-cli",
 	hint: "use npx lazycodex-ai for the omo CLI",
 	reason: "marketplace payload has no dist/cli",
 };
 
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 async function withBinLinkFixture(run) {
 	const root = await mkdtemp(join(tmpdir(), "omo-bootstrap-binlinks-"));
 	try {
@@ -79,6 +86,8 @@ async function writeVersionedRoot(root, version, { withRuntimeCli = false } = {}
 	if (withRuntimeCli) {
 		await mkdir(join(pluginRoot, "dist", "cli"), { recursive: true });
 		await writeFile(join(pluginRoot, "dist", "cli", "index.js"), "console.log('omo');\n");
+		await mkdir(join(pluginRoot, "dist", "cli-node"), { recursive: true });
+		await writeFile(join(pluginRoot, "dist", "cli-node", "index.js"), "console.log('omo node runtime');\n");
 	}
 	return pluginRoot;
 }
@@ -196,14 +205,18 @@ test("#given platform win32 #when the worker setup links bins #then component bi
 		assert.deepEqual(outcome.degraded, []);
 		const shim = await readFile(join(fixture.binDir, `${COMPONENT_BIN_NAME}.cmd`), "utf8");
 		assert.match(shim, /@echo off/);
-		assert.ok(shim.includes(`node "${join(pluginRoot, "components", "toolbox", "dist", "cli.js")}"`));
+		const componentEntrypoint = join(pluginRoot, "components", "toolbox", "dist", "cli.js");
+		assert.match(shim, /NODE_REPL_NODE_PATH/);
+		assert.match(shim, /"%OMO_NODE_BINARY%"/);
+		assert.match(shim, new RegExp(`"${escapeRegExp(componentEntrypoint)}" %\\*`));
+		assert.doesNotMatch(shim, new RegExp(`node "${escapeRegExp(componentEntrypoint)}" %\\*`));
 		const wrapper = await readFile(join(fixture.binDir, "omo.cmd"), "utf8");
 		assert.ok(wrapper.includes(join(pluginRoot, "dist", "cli", "index.js")));
 		await assert.rejects(() => lstat(join(fixture.binDir, COMPONENT_BIN_NAME)), "win32 must not leave posix symlinks behind");
 	});
 });
 
-test("#given a marketplace payload without dist/cli #when the worker setup runs #then it records the degraded omo-cli entry, logs the skip warning, and leaves no broken or omo link", async () => {
+test("#given a legacy payload without root CLI dist #when the worker setup runs #then it records degraded omo-cli and leaves no broken link", async () => {
 	await withBinLinkFixture(async (fixture) => {
 		const pluginRoot = await writeVersionedRoot(fixture.root, "1.0.0");
 
@@ -234,14 +247,19 @@ test("#given a payload shipping dist/cli #when the worker setup runs with no bin
 		assert.deepEqual(outcome.degraded, []);
 		const defaultBinDir = join(fixture.codexHome, "bin");
 		const wrapperName = process.platform === "win32" ? "omo.cmd" : "omo";
-		const wrapper = await readFile(join(defaultBinDir, wrapperName), "utf8");
+		const wrapperPath = join(defaultBinDir, wrapperName);
+		const wrapper = await readFile(wrapperPath, "utf8");
 		assert.ok(wrapper.includes(join(pluginRoot, "dist", "cli", "index.js")));
 		if (process.platform !== "win32") {
-			assert.ok((await stat(join(defaultBinDir, "omo"))).mode & 0o111, "the posix omo wrapper must be executable");
+			assert.ok((await stat(wrapperPath)).mode & 0o111, "the posix omo wrapper must be executable");
 			assert.equal(
 				await readlink(join(defaultBinDir, COMPONENT_BIN_NAME)),
 				join(pluginRoot, "components", "toolbox", "dist", "cli.js"),
 			);
+			const result = await execFileAsync(wrapperPath, ["--version"], {
+				env: { ...process.env, OMO_RUNTIME: "node", PATH: `${dirname(process.execPath)}:/usr/bin:/bin` },
+			});
+			assert.match(result.stdout, /omo node runtime/);
 		} else {
 			const shim = await readFile(join(defaultBinDir, `${COMPONENT_BIN_NAME}.cmd`), "utf8");
 			assert.ok(shim.includes(join(pluginRoot, "components", "toolbox", "dist", "cli.js")));

package/packages/omo-codex/plugin/test/bootstrap-hooks.test.mjs

@@ -16,6 +16,8 @@ const SKIPPED_DIRECTORY_NAMES = new Set([".git", "node_modules"]);
 const EXPECTED_BOOTSTRAP_COMMAND = 'node "${PLUGIN_ROOT}/components/bootstrap/dist/cli.js" hook session-start';
 const EXPECTED_BOOTSTRAP_COMMAND_WINDOWS =
 	'powershell -NoProfile -ExecutionPolicy Bypass -File "${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\bootstrap.ps1"';
+const EXPECTED_NODE_DISPATCH_PREFIX =
+	'powershell -NoProfile -ExecutionPolicy Bypass -File "${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1"';
 
 async function pathExists(absolutePath) {
 	try {
@@ -127,6 +129,23 @@ test("#given aggregate and component hook manifests #when command targets are re
 	assert.deepEqual(missing, []);
 });
 
+test("#given aggregate hook manifests #when command handlers are inspected #then each has a Windows dispatcher", async () => {
+	// given
+	const aggregateHooks = await readAggregateHookManifests();
+
+	// when
+	const missing = [];
+	for (const manifest of aggregateHooks) {
+		for (const { handler } of collectCommandHooks(manifest.hooks, manifest.source)) {
+			if (typeof handler.commandWindows === "string" && handler.commandWindows.length > 0) continue;
+			missing.push(`${manifest.source}: ${handler.command}`);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, [], `Aggregate hook commands need commandWindows dispatchers:\n${missing.join("\n")}`);
+});
+
 test("#given the bootstrap component #when its SessionStart registration is inspected #then aggregate and component entries declare both platform commands", async () => {
 	// given
 	const aggregateHooks = (await readAggregateHookManifests()).find(({ source }) =>
@@ -156,6 +175,25 @@ test("#given the bootstrap component #when its SessionStart registration is insp
 	}
 });
 
+test("#given non-bootstrap aggregate hook manifests #when commandWindows entries are read #then they launch the managed Node dispatcher", async () => {
+	// given
+	const aggregateHooks = await readAggregateHookManifests();
+
+	// when
+	const offenders = [];
+	for (const manifest of aggregateHooks) {
+		for (const { handler } of collectCommandHooks(manifest.hooks, manifest.source)) {
+			if (handler.command === EXPECTED_BOOTSTRAP_COMMAND) continue;
+			if (typeof handler.commandWindows !== "string" || !handler.commandWindows.startsWith(EXPECTED_NODE_DISPATCH_PREFIX)) {
+				offenders.push(`${manifest.source}: ${handler.commandWindows ?? "<missing>"}`);
+			}
+		}
+	}
+
+	// then
+	assert.deepEqual(offenders, [], `Non-bootstrap aggregate hooks must use node-dispatch.ps1 on Windows:\n${offenders.join("\n")}`);
+});
+
 test("#given the built bootstrap bundle #when its module references are inspected #then it depends on Node built-ins only", async () => {
 	// given
 	const bundlePath = join(root, "components", "bootstrap", "dist", "cli.js");

package/packages/omo-codex/plugin/test/bootstrap-ps-guard.test.mjs

@@ -68,6 +68,31 @@ test("#given bootstrap.ps1 #when environment writes are scanned #then no Machine
 	assert.deepEqual(offenders, [], "bootstrap.ps1 must only touch User-scope environment values (Machine scope needs elevation)");
 });
 
+test("#given bootstrap.ps1 #when dependency discovery misses #then it never invokes winget or mutates user PATH", async () => {
+	// given
+	const content = await readBootstrapScript();
+
+	// then
+	assert.doesNotMatch(content, /&\s*winget\s+install/i, "bootstrap.ps1 must not install system dependencies with winget");
+	assert.doesNotMatch(
+		content,
+		/SetEnvironmentVariable\("Path"/,
+		"bootstrap.ps1 must not mutate the user PATH when Codex Desktop misses PATH entries",
+	);
+});
+
+test("#given bootstrap.ps1 #when resolving Node #then Codex NODE_REPL_NODE_PATH is checked before PATH", async () => {
+	// given
+	const content = await readBootstrapScript();
+
+	// then
+	assert.match(content, /NODE_REPL_NODE_PATH/, "bootstrap.ps1 must know how to read the Codex bundled Node setting");
+	assert(
+		content.indexOf("NODE_REPL_NODE_PATH") < content.indexOf("Get-Command node"),
+		"bootstrap.ps1 must prefer Codex bundled Node config before probing PATH",
+	);
+});
+
 test("#given bootstrap.ps1 #when execution policy mutations are scanned #then Set-ExecutionPolicy is never invoked", async () => {
 	// given
 	const content = await readBootstrapScript();

package/packages/omo-codex/plugin/test/bootstrap-setup.test.mjs

@@ -205,21 +205,15 @@ test("#given an unwritable config.toml #when the worker setup runs #then it degr
 	});
 });
 
-test("#given win32 without Git Bash and auto-install skipped #when the worker setup runs #then it degrades instead of throwing and disables the git_bash MCP", async () => {
+test("#given win32 without Git Bash #when the worker setup runs #then it degrades instead of throwing and disables the git_bash MCP", async () => {
 	await withSetupFixture(async (fixture) => {
-		const commands = [];
 		const outcome = await runWorkerSetup(
 			setupOptions(fixture, {
-				env: { OMO_CODEX_SKIP_GIT_BASH_AUTO_INSTALL: "1" },
 				platform: "win32",
 				resolveGitBash: () => ({ checkedPaths: [], found: false, installHint: "install git bash" }),
-				runCommand: async (command, args) => {
-					commands.push([command, ...args]);
-				},
 			}),
 		);
 
-		assert.deepEqual(commands, []);
 		const gitBashEntries = outcome.degraded.filter((entry) => entry.component === "git-bash");
 		assert.equal(gitBashEntries.length, 1);
 		const config = await readConfig(fixture);

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

@@ -1,12 +1,41 @@
+// allow: SIZE_OK - migration scenarios share one temp Codex-home harness across legacy TOML shapes; this release only adds config cases and future additions should split by migration family.
+
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
 import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
 
+import { removeUnsupportedRootMultiAgentMode } from "../scripts/migrate-codex-config/multi-agent-mode-guard.mjs";
 import { forceDisableMultiAgentV2 } from "../scripts/migrate-codex-config/multi-agent-v2-guard.mjs";
 import { ensureCodexReasoningConfig, migrateCodexConfig } from "../scripts/migrate-codex-config.mjs";
 
+function parseTomlWithPython(config) {
+	const python = resolvePython();
+	const result = spawnSync(
+		python,
+		[
+			"-c",
+			[
+				"import json, sys, tomllib",
+				"print(json.dumps(tomllib.loads(sys.stdin.read())))",
+			].join("; "),
+		],
+		{ 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 stale root reasoning config #when ensuring config #then replaces stale values without duplicate keys", () => {
 	const result = ensureCodexReasoningConfig(
 		[
@@ -181,7 +210,7 @@ test("#given model catalog is malformed and stale config #when migrating #then f
 	assert.match(content, /model_context_window = 400000/);
 });
 
-test("#given user-customized Codex model config #when migrating #then user values are preserved", async () => {
+test("#given user-customized Codex model config #when migrating #then user values are preserved without root multi-agent mode", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-custom-"));
 	const codexHome = join(root, "codex-home");
 	await mkdir(codexHome, { recursive: true });
@@ -205,11 +234,16 @@ test("#given user-customized Codex model config #when migrating #then user value
 	});
 
 	const content = await readFile(join(codexHome, "config.toml"), "utf8");
-	assert.deepEqual(result.changed, []);
+	assert.deepEqual(result.changed, [join(codexHome, "config.toml")]);
+	assert.deepEqual(result.modeChanged, []);
 	assert.match(content, /model = "gpt-5\.4"/);
 	assert.match(content, /model_context_window = 123456/);
 	assert.match(content, /model_reasoning_effort = "medium"/);
 	assert.match(content, /plan_mode_reasoning_effort = "medium"/);
+	assert.doesNotMatch(content, /^\s*multi_agent_mode\s*=/m);
+	assert.match(content, /\[agents\][\s\S]*?max_threads = 1000/);
+	assert.match(content, /\[features\.multi_agent_v2\][\s\S]*?enabled = false/);
+	assert.match(content, /max_concurrent_threads_per_session = 1000/);
 });
 
 test("#given managed config state is malformed #when migrating #then migration ignores stale state safely", async () => {
@@ -328,6 +362,7 @@ test("#given config already matches current catalog #when catalog version advanc
 			"model_context_window = 400000",
 			'model_reasoning_effort = "high"',
 			'plan_mode_reasoning_effort = "xhigh"',
+			'multi_agent_mode = "proactive"',
 			"",
 			"[features.multi_agent_v2]",
 			"enabled = false",
@@ -363,9 +398,88 @@ test("#given config already matches current catalog #when catalog version advanc
 	});
 
 	const state = JSON.parse(await readFile(statePath, "utf8"));
-	assert.deepEqual(result.changed, []);
+	assert.deepEqual(result.changed, [configPath]);
+	assert.deepEqual(result.modeChanged, [configPath]);
 	assert.equal(state.files[configPath].managed, true);
 	assert.equal(state.files[configPath].catalogVersion, "test.role-only");
+	const content = await readFile(configPath, "utf8");
+	assert.doesNotMatch(content, /^\s*multi_agent_mode\s*=/m);
+	assert.match(content, /\[agents\][\s\S]*?max_threads = 1000/);
+	assert.match(content, /max_concurrent_threads_per_session = 1000/);
+});
+
+test("#given stale Context7 placeholder MCP config #when migrating #then removes it and keeps plugin policy", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-context7-placeholder-cleanup-"));
+	const codexHome = join(root, "codex-home");
+	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"',
+			"",
+			"[mcp_servers.context7] # stale npx package from old docs",
+			'command = "npx"',
+			'args = ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]',
+			"startup_timeout_sec = 20",
+			"",
+			'[plugins."omo@sisyphuslabs".mcp_servers.context7]',
+			"enabled = true",
+			"",
+		].join("\n"),
+	);
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: root,
+	});
+
+	const content = await readFile(configPath, "utf8");
+	assert.deepEqual(result.changed, [configPath]);
+	assert.doesNotMatch(content, /\[mcp_servers\.context7\]/);
+	assert.doesNotMatch(content, /@upstash\/context7-mcp/);
+	assert.doesNotMatch(content, /YOUR_API_KEY/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.context7\][\s\S]*?enabled = true/);
+});
+
+test("#given real Context7 API key and placeholder comment #when migrating #then preserves user server settings", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-context7-real-key-"));
+	const codexHome = join(root, "codex-home");
+	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"',
+			"",
+			"[mcp_servers.context7]",
+			'command = "npx"',
+			'args = ["-y", "@upstash/context7-mcp", "--api-key", "ctx7sk_live_example"] # replace YOUR_API_KEY in docs only',
+			"startup_timeout_sec = 20",
+			"",
+			'[plugins."omo@sisyphuslabs".mcp_servers.context7]',
+			"enabled = true",
+			"",
+		].join("\n"),
+	);
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: root,
+	});
+
+	const content = await readFile(configPath, "utf8");
+	assert.deepEqual(result.changed, [configPath]);
+	assert.match(content, /\[mcp_servers\.context7\]/);
+	assert.match(content, /ctx7sk_live_example/);
+	assert.match(content, /replace YOUR_API_KEY in docs only/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.context7\][\s\S]*?enabled = true/);
 });
 
 test("#given multi_agent_v2 enabled #when forcing disable #then flips the flag to false", () => {
@@ -470,18 +584,23 @@ test("#given an annotated managed section #when forcing disable runs again #then
 	assert.match(rerun, /enabled = false/);
 });
 
-test("#given [features] boolean shorthand multi_agent_v2 = false #when forcing disable #then returns config unchanged", () => {
+test("#given [features] boolean shorthand multi_agent_v2 = false #when forcing disable #then rewrites to the non-conflicting disabled table", () => {
 	const config = [
 		'model = "gpt-5.5"',
 		"",
 		"[features]",
 		"multi_agent_v2 = false",
+		"plugins = true",
 		"",
 	].join("\n");
 
 	const result = forceDisableMultiAgentV2(config);
+	const parsed = parseTomlWithPython(result);
 
-	assert.equal(result, config);
+	assert.doesNotMatch(result, /^\s*multi_agent_v2\s*=/m);
+	assert.equal((result.match(/\[features\.multi_agent_v2\]/g) ?? []).length, 1);
+	assert.equal(parsed.features.plugins, true);
+	assert.equal(parsed.features.multi_agent_v2.enabled, false);
 });
 
 test("#given multi_agent_v2 already disabled #when forcing disable #then returns config unchanged", () => {
@@ -520,8 +639,87 @@ test("#given global config without multi_agent_v2 section #when full migration r
 	});
 
 	assert.deepEqual(result.changed, [configPath]);
+	assert.deepEqual(result.modeChanged, []);
 	const content = await readFile(configPath, "utf8");
-	assert.match(content, /\[features\.multi_agent_v2\]\nenabled = false\n/);
+	assert.match(content, /\[features\.multi_agent_v2\][\s\S]*?enabled = false/);
+	assert.match(content, /max_concurrent_threads_per_session = 1000/);
+	assert.match(content, /\[agents\][\s\S]*?max_threads = 1000/);
+	assert.doesNotMatch(content, /^\s*multi_agent_mode\s*=/m);
+});
+
+test("#given global config starts with inline-comment features table #when full migration runs #then managed root settings stay at TOML root", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-root-settings-inline-features-"));
+	const codexHome = join(root, "codex-home");
+	await mkdir(codexHome, { recursive: true });
+	const configPath = join(codexHome, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[features] # keep comment",
+			"plugins = true",
+			"",
+		].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");
+	const parsed = parseTomlWithPython(content);
+	assert.equal("multi_agent_mode" in parsed, false);
+	assert.equal(parsed.model, "gpt-5.5");
+	assert.equal(parsed.model_context_window, 400000);
+	assert.equal(parsed.model_reasoning_effort, "high");
+	assert.equal(parsed.plan_mode_reasoning_effort, "xhigh");
+	assert.equal(parsed.features.plugins, true);
+	assert.equal("multi_agent_mode" in parsed.features, false);
+	assert.equal("model" in parsed.features, false);
+	assert.equal("model_context_window" in parsed.features, false);
+	assert.match(content, /^model = "gpt-5\.5"\nmodel_context_window = 400000/m);
+	assert.doesNotMatch(content, /^\s*multi_agent_mode\s*=/m);
+	assert.match(content, /\[features\] # keep comment\nplugins = true/);
+});
+
+test("#given queue multi-agent mode #when removing unsupported root key #then deletes root setting", () => {
+	const config = ['multi_agent_mode = "queue"', "", "[features]", "multi_agent = true", ""].join("\n");
+
+	const result = removeUnsupportedRootMultiAgentMode(config);
+
+	assert.doesNotMatch(result, /^\s*multi_agent_mode\s*=/m);
+	assert.doesNotMatch(result, /multi_agent_mode = "queue"/);
+	assert.match(result, /\[features\]/);
+});
+
+test("#given proactive multi-agent mode #when removing unsupported root key #then deletes root setting", () => {
+	const config = ['multi_agent_mode = "proactive" # user already opted in', "", "[features]", "multi_agent = true", ""].join("\n");
+
+	const result = removeUnsupportedRootMultiAgentMode(config);
+
+	assert.doesNotMatch(result, /^\s*multi_agent_mode\s*=/m);
+	assert.match(result, /\[features\]/);
+});
+
+test("#given inline-comment features table #when removing unsupported root key #then config stays unchanged", () => {
+	const config = ["[features] # keep comment", "multi_agent = true", ""].join("\n");
+
+	const result = removeUnsupportedRootMultiAgentMode(config);
+	const parsed = parseTomlWithPython(result);
+
+	assert.equal(result, config);
+	assert.equal("multi_agent_mode" in parsed, false);
+	assert.equal(parsed.features.multi_agent, true);
+});
+
+test("#given indented root proactive mode #when removing unsupported root key #then no root setting remains", () => {
+	const config = ['  multi_agent_mode = "proactive" # user already opted in', "", "[features] # keep comment", "multi_agent = true", ""].join("\n");
+
+	const result = removeUnsupportedRootMultiAgentMode(config);
+
+	assert.equal(result.match(/multi_agent_mode\s*=/g)?.length ?? 0, 0);
+	assert.match(result, /^\[features\] # keep comment$/m);
 });
 
 test("#given global config with forced multi_agent_v2 #when full migration runs #then disables it on disk", async () => {
@@ -551,6 +749,8 @@ test("#given global config with forced multi_agent_v2 #when full migration runs
 	const content = await readFile(configPath, "utf8");
 	assert.match(content, /enabled = false/);
 	assert.doesNotMatch(content, /enabled = true/);
+	assert.match(content, /max_concurrent_threads_per_session = 1000/);
+	assert.match(content, /\[agents\][\s\S]*?max_threads = 1000/);
 });
 
 test("#given enabled = true with an inline comment #when forcing disable #then flips to false and preserves the comment", () => {

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

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+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 () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-subagent-limit-migration-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.4"',
+			"model_context_window = 123456",
+			'model_reasoning_effort = "medium"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+			"[agents]",
+			"max_threads = 6",
+			"max_depth = 4",
+			"",
+			"[agents.explorer]",
+			'config_file = "./agents/explorer.toml"',
+			"",
+			"[features.multi_agent_v2]",
+			"enabled = false",
+			"max_concurrent_threads_per_session = 6",
+			"",
+		].join("\n"),
+	);
+
+	const result = 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);
+});

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

@@ -20,10 +20,19 @@ async function readSkill(skillName) {
 	return readFile(join(root, "skills", skillName, "SKILL.md"), "utf8");
 }
 
+async function readSharedSkill(skillName) {
+	return readFile(join(root, "../../shared-skills/skills", skillName, "SKILL.md"), "utf8");
+}
+
 function patternFromParts(parts, flags) {
 	return new RegExp(parts.join(""), flags);
 }
 
+const multiAgentV2RoleGuidance =
+	"On `multi_agent_v2` sessions the same `agent_type` applies (the OMO installer exposes it) with `fork_turns` instead of `fork_context`.";
+const loadSkillsGuidance =
+	"When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`.";
+
 test("#given synced aggregate Codex skills #when they contain OpenCode orchestration examples #then Codex tool compatibility guidance is injected", async () => {
 	// given
 	const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
@@ -41,6 +50,8 @@ test("#given synced aggregate Codex skills #when they contain OpenCode orchestra
 			compatibilityIndex < content.search(opencodeOnlyToolPattern),
 			`${skillName} must explain Codex tool translation before OpenCode-only examples`,
 		);
+		assert.ok(content.includes(multiAgentV2RoleGuidance), `${skillName} missing multi_agent_v2 role guidance`);
+		assert.ok(content.includes(loadSkillsGuidance), `${skillName} missing load_skills guidance`);
 	}
 });
 
@@ -77,7 +88,7 @@ task(category="quick", prompt="verify")
 	assert.ok(compatibilityIndex < firstToolIndex);
 	assert.equal(adapted.match(/## Codex Harness Tool Compatibility/g)?.length, 1);
 	assert.doesNotMatch(adapted, /Older variant guidance/);
-	assert.doesNotMatch(adapted, /When translating `load_skills=\[\.\.\.\]`/);
+	assert.doesNotMatch(adapted, /name the skills inside the spawned agent's `message`/);
 	assert.match(adapted, /\n---\n\n## Next Section/);
 });
 
@@ -141,6 +152,25 @@ call_omo_agent(subagent_type="explore", prompt="inspect")
 	assert.doesNotMatch(adapted, /Obsolete generated compatibility prose/);
 });
 
+test("#given generated Codex compatibility guidance #when adapting a skill #then multi-agent role and load_skills guidance are both present", () => {
+	// given
+	const content = `---
+name: example
+---
+
+# Example Skill
+
+task(subagent_type="oracle", load_skills=["debugging"], prompt="verify")
+`;
+
+	// when
+	const adapted = insertCodexCompatibilityGuidance(content);
+
+	// then
+	assert.ok(adapted.includes(multiAgentV2RoleGuidance));
+	assert.ok(adapted.includes(loadSkillsGuidance));
+});
+
 test("#given generated guidance before a template export #when adapting a skill #then the export wrapper is preserved", () => {
 	// given
 	const content = `---
@@ -214,3 +244,22 @@ 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, /Do not use `multi_agent_v1\.send_input` as an interrupt/);
 });
+
+test("#given PR and review skills #when synced for Codex #then worktree lifecycle is mandatory", async () => {
+	const startWork = await readSkill("start-work");
+	const reviewWork = await readSkill("review-work");
+	const sharedStartWork = await readSharedSkill("start-work");
+
+	assert.match(startWork, /PR creation, PR handoff, branch handoff, or merge/);
+	assert.match(startWork, /Finish the PR\/branch lifecycle from its task-owned worktree/);
+	assert.match(startWork, /merge by default unless explicitly opted out/);
+	assert.match(startWork, /No PR\/branch implementation or review in the main worktree/);
+
+	assert.match(sharedStartWork, /required for PR\/branch work/);
+	assert.match(sharedStartWork, /No PR\/branch implementation, review, or merge in the main worktree/);
+	assert.doesNotMatch(sharedStartWork, /If worktree mode was used/);
+	assert.doesNotMatch(sharedStartWork, /merge or hand off exactly as requested/);
+
+	assert.match(reviewWork, /dedicated review worktree attached to that branch/);
+	assert.match(reviewWork, /Never\s+checkout, test, or edit the review branch in the main worktree/);
+});