oh-my-opencode 4.12.1 → 4.14.0

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

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
 
 import { spawn, spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { pathToFileURL } from "node:url";
 import {
 	DEFAULT_LOCK_STALE_MS,
 	acquireLock,
@@ -13,17 +11,27 @@ import {
 	resolveStatePath,
 	writeState,
 } from "./auto-update-state.mjs";
-import { detectInstallFlow, resolveInstallSnapshotPath } from "./install-flow.mjs";
+import {
+	compareVersions,
+	defaultRunCommandForManualUpdate,
+	detectAutoUpdateInstallFlow,
+	parsePositiveInteger,
+	parseVersion,
+	resolveArgs,
+	resolveCommand,
+	resolveCurrentVersion,
+	resolveLatestVersion,
+	resolveLazyCodexUpdatePlan,
+} from "./auto-update-plan.mjs";
+import { formatMarketplaceFlowNotice, formatUpdateStartedNotice, resolveReleaseNotes } from "./auto-update-release-notes.mjs";
 import { migrateCodexConfig } from "./migrate-codex-config.mjs";
 import { migrateOmoSotConfig } from "./migrate-omo-sot.mjs";
 import { resolveSpawnInvocation } from "./spawn-command.mjs";
 
 const DEFAULT_INTERVAL_MS = 24 * 60 * 60 * 1_000;
 const DEFAULT_RETRY_INTERVAL_MS = 30 * 60 * 1_000;
-const DEFAULT_UPDATE_COMMAND = "npx";
-const DEFAULT_UPDATE_ARGS = ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--codex-autonomous"];
-const MARKETPLACE_FLOW_NOTICE =
-	"[LazyCodex] Auto-update skipped: this LazyCodex install is managed by the Codex plugin marketplace, so the npx self-update was not started. Tell the user to upgrade with `codex plugin marketplace upgrade sisyphuslabs`, and that Codex will require hook re-approval after the upgrade.";
+
+export { resolveLazyCodexUpdatePlan };
 
 export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), lastCheckedAt, lastAttemptedAt, lastStatus, installFlow } = {}) {
 	if (env.LAZYCODEX_AUTO_UPDATE_DISABLED === "1" || env.OMO_CODEX_AUTO_UPDATE_DISABLED === "1") {
@@ -67,15 +75,6 @@ export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), las
 	};
 }
 
-export function resolveLazyCodexUpdatePlan({ currentVersion, latestVersion, command = DEFAULT_UPDATE_COMMAND, args = DEFAULT_UPDATE_ARGS } = {}) {
-	const current = parseVersion(currentVersion);
-	if (current === null) return { shouldUpdate: false, reason: "unknown-current" };
-	const latest = parseVersion(latestVersion);
-	if (latest === null) return { shouldUpdate: false, reason: "unknown-latest" };
-	if (compareVersions(latest, current) <= 0) return { shouldUpdate: false, reason: "up-to-date" };
-	return { shouldUpdate: true, command, args };
-}
-
 export async function runLazyCodexManualUpdate({ env = process.env, dryRun = false, log = console.log, runCommand } = {}) {
 	const commandRunner = runCommand ?? defaultRunCommandForManualUpdate;
 	const currentVersion = resolveCurrentVersion(env);
@@ -102,9 +101,9 @@ export async function runLazyCodexManualUpdate({ env = process.env, dryRun = fal
 }
 
 export async function runAutoUpdateCheck({ env = process.env, now = Date.now() } = {}) {
-	await runConfigMigration({ env });
+	const migrationNotices = await runConfigMigration({ env });
 	const statePath = resolveStatePath(env);
-	const notices = [];
+	const notices = [...migrationNotices];
 	const state = await settlePendingNotice({ env, now, statePath, state: await readState(statePath), notices });
 	const installFlow = detectAutoUpdateInstallFlow(env);
 	if (installFlow.flow === "unknown") {
@@ -122,7 +121,11 @@ export async function runAutoUpdateCheck({ env = process.env, now = Date.now() }
 		if (plan.reason === "marketplace-flow") {
 			await appendUpdateLog(env, now, "skipped", { kind: "marketplace-flow" });
 			await writeState(statePath, { ...state, lastCheckedAt: now, lastStatus: "success" });
-			notices.push(MARKETPLACE_FLOW_NOTICE);
+			const updateContext = resolveUpdateContext({ env });
+			const releaseNotes = updateContext.shouldUpdate
+				? await resolveReleaseNotes({ env, latestVersion: updateContext.latestVersion })
+				: undefined;
+			notices.push(formatMarketplaceFlowNotice({ updateContext, releaseNotes }));
 			return { started: false, reason: plan.reason, notices };
 		}
 		await appendUpdateLog(env, now, "skipped", { reason: plan.reason });
@@ -141,6 +144,7 @@ export async function runAutoUpdateCheck({ env = process.env, now = Date.now() }
 	try {
 		await appendUpdateLog(env, now, "started", { command: plan.command, args: plan.args });
 		const pendingNotice = { fromVersion: plan.currentVersion, toVersion: plan.latestVersion, startedAt: now };
+		const releaseNotes = await resolveReleaseNotes({ env, latestVersion: plan.latestVersion });
 		if (env.LAZYCODEX_AUTO_UPDATE_WAIT === "1") {
 			const invocation = resolveSpawnInvocation(plan.command, plan.args);
 			const result = spawnSync(invocation.command, invocation.args, {
@@ -151,7 +155,7 @@ export async function runAutoUpdateCheck({ env = process.env, now = Date.now() }
 			await appendUpdateLog(env, now, "finished", { status });
 			if (status === 0) {
 				await writeState(statePath, { lastCheckedAt: now, lastAttemptedAt: now, lastStatus: "success", pendingNotice });
-				await recordUpdateStartedNotice({ env, now, notices, pendingNotice });
+				await recordUpdateStartedNotice({ env, now, notices, pendingNotice, releaseNotes });
 			} else {
 				await writeState(statePath, { lastAttemptedAt: now, lastStatus: "failed" });
 			}
@@ -165,7 +169,7 @@ export async function runAutoUpdateCheck({ env = process.env, now = Date.now() }
 			detached: true,
 		});
 		await writeState(statePath, { lastAttemptedAt: now, lastStatus: "started", pendingNotice });
-		await recordUpdateStartedNotice({ env, now, notices, pendingNotice });
+		await recordUpdateStartedNotice({ env, now, notices, pendingNotice, releaseNotes });
 		child.unref();
 		return { started: true, notices };
 	} finally {
@@ -193,8 +197,8 @@ async function settlePendingNotice({ env, now, statePath, state, notices }) {
 	return nextState;
 }
 
-async function recordUpdateStartedNotice({ env, now, notices, pendingNotice }) {
-	notices.push(`[LazyCodex] Auto-update started in the background: v${pendingNotice.fromVersion} -> v${pendingNotice.toVersion}. Tell the user a new LazyCodex version is installing and that they should start a new Codex session after it completes to apply it.`);
+async function recordUpdateStartedNotice({ env, now, notices, pendingNotice, releaseNotes }) {
+	notices.push(formatUpdateStartedNotice({ pendingNotice, releaseNotes }));
 	await appendUpdateLog(env, now, "notified", {
 		kind: "update-started",
 		fromVersion: pendingNotice.fromVersion,
@@ -202,126 +206,26 @@ async function recordUpdateStartedNotice({ env, now, notices, pendingNotice }) {
 	});
 }
 
+function resolveUpdateContext({ env }) {
+	const currentVersion = resolveCurrentVersion(env);
+	const latestVersion = resolveLatestVersion(env);
+	const plan = resolveLazyCodexUpdatePlan({ currentVersion, latestVersion });
+	return { currentVersion, latestVersion, shouldUpdate: plan.shouldUpdate };
+}
+
 async function runConfigMigration({ env }) {
-	if (env.LAZYCODEX_CONFIG_MIGRATION_DISABLED === "1" || env.OMO_CODEX_CONFIG_MIGRATION_DISABLED === "1") return;
+	if (env.LAZYCODEX_CONFIG_MIGRATION_DISABLED === "1" || env.OMO_CODEX_CONFIG_MIGRATION_DISABLED === "1") return [];
 	try {
 		await migrateOmoSotConfig({ env, seed: true });
-		await migrateCodexConfig({ env });
+		const result = await migrateCodexConfig({ env });
+		if (result.modeChanged.length === 0) return [];
+		return [
+			"[LazyCodex] Removed unsupported Codex root multi_agent_mode from config.toml. Tell the user LazyCodex cleaned up a stale OMO-managed setting so Codex uses its supported per-turn multiAgentMode API.",
+		];
 	} catch (error) {
 		if (!(error instanceof Error)) throw error;
-		return;
-	}
-}
-
-function resolveCommand(env) {
-	return env.LAZYCODEX_AUTO_UPDATE_COMMAND?.trim() || DEFAULT_UPDATE_COMMAND;
-}
-
-function resolveArgs(env) {
-	if (env.LAZYCODEX_AUTO_UPDATE_ARGS_JSON) {
-		const parsed = JSON.parse(env.LAZYCODEX_AUTO_UPDATE_ARGS_JSON);
-		if (!Array.isArray(parsed) || parsed.some((value) => typeof value !== "string")) {
-			throw new TypeError("LAZYCODEX_AUTO_UPDATE_ARGS_JSON must be a JSON string array");
-		}
-		return parsed;
-	}
-	return DEFAULT_UPDATE_ARGS;
-}
-
-function detectAutoUpdateInstallFlow(env) {
-	return detectInstallFlow({ pluginRoot: resolveAutoUpdatePluginRoot(env), env });
-}
-
-function resolveAutoUpdatePluginRoot(env) {
-	if (env.PLUGIN_ROOT?.trim()) return env.PLUGIN_ROOT.trim();
-	return dirname(dirname(fileURLToPath(import.meta.url)));
-}
-
-function resolveCurrentVersion(env) {
-	if (env.LAZYCODEX_CURRENT_VERSION?.trim()) return env.LAZYCODEX_CURRENT_VERSION.trim();
-	const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-	return (
-		readVersionManifest(resolveInstallSnapshotPath(env, pluginRoot)) ??
-		readVersionManifest(join(pluginRoot, "..", "..", "..", "package.json")) ??
-		readVersionManifest(join(pluginRoot, ".codex-plugin", "plugin.json"))
-	);
-}
-
-function resolveLatestVersion(env) {
-	if (env.LAZYCODEX_LATEST_VERSION?.trim()) return env.LAZYCODEX_LATEST_VERSION.trim();
-	const invocation = resolveSpawnInvocation("npm", ["view", "lazycodex-ai", "version", "--silent"]);
-	const result = spawnSync(invocation.command, invocation.args, {
-		encoding: "utf8",
-		stdio: ["ignore", "pipe", "ignore"],
-	});
-	if (result.status !== 0) return undefined;
-	const version = result.stdout.trim();
-	return version.length > 0 ? version : undefined;
-}
-
-function defaultRunCommandForManualUpdate(command, args, options) {
-	return new Promise((resolve, reject) => {
-		const invocation = resolveSpawnInvocation(command, args);
-		const child = spawn(invocation.command, invocation.args, {
-			cwd: options.cwd,
-			env: options.env,
-			stdio: "inherit",
-		});
-		child.once("error", reject);
-		child.once("close", (code) => {
-			if (code === 0) {
-				resolve();
-				return;
-			}
-			reject(new Error(`${command} ${args.join(" ")} exited with ${code ?? "unknown status"}`));
-		});
-	});
-}
-
-function parseVersion(version) {
-	if (typeof version !== "string") return null;
-	const match = /^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?(?:\+.*)?$/.exec(version.trim());
-	if (match === null) return null;
-	const major = Number.parseInt(match[1], 10);
-	const minor = Number.parseInt(match[2], 10);
-	const patch = Number.parseInt(match[3], 10);
-	const prerelease = match[4];
-	return Number.isFinite(major) && Number.isFinite(minor) && Number.isFinite(patch)
-		? { major, minor, patch, prerelease }
-		: null;
-}
-
-function compareVersions(left, right) {
-	for (const key of ["major", "minor", "patch"]) {
-		const leftValue = left[key];
-		const rightValue = right[key];
-		if (leftValue > rightValue) return 1;
-		if (leftValue < rightValue) return -1;
-	}
-	if (left.prerelease === undefined && right.prerelease !== undefined) return 1;
-	if (left.prerelease !== undefined && right.prerelease === undefined) return -1;
-	if (left.prerelease !== undefined && right.prerelease !== undefined) {
-		return left.prerelease.localeCompare(right.prerelease);
+		return [];
 	}
-	return 0;
-}
-
-function readVersionManifest(path) {
-	try {
-		const parsed = JSON.parse(readFileSync(path, "utf8"));
-		if (typeof parsed.version !== "string") return undefined;
-		const version = parsed.version.trim();
-		return version.length > 0 ? version : undefined;
-	} catch (error) {
-		if (error instanceof Error) return undefined;
-		throw error;
-	}
-}
-
-function parsePositiveInteger(value, fallback) {
-	if (value === undefined || value === "") return fallback;
-	const parsed = Number.parseInt(value, 10);
-	return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
 }
 
 if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/packages/omo-codex/plugin/scripts/materialize-shared-upstreams.mjs

@@ -0,0 +1,42 @@
+import { execFileSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const pluginScriptsDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(pluginScriptsDir, "..", "..", "..", "..");
+const sharedSkillsScripts = join(repoRoot, "packages", "shared-skills", "scripts");
+const materializeScript = join(sharedSkillsScripts, "materialize-frontend-refs.mjs");
+
+const upstreamPaths = [
+	"packages/shared-skills/upstreams/open-design",
+	"packages/shared-skills/upstreams/taste-skill",
+	"packages/shared-skills/upstreams/ui-ux-pro-max",
+	"packages/shared-skills/upstreams/designpowers",
+];
+
+function initSubmodules({ strict }) {
+	try {
+		execFileSync("git", ["submodule", "update", "--init", "--recursive", ...upstreamPaths], {
+			cwd: repoRoot,
+			stdio: "inherit",
+		});
+		return true;
+	} catch (error) {
+		const message = `[materialize-shared-upstreams] git submodule init failed: ${error instanceof Error ? error.message : String(error)}`;
+		if (strict) throw new Error(message);
+		process.stderr.write(`${message} - continuing without submodule refresh\n`);
+		return false;
+	}
+}
+
+export async function materializeSharedUpstreams({ strict }) {
+	initSubmodules({ strict });
+	const { materializeFrontendRefs } = await import(pathToFileURL(materializeScript).href);
+	return materializeFrontendRefs({ strict });
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	const strict = process.env.OMO_MATERIALIZE_STRICT === "1" || process.argv.includes("--strict");
+	const result = await materializeSharedUpstreams({ strict });
+	if (result.skipped && strict) process.exit(1);
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/context7-placeholder-guard.mjs

@@ -0,0 +1,131 @@
+const CONTEXT7_HEADER = "[mcp_servers.context7]";
+
+export function removeStaleContext7PlaceholderMcpServer(config) {
+	return removeSections(config, (section) => section.header === CONTEXT7_HEADER && isContext7PlaceholderSection(section.text));
+}
+
+function isContext7PlaceholderSection(sectionText) {
+	const args = readStringArraySetting(sectionText, "args");
+	if (args === null || !args.includes("@upstash/context7-mcp")) return false;
+	const apiKey = valueAfter(args, "--api-key");
+	return apiKey !== null && isPlaceholderApiKey(apiKey);
+}
+
+function valueAfter(values, key) {
+	const index = values.indexOf(key);
+	return index >= 0 ? values[index + 1] ?? null : null;
+}
+
+function isPlaceholderApiKey(value) {
+	return /^your[-_ ]?api[-_ ]?key$/i.test(value);
+}
+
+function readStringArraySetting(sectionText, key) {
+	for (const line of sectionText.split("\n")) {
+		if (!new RegExp(`^\\s*${key}\\s*=`).test(line)) continue;
+		const assignmentIndex = line.indexOf("=");
+		if (assignmentIndex === -1) return null;
+		return parseTomlStringArray(stripUnquotedInlineComment(line.slice(assignmentIndex + 1)).trim());
+	}
+	return null;
+}
+
+function parseTomlStringArray(value) {
+	if (!value.startsWith("[") || !value.endsWith("]")) return null;
+	const items = [];
+	let index = 1;
+	while (index < value.length - 1) {
+		const char = value[index];
+		if (char === "\"" || char === "'") {
+			const parsed = parseTomlString(value, index);
+			if (parsed === null) return null;
+			items.push(parsed.value);
+			index = parsed.nextIndex;
+			continue;
+		}
+		index += 1;
+	}
+	return items;
+}
+
+function parseTomlString(input, startIndex) {
+	const quote = input[startIndex];
+	let value = "";
+	let index = startIndex + 1;
+	while (index < input.length) {
+		const char = input[index];
+		if (quote === "\"" && char === "\\") {
+			const next = input[index + 1];
+			if (next === undefined) return null;
+			value += next;
+			index += 2;
+			continue;
+		}
+		if (char === quote) return { value, nextIndex: index + 1 };
+		value += char;
+		index += 1;
+	}
+	return null;
+}
+
+function stripUnquotedInlineComment(line) {
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === "\"") {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === "\"") quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (char === "#") return line.slice(0, index);
+		index += 1;
+	}
+	return line;
+}
+
+function removeSections(config, shouldRemove) {
+	return splitSections(config)
+		.filter((section) => !shouldRemove(section))
+		.map((section) => section.text)
+		.join("")
+		.replace(/\n{3,}/g, "\n\n");
+}
+
+function splitSections(config) {
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	const sections = [];
+	let current = { header: null, text: "" };
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const header = tableHeader(line);
+		if (header !== null) {
+			if (current.text.length > 0) sections.push(current);
+			current = { header, text: line };
+		} else {
+			current = { ...current, text: current.text + line };
+		}
+	}
+	if (current.text.length > 0) sections.push(current);
+	return sections;
+}
+
+function tableHeader(line) {
+	const trimmed = stripUnquotedInlineComment(line).trim();
+	if (!trimmed.startsWith("[") || !trimmed.endsWith("]") || trimmed.startsWith("[[")) return null;
+	return trimmed;
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/multi-agent-mode-guard.mjs

@@ -0,0 +1,60 @@
+const MULTI_AGENT_MODE_KEY = "multi_agent_mode";
+
+export function removeUnsupportedRootMultiAgentMode(config) {
+	const lines = config.split(/\n/);
+	const output = [];
+	let inRoot = true;
+	let changed = false;
+	for (const line of lines) {
+		const sectionHeader = isSectionHeader(line);
+		if (inRoot && isRootSetting(line, MULTI_AGENT_MODE_KEY)) {
+			changed = true;
+			continue;
+		}
+		output.push(line);
+		if (sectionHeader) inRoot = false;
+	}
+	return changed ? output.join("\n") : config;
+}
+
+function isSectionHeader(line) {
+	const trimmed = stripUnquotedInlineComment(line).trim();
+	return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+
+function isRootSetting(line, key) {
+	const trimmed = line.trimStart();
+	if (trimmed.startsWith("#") || trimmed.startsWith("[")) return false;
+	const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+	return match?.[1] === key;
+}
+
+function stripUnquotedInlineComment(line) {
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === "\"") {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === "\"") quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (char === "#") return line.slice(0, index);
+		index += 1;
+	}
+	return line;
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/multi-agent-v2-guard.mjs

@@ -24,11 +24,10 @@ const MANAGED_DISABLE_COMMENT = [
 ].join("\n");
 
 export function forceDisableMultiAgentV2(config) {
-	let result = removeEnabledFeaturesShorthand(config);
+	let result = removeFeaturesShorthand(config);
 	const section = findSection(result, "[features.multi_agent_v2]");
 
 	if (!section) {
-		if (hasDisabledFeaturesShorthand(result)) return result;
 		return ensureManagedComment(appendDisabledSection(result));
 	}
 
@@ -53,23 +52,17 @@ function ensureManagedComment(config) {
 	return config.slice(0, section.start) + MANAGED_DISABLE_COMMENT + config.slice(section.start);
 }
 
-function removeEnabledFeaturesShorthand(config) {
+function removeFeaturesShorthand(config) {
 	const section = findSection(config, "[features]");
 	if (!section) return config;
 
-	const shorthandPattern = /^\s*multi_agent_v2\s*=\s*true[ \t]*(?:#[^\n]*)?[ \t]*\n?/m;
+	const shorthandPattern = /^\s*multi_agent_v2\s*=\s*(?:true|false)[ \t]*(?:#[^\n]*)?[ \t]*\n?/m;
 	if (!shorthandPattern.test(section.text)) return config;
 
 	const patched = section.text.replace(shorthandPattern, "");
 	return config.slice(0, section.start) + patched + config.slice(section.end);
 }
 
-function hasDisabledFeaturesShorthand(config) {
-	const section = findSection(config, "[features]");
-	if (!section) return false;
-	return /^\s*multi_agent_v2\s*=\s*false[ \t]*(?:#[^\n]*)?$/m.test(section.text);
-}
-
 function appendDisabledSection(config) {
 	const trimmed = config.trimEnd();
 	const prefix = trimmed.length === 0 ? "" : `${trimmed}\n\n`;

package/packages/omo-codex/plugin/scripts/migrate-codex-config/root-settings.mjs

@@ -62,7 +62,7 @@ function replaceOrInsertRootSetting(config, key, value) {
 }
 
 function isSectionHeader(line) {
-	const trimmed = line.trim();
+	const trimmed = stripUnquotedInlineComment(line).trim();
 	return trimmed.startsWith("[") && trimmed.endsWith("]");
 }
 
@@ -72,3 +72,33 @@ function isRootSetting(line, key) {
 	const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=/);
 	return match?.[1] === key;
 }
+
+function stripUnquotedInlineComment(line) {
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === "\"") {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === "\"") quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (char === "#") return line.slice(0, index);
+		index += 1;
+	}
+	return line;
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/subagent-limit-guard.mjs

@@ -0,0 +1,73 @@
+const CODEX_AGENTS_HEADER = "[agents]";
+const CODEX_MULTI_AGENT_V2_HEADER = "[features.multi_agent_v2]";
+const CODEX_SUBAGENT_THREAD_LIMIT = "1000";
+
+export function ensureSubagentConcurrencyLimit(config) {
+	return ensureMultiAgentV2ThreadLimit(ensureAgentsMaxThreads(config));
+}
+
+function ensureAgentsMaxThreads(config) {
+	const section = findSection(config, CODEX_AGENTS_HEADER);
+	if (!section) return appendBlock(config, `${CODEX_AGENTS_HEADER}\nmax_threads = ${CODEX_SUBAGENT_THREAD_LIMIT}\n`);
+	return replaceOrInsertSetting(config, section, "max_threads", CODEX_SUBAGENT_THREAD_LIMIT);
+}
+
+function ensureMultiAgentV2ThreadLimit(config) {
+	const section = findSection(config, CODEX_MULTI_AGENT_V2_HEADER);
+	if (!section) {
+		return appendBlock(
+			config,
+			`${CODEX_MULTI_AGENT_V2_HEADER}\nmax_concurrent_threads_per_session = ${CODEX_SUBAGENT_THREAD_LIMIT}\n`,
+		);
+	}
+	return replaceOrInsertSetting(config, section, "max_concurrent_threads_per_session", CODEX_SUBAGENT_THREAD_LIMIT);
+}
+
+function replaceOrInsertSetting(config, section, key, value) {
+	const pattern = new RegExp(`^(\\s*)${escapeRegExp(key)}\\s*=\\s*[^\\n#]*(#[^\\n]*)?$`, "m");
+	if (pattern.test(section.text)) {
+		const patched = section.text.replace(pattern, (_match, indent, comment) => comment ? `${indent}${key} = ${value} ${comment}` : `${indent}${key} = ${value}`);
+		return config.slice(0, section.start) + patched + config.slice(section.end);
+	}
+
+	const headerEnd = section.text.indexOf("\n");
+	const insertAt = headerEnd === -1 ? section.text.length : headerEnd + 1;
+	const patched = `${section.text.slice(0, insertAt)}${headerEnd === -1 ? "\n" : ""}${key} = ${value}\n${section.text.slice(insertAt)}`;
+	return config.slice(0, section.start) + patched + config.slice(section.end);
+}
+
+function appendBlock(config, block) {
+	const trimmed = config.trimEnd();
+	const prefix = trimmed.length === 0 ? "" : `${trimmed}\n\n`;
+	return `${prefix}${block}`;
+}
+
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function stripTrailingComment(line) {
+	const idx = line.indexOf("#");
+	return idx === -1 ? line : line.slice(0, idx).trim();
+}
+
+function findSection(config, headerLine) {
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let start = -1;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const trimmed = line.trim();
+		if (start === -1) {
+			if (stripTrailingComment(trimmed) === headerLine) start = offset;
+		} else {
+			const bare = stripTrailingComment(trimmed);
+			if (bare.startsWith("[") && bare.endsWith("]")) {
+				return { start, end: offset, text: config.slice(start, offset) };
+			}
+		}
+		offset += line.length;
+	}
+	if (start === -1) return null;
+	return { start, end: config.length, text: config.slice(start) };
+}