oh-my-opencode 4.6.0 → 4.7.1

package/packages/omo-codex/plugin/test/aggregate.test.mjs

@@ -5,17 +5,30 @@ import test from "node:test";
 import { fileURLToPath } from "node:url";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const mcpPackageManifestPaths = ["../../lsp-tools-mcp/package.json", "../../ast-grep-mcp/package.json", "../../git-bash-mcp/package.json"];
+const mcpPackageManifestExists = await Promise.all(mcpPackageManifestPaths.map(exists));
 
 async function readJson(relativePath) {
 	return JSON.parse(await readFile(join(root, relativePath), "utf8"));
 }
 
+async function exists(relativePath) {
+	try {
+		await stat(join(root, relativePath));
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
 async function readComponentHookManifests() {
 	const components = await readdir(join(root, "components"), { withFileTypes: true });
 	const manifests = [];
 	for (const entry of components) {
 		if (!entry.isDirectory()) continue;
 		const source = join("components", entry.name, "hooks", "hooks.json");
+		if (!(await exists(source))) continue;
 		manifests.push({ source, hooks: await readJson(source) });
 	}
 	return manifests.sort((left, right) => left.source.localeCompare(right.source));
@@ -57,6 +70,18 @@ function findSpawnAgentTypes(content) {
 	return [...agentTypes].sort();
 }
 
+function findRoleSpecificSpawnsWithoutForkTurnsNone(content) {
+	const missingForkTurns = [];
+	const regex = /spawn_agent\(agent_type="([^"]+)"[^)]*\)/g;
+	for (const match of content.matchAll(regex)) {
+		const call = match[0];
+		if (!call.includes('fork_turns="none"')) {
+			missingForkTurns.push(call);
+		}
+	}
+	return missingForkTurns;
+}
+
 test("#given aggregate plugin manifest #when inspected #then it owns the omo namespace", async () => {
 	// given
 	const manifest = await readJson(".codex-plugin/plugin.json");
@@ -99,6 +124,7 @@ test("#given isolated components #when hooks are inspected #then commands stay i
 		"components/telemetry/dist/cli.js",
 		"components/ulw-loop/dist/cli.js",
 		"components/ultrawork/dist/cli.js",
+		"scripts/auto-update.mjs",
 	];
 
 	// then
@@ -106,6 +132,23 @@ test("#given isolated components #when hooks are inspected #then commands stay i
 		assert.match(text, new RegExp(marker.replaceAll("/", "\\/")));
 	}
 	assert.doesNotMatch(text, /codex-(comment-checker|lsp|rules|telemetry|ulw-loop|ultrawork)@/);
+	assert.equal(await exists("scripts/migrate-codex-config.mjs"), true);
+});
+
+test("#given aggregate PostCompact hooks #when hooks are inspected #then LSP diagnostics cache reset is registered", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+
+	// when
+	const lspPostCompactHooks = collectCommandHooks(hooks, "hooks/hooks.json").filter(
+		(hook) =>
+			hook.eventName === "PostCompact" &&
+			hook.handler.command === 'node "${PLUGIN_ROOT}/components/lsp/dist/cli.js" hook post-compact',
+	);
+
+	// then
+	assert.equal(lspPostCompactHooks.length, 1);
+	assert.equal(lspPostCompactHooks[0]?.handler.statusMessage, "LazyCodex(0.1.0): Resetting LSP Diagnostics Cache");
 });
 
 test("#given aggregate hook commands #when inspected #then every command exposes a Codex status message", async () => {
@@ -172,6 +215,24 @@ test("#given aggregate OMO plugin is enabled #when hooks are inspected #then she
 	assert.deepEqual(preToolUseGroups.map((group) => group.matcher), ["^Bash$", "^create_goal$"]);
 });
 
+test("#given aggregate SessionStart hooks #when inspected #then LazyCodex auto-update is registered", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+	const text = JSON.stringify(hooks);
+
+	// when
+	const sessionStartCommands = collectCommandHooks(hooks, "hooks/hooks.json")
+		.filter(({ eventName }) => eventName === "SessionStart")
+		.map(({ handler }) => handler.command);
+	const autoUpdateGroup = hooks.hooks.SessionStart.find((group) => JSON.stringify(group).includes("scripts/auto-update.mjs"));
+
+	// then
+	assert.equal(autoUpdateGroup?.matcher, "^startup$");
+	assert.match(text, /scripts\/auto-update\.mjs/);
+	assert.match(text, /Checking Auto Update/);
+	assert(sessionStartCommands.some((command) => command.includes("scripts/auto-update.mjs")));
+});
+
 test("#given aggregate MCP config #when inspected #then code MCPs reference package runtimes without package names", async () => {
 	// given
 	const packageJson = await readJson("package.json");
@@ -208,25 +269,29 @@ test("#given aggregate MCP config #when inspected #then code MCPs reference pack
 	assert.deepEqual(componentLocalMcpSources, []);
 });
 
-test("#given package-level MCP CLIs #when package metadata is inspected #then bin names use the omo prefix", async () => {
-	// given
-	const lspPackageJson = await readJson("../../lsp-tools-mcp/package.json");
-	const astGrepPackageJson = await readJson("../../ast-grep-mcp/package.json");
-	const gitBashPackageJson = await readJson("../../git-bash-mcp/package.json");
-
-	// when
-	const binNames = [
-		...Object.keys(lspPackageJson.bin ?? {}),
-		...Object.keys(astGrepPackageJson.bin ?? {}),
-		...Object.keys(gitBashPackageJson.bin ?? {}),
-	].sort();
+test(
+	"#given package-level MCP CLIs #when package metadata is inspected #then bin names use the omo prefix",
+	{ skip: mcpPackageManifestExists.some((exists) => !exists) },
+	async () => {
+		// given
+		const [lspPackageJson, astGrepPackageJson, gitBashPackageJson] = await Promise.all(
+			mcpPackageManifestPaths.map((path) => readJson(path)),
+		);
 
-	// then
-	assert.deepEqual(binNames, ["omo-ast-grep", "omo-git-bash", "omo-lsp"]);
-	for (const name of binNames) {
-		assert.match(name, /^omo-/);
-	}
-});
+		// when
+		const binNames = [
+			...Object.keys(lspPackageJson.bin ?? {}),
+			...Object.keys(astGrepPackageJson.bin ?? {}),
+			...Object.keys(gitBashPackageJson.bin ?? {}),
+		].sort();
+
+		// then
+		assert.deepEqual(binNames, ["omo-ast-grep", "omo-git-bash", "omo-lsp"]);
+		for (const name of binNames) {
+			assert.match(name, /^omo-/);
+		}
+	},
+);
 
 test("#given aggregate plugin build script #when inspected #then hook status and telemetry sync run before workspace builds", async () => {
 	// given
@@ -261,7 +326,13 @@ test("#given component directories #when scanned #then only intentional resource
 	const expectedComponentManifests = new Map([["rules", { hooks: "./hooks/hooks.json" }]]);
 
 	// when
-	const componentNames = components.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+	const componentNames = [];
+	for (const entry of components) {
+		if (!entry.isDirectory()) continue;
+		if (!(await exists(join("components", entry.name, "package.json")))) continue;
+		componentNames.push(entry.name);
+	}
+	componentNames.sort();
 
 	// then
 	assert.deepEqual(componentNames, [
@@ -315,6 +386,65 @@ test("#given bundled Codex agents #when components/ultrawork/agents directory is
 	}
 });
 
+test("#given planner agent prompt #when inspected #then generated artifacts stay under .omo", async () => {
+	const prompt = await readFile(join(root, "components", "ultrawork", "agents", "plan.toml"), "utf8");
+
+	assert.match(prompt, /\.omo\/plans\/<slug>\.md/);
+	assert.match(prompt, /\.omo\/evidence\/task-<N>-<slug>\.<ext>/);
+	assert.doesNotMatch(prompt, /(?<!\.omo\/)plans\/<slug>\.md/);
+	assert.doesNotMatch(prompt, /(?<!\.omo\/)evidence\/task-/);
+});
+
+test("#given reviewer agent prompt #when inspected #then default model is ChatGPT-account compatible", async () => {
+	const prompt = await readFile(
+		join(root, "components", "ultrawork", "agents", "codex-ultrawork-reviewer.toml"),
+		"utf8",
+	);
+
+	assert.match(prompt, /^model\s*=\s*"gpt-5\.5"$/m);
+	assert.match(prompt, /^model_reasoning_effort\s*=\s*"xhigh"$/m);
+	assert.doesNotMatch(prompt, /^model\s*=\s*"gpt-5\.2"$/m);
+	assert.match(prompt, /ChatGPT account/);
+});
+
+test("#given bundled model catalog #when inspected #then default verifier and worker roles are pinned", async () => {
+	const catalog = JSON.parse(await readFile(join(root, "model-catalog.json"), "utf8"));
+
+	assert.equal(catalog.current.model, "gpt-5.5");
+	assert.equal(catalog.current.model_context_window, 400000);
+	assert.equal(catalog.current.model_reasoning_effort, "high");
+	assert.equal(catalog.current.plan_mode_reasoning_effort, "xhigh");
+	assert.deepEqual(catalog.roles.default, catalog.current);
+	assert.deepEqual(catalog.roles.verifier, {
+		model: "gpt-5.5",
+		model_reasoning_effort: "xhigh",
+	});
+	assert.deepEqual(catalog.roles.worker, {
+		model: "gpt-5.4",
+		model_reasoning_effort: "high",
+	});
+});
+
+test("#given Codex-facing orchestration surfaces #when inspected #then retired ChatGPT-account model names are not recommended", async () => {
+	const promptFiles = [
+		join(root, "skills", "ulw-loop", "references", "full-workflow.md"),
+		join(root, "components", "ulw-loop", "skills", "ulw-loop", "references", "full-workflow.md"),
+		join(root, "components", "ultrawork", "README.md"),
+		join(root, "components", "ultrawork", "CHANGELOG.md"),
+		join(root, "components", "rules", "src", "post-compact-budget.ts"),
+	];
+
+	const staleReferences = [];
+	for (const promptPath of promptFiles) {
+		const content = await readFile(promptPath, "utf8");
+		if (/gpt-5\.(?:2|3-codex)/i.test(content)) {
+			staleReferences.push(`${basename(dirname(promptPath))}/${basename(promptPath)}`);
+		}
+	}
+
+	assert.deepEqual(staleReferences, []);
+});
+
 test("#given synced skills with Codex compatibility guidance #when a bundled agent_type is referenced #then a matching TOML is bundled", async () => {
 	const skillsDir = join(root, "skills");
 	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
@@ -343,3 +473,42 @@ test("#given synced skills with Codex compatibility guidance #when a bundled age
 		assert.equal(basename(tomlPath), `${agentType}.toml`);
 	}
 });
+
+test('#given synced skills and bundled rules #when role-specific agents are spawned #then they set fork_turns="none"', async () => {
+	const skillsDir = join(root, "skills");
+	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
+	const promptFiles = skillEntries
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => join(skillsDir, entry.name, "SKILL.md"));
+	promptFiles.push(join(root, "components", "rules", "bundled-rules", "hephaestus.md"));
+
+	const missingForkTurns = [];
+	for (const promptPath of promptFiles) {
+		const content = await readFile(promptPath, "utf8");
+		for (const call of findRoleSpecificSpawnsWithoutForkTurnsNone(content)) {
+			missingForkTurns.push(`${basename(dirname(promptPath))}/${basename(promptPath)}: ${call}`);
+		}
+	}
+
+	assert.deepEqual(missingForkTurns, []);
+});
+
+test("#given long-running orchestration prompts #when waiting on child agents #then parent liveness is surfaced", async () => {
+	const promptFiles = [
+		join(root, "skills", "ulw-loop", "SKILL.md"),
+		join(root, "skills", "ulw-loop", "references", "full-workflow.md"),
+		join(root, "skills", "review-work", "SKILL.md"),
+		join(root, "skills", "start-work", "SKILL.md"),
+		join(root, "components", "rules", "bundled-rules", "hephaestus.md"),
+	];
+
+	const missingLivenessGuidance = [];
+	for (const promptPath of promptFiles) {
+		const content = await readFile(promptPath, "utf8");
+		if (!content.includes("active subagent count") || !content.includes("last heartbeat")) {
+			missingLivenessGuidance.push(`${basename(dirname(promptPath))}/${basename(promptPath)}`);
+		}
+	}
+
+	assert.deepEqual(missingLivenessGuidance, []);
+});

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

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { resolveAutoUpdatePlan, runAutoUpdateCheck } from "../scripts/auto-update.mjs";
+
+test("#given auto update is disabled #when resolving plan #then no command is scheduled", () => {
+	const plan = resolveAutoUpdatePlan({
+		env: { LAZYCODEX_AUTO_UPDATE_DISABLED: "1" },
+		now: 1_000,
+		lastCheckedAt: 0,
+	});
+
+	assert.equal(plan.shouldRun, false);
+	assert.equal(plan.reason, "disabled");
+});
+
+test("#given stale state #when resolving plan #then installer update command is scheduled", () => {
+	const plan = resolveAutoUpdatePlan({
+		env: {},
+		now: 90_000_000,
+		lastCheckedAt: 0,
+	});
+
+	assert.equal(plan.shouldRun, true);
+	assert.deepEqual(plan.command, "npx");
+	assert.deepEqual(plan.args, ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--skip-auth"]);
+});
+
+test("#given recent state #when resolving plan #then update is throttled", () => {
+	const plan = resolveAutoUpdatePlan({
+		env: {},
+		now: 90_000_000,
+		lastCheckedAt: 89_999_000,
+	});
+
+	assert.equal(plan.shouldRun, false);
+	assert.equal(plan.reason, "throttled");
+});
+
+test("#given test command override #when running check #then records state and launches command", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-"));
+	const logPath = join(root, "spawn.log");
+	const statePath = join(root, "state.json");
+	const codexHome = join(root, "codex-home");
+
+	const result = await runAutoUpdateCheck({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
+			LAZYCODEX_AUTO_UPDATE_STATE_PATH: statePath,
+			LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "0",
+			LAZYCODEX_AUTO_UPDATE_COMMAND: process.execPath,
+			LAZYCODEX_AUTO_UPDATE_ARGS_JSON: JSON.stringify(["-e", `require("node:fs").writeFileSync(${JSON.stringify(logPath)}, "ok")`]),
+			LAZYCODEX_AUTO_UPDATE_WAIT: "1",
+		},
+		now: 123_456,
+	});
+
+	assert.equal(result.started, true);
+	assert.equal(JSON.parse(await readFile(statePath, "utf8")).lastCheckedAt, 123_456);
+	assert.equal(await readFile(logPath, "utf8"), "ok");
+	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /model = "gpt-5\.5"/);
+});
+
+test("#given active lock #when running check #then skips concurrent update", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-lock-"));
+	const statePath = join(root, "state.json");
+	const lockPath = join(root, "state.json.lock");
+	const codexHome = join(root, "codex-home");
+	await writeFile(lockPath, "locked\n");
+
+	const result = await runAutoUpdateCheck({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
+			LAZYCODEX_AUTO_UPDATE_STATE_PATH: statePath,
+			LAZYCODEX_AUTO_UPDATE_LOCK_PATH: lockPath,
+			LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "0",
+			LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS: "600000",
+		},
+		now: 123_456,
+	});
+
+	assert.equal(result.started, false);
+	assert.equal(result.reason, "locked");
+	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /model_context_window = 400000/);
+});
+
+test("#given throttled updater and stale Codex config #when running check #then config migration still runs", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-migration-"));
+	const statePath = join(root, "state.json");
+	const codexHome = join(root, "codex-home");
+	await writeFile(statePath, JSON.stringify({ lastCheckedAt: 99_999 }, null, 2));
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		join(codexHome, "config.toml"),
+		[
+			'model = "gpt-5.2"',
+			"model_context_window = 272000",
+			'model_reasoning_effort = "low"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+			"[features]",
+			"plugins = true",
+			"",
+		].join("\n"),
+	);
+
+	const result = await runAutoUpdateCheck({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
+			LAZYCODEX_AUTO_UPDATE_STATE_PATH: statePath,
+		},
+		now: 100_000,
+	});
+
+	const content = await readFile(join(codexHome, "config.toml"), "utf8");
+	assert.equal(result.started, false);
+	assert.equal(result.reason, "throttled");
+	assert.match(content, /model = "gpt-5\.5"/);
+	assert.match(content, /model_context_window = 400000/);
+	assert.match(content, /model_reasoning_effort = "high"/);
+	assert.match(content, /plan_mode_reasoning_effort = "xhigh"/);
+	assert.doesNotMatch(content, /gpt-5\.2/);
+});

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

@@ -15,6 +15,7 @@ const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const AGGREGATE_EXPECTED_LABELS = new Map([
 	["hooks/hooks.json:SessionStart:0:0", "Loading Project Rules"],
 	["hooks/hooks.json:SessionStart:1:0", "Recording Session Telemetry"],
+	["hooks/hooks.json:SessionStart:2:0", "Checking Auto Update"],
 	["hooks/hooks.json:UserPromptSubmit:0:0", "Loading Project Rules"],
 	["hooks/hooks.json:UserPromptSubmit:1:0", "Checking Ultrawork Trigger"],
 	["hooks/hooks.json:UserPromptSubmit:2:0", "Checking Ulw-Loop Steering"],
@@ -23,6 +24,7 @@ const AGGREGATE_EXPECTED_LABELS = new Map([
 	["hooks/hooks.json:PostToolUse:0:1", "Checking LSP Diagnostics"],
 	["hooks/hooks.json:PostToolUse:1:0", "Matching Project Rules"],
 	["hooks/hooks.json:PostCompact:0:0", "Resetting Project Rule Cache"],
+	["hooks/hooks.json:PostCompact:2:0", "Resetting LSP Diagnostics Cache"],
 	["hooks/hooks.json:Stop:0:0", "Checking Start-Work Continuation"],
 	["hooks/hooks.json:SubagentStop:0:0", "Checking Start-Work Continuation"],
 ]);
@@ -30,6 +32,7 @@ const AGGREGATE_EXPECTED_LABELS = new Map([
 const COMPONENT_EXPECTED_LABELS = new Map([
 	["components/comment-checker/hooks/hooks.json:PostToolUse:0:0", "Checking Comments"],
 	["components/lsp/hooks/hooks.json:PostToolUse:0:0", "Checking LSP Diagnostics"],
+	["components/lsp/hooks/hooks.json:PostCompact:0:0", "Resetting LSP Diagnostics Cache"],
 	["components/rules/hooks/hooks.json:SessionStart:0:0", "Loading Project Rules"],
 	["components/rules/hooks/hooks.json:UserPromptSubmit:0:0", "Loading Project Rules"],
 	["components/rules/hooks/hooks.json:PostToolUse:0:0", "Matching Project Rules"],
@@ -69,25 +72,6 @@ async function readComponentHookManifests() {
 	return manifests.sort((left, right) => left.source.localeCompare(right.source));
 }
 
-async function readComponentVersions() {
-	const components = await readdir(join(root, "components"), { withFileTypes: true });
-	const versions = new Map();
-	for (const entry of components) {
-		if (!entry.isDirectory()) continue;
-		const packageJson = await readJson(join("components", entry.name, "package.json"));
-		versions.set(entry.name, packageJson.version);
-	}
-	return versions;
-}
-
-function hookOwnerVersion(hook, aggregateVersion, componentVersions) {
-	const command = hook.command;
-	for (const [componentName, version] of componentVersions.entries()) {
-		if (command.includes(`/components/${componentName}/dist/cli.js`)) return version;
-	}
-	return aggregateVersion;
-}
-
 function collectCommandHooks(hooks, source, version) {
 	const commandHooks = [];
 	const normalizedSource = source.replaceAll("\\", "/");
@@ -147,15 +131,15 @@ test("#given loose legacy status label #when normalizing #then removes OMO wordi
 
 test("#given aggregate comment-checker hook #when status is inspected #then it uses LazyCodex comments label", async () => {
 	// given
+	const aggregateVersion = (await readJson(".codex-plugin/plugin.json")).version;
 	const aggregateHooks = await readJson("hooks/hooks.json");
-	const componentVersions = await readComponentVersions();
 
 	// when
-	const hooks = collectCommandHooks(aggregateHooks, "hooks/hooks.json", "0.1.0");
+	const hooks = collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion);
 	const commentCheckerHook = hooks.find((hook) => hook.id === "hooks/hooks.json:PostToolUse:0:0");
 
 	// then
-	assert.equal(commentCheckerHook?.statusMessage, formatLazyCodexHookStatusMessage(componentVersions.get("comment-checker"), "Checking Comments"));
+	assert.equal(commentCheckerHook?.statusMessage, formatLazyCodexHookStatusMessage(aggregateVersion, "Checking Comments"));
 	assert.doesNotMatch(JSON.stringify(aggregateHooks), /checking\s+OMO\s+comments/i);
 });
 
@@ -164,14 +148,10 @@ test("#given aggregate and component hooks #when status messages are inspected #
 	const aggregateVersion = (await readJson(".codex-plugin/plugin.json")).version;
 	const aggregateHooks = await readJson("hooks/hooks.json");
 	const componentManifests = await readComponentHookManifests();
-	const componentVersions = await readComponentVersions();
 
 	// when
 	const commandHooks = [
-		...collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion).map((hook) => ({
-			...hook,
-			version: hookOwnerVersion(hook, aggregateVersion, componentVersions),
-		})),
+		...collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion),
 		...componentManifests.flatMap((manifest) => collectCommandHooks(manifest.hooks, manifest.source, manifest.version)),
 	];
 	const expectedLabels = new Map([...AGGREGATE_EXPECTED_LABELS, ...COMPONENT_EXPECTED_LABELS]);

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

@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+
+import { ensureCodexReasoningConfig, migrateCodexConfig } from "../scripts/migrate-codex-config.mjs";
+
+test("#given stale root reasoning config #when ensuring config #then replaces stale values without duplicate keys", () => {
+	const result = ensureCodexReasoningConfig(
+		[
+			'model = "gpt-5.2"',
+			"model_context_window = 272000",
+			'model_reasoning_effort = "low"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+			"[features]",
+			"plugins = true",
+			"",
+		].join("\n"),
+	);
+
+	assert.equal(result.match(/^model\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^model_context_window\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^model_reasoning_effort\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^plan_mode_reasoning_effort\s*=/gm)?.length, 1);
+	assert.match(result, /model = "gpt-5\.5"/);
+	assert.match(result, /model_context_window = 400000/);
+	assert.match(result, /model_reasoning_effort = "high"/);
+	assert.match(result, /plan_mode_reasoning_effort = "xhigh"/);
+	assert.doesNotMatch(result, /gpt-5\.2/);
+	assert.match(result, /\[features\]/);
+});
+
+test("#given global and project-local stale Codex configs #when migrating #then both configs are forced to current defaults", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-migration-"));
+	const codexHome = join(root, "codex-home");
+	const project = join(root, "project", "nested");
+	const projectConfig = join(root, "project", ".codex", "config.toml");
+	await mkdir(codexHome, { recursive: true });
+	await mkdir(dirname(projectConfig), { recursive: true });
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.2"\n');
+	await writeFile(projectConfig, 'model = "gpt-5.2"\nmodel_context_window = 272000\n');
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: project,
+	});
+
+	assert.deepEqual(result.changed.sort(), [join(codexHome, "config.toml"), projectConfig].sort());
+	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /model = "gpt-5\.5"/);
+	assert.match(await readFile(projectConfig, "utf8"), /model_context_window = 400000/);
+});
+
+test("#given user-customized Codex model config #when migrating #then user values are preserved", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-custom-"));
+	const codexHome = join(root, "codex-home");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		join(codexHome, "config.toml"),
+		[
+			'model = "gpt-5.4"',
+			"model_context_window = 123456",
+			'model_reasoning_effort = "medium"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+		].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(join(codexHome, "config.toml"), "utf8");
+	assert.deepEqual(result.changed, []);
+	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"/);
+});
+
+test("#given managed catalog state #when catalog version advances #then only previously managed config is updated", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-catalog-state-"));
+	const codexHome = join(root, "codex-home");
+	const catalogPath = join(root, "catalog.json");
+	const statePath = join(root, "model-state.json");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		catalogPath,
+		JSON.stringify(
+			{
+				version: "test.v1",
+				current: {
+					model: "gpt-5.4",
+					model_context_window: 1000000,
+					model_reasoning_effort: "high",
+					plan_mode_reasoning_effort: "xhigh",
+				},
+				managedProfiles: [],
+			},
+			null,
+			2,
+		),
+	);
+
+	const first = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: catalogPath,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: statePath,
+		},
+		cwd: root,
+	});
+	await writeFile(
+		catalogPath,
+		JSON.stringify(
+			{
+				version: "test.v2",
+				current: {
+					model: "gpt-5.5",
+					model_context_window: 400000,
+					model_reasoning_effort: "high",
+					plan_mode_reasoning_effort: "xhigh",
+				},
+				managedProfiles: [],
+			},
+			null,
+			2,
+		),
+	);
+	const second = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: catalogPath,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: statePath,
+		},
+		cwd: root,
+	});
+
+	const content = await readFile(join(codexHome, "config.toml"), "utf8");
+	assert.deepEqual(first.changed, [join(codexHome, "config.toml")]);
+	assert.deepEqual(second.changed, [join(codexHome, "config.toml")]);
+	assert.match(content, /model = "gpt-5\.5"/);
+	assert.match(content, /model_context_window = 400000/);
+});