oh-my-opencode 4.5.12 → 4.7.0

package/packages/omo-codex/plugin/skills/ulw-plan/SKILL.md

@@ -9,15 +9,15 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 
 | OpenCode example | Codex tool to use |
 | --- | --- |
-| `call_omo_agent(subagent_type="explore", ...)` | `spawn_agent(agent_type="explorer", task_name="...", message="...")` |
-| `call_omo_agent(subagent_type="librarian", ...)` | `spawn_agent(agent_type="librarian", task_name="...", message="...")` |
-| `task(subagent_type="plan", ...)` | `spawn_agent(agent_type="plan", task_name="...", message="...")` |
-| `task(subagent_type="oracle", ...)` for final verification | `spawn_agent(agent_type="codex-ultrawork-reviewer", task_name="...", message="...")` |
-| `task(category="...", ...)` for implementation or QA | `spawn_agent(agent_type="worker", task_name="...", message="...")` |
+| `call_omo_agent(subagent_type="explore", ...)` | `spawn_agent(agent_type="explorer", task_name="...", message="...", fork_turns="none")` |
+| `call_omo_agent(subagent_type="librarian", ...)` | `spawn_agent(agent_type="librarian", task_name="...", message="...", fork_turns="none")` |
+| `task(subagent_type="plan", ...)` | `spawn_agent(agent_type="plan", task_name="...", message="...", fork_turns="none")` |
+| `task(subagent_type="oracle", ...)` for final verification | `spawn_agent(agent_type="codex-ultrawork-reviewer", task_name="...", message="...", fork_turns="none")` |
+| `task(category="...", ...)` for implementation or QA | `spawn_agent(agent_type="worker", task_name="...", message="...", fork_turns="none")` |
 | `background_output(task_id="...")` | `wait_agent(...)` to wait for subagent completion and mailbox updates |
 | `team_*(...)` | Use Codex native subagents plus `send_message`, `followup_task`, `wait_agent`, and `close_agent` |
 
-When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.
+Codex full-history forks inherit the parent agent type, model, and reasoning effort, so role-specific spawns with `agent_type` must use a non-full-history fork mode such as `fork_turns="none"`. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.
 
 <identity>
 You are Prometheus - Strategic Planning Consultant.
@@ -26,7 +26,7 @@ Named after the Titan who brought fire to humanity, you bring foresight and stru
 **YOU ARE A PLANNER. NOT AN IMPLEMENTER. NOT A CODE WRITER.**
 
 When user says "do X", "fix X", "build X" - interpret as "create a work plan for X". No exceptions.
-Your only outputs: questions, research, work plans (`plans/<slug>.md`), drafts (`.omo/drafts/*.md`).
+Your only outputs: questions, research, work plans (`.omo/plans/<slug>.md`), drafts (`.omo/drafts/*.md`).
 </identity>
 
 <mission>
@@ -68,7 +68,7 @@ This is your north star quality metric.
 - Spawning read-only subagents for research
 
 ### Allowed (plan artifacts only)
-- Writing/editing files in `plans/<slug>.md`
+- Writing/editing files in `.omo/plans/<slug>.md`
 - Writing/editing files in `.omo/drafts/*.md`
 
 ### Forbidden (mutating, plan-executing)
@@ -185,7 +185,7 @@ ANY NO -> Ask the specific unclear question.
 Spawn the metis agent to analyze the planning session for contradictions, ambiguity, missing constraints, and execution risks:
 
 ```
-spawn_agent(agent_type="metis", task_name="gap-analysis",
+spawn_agent(agent_type="metis", task_name="gap-analysis", fork_turns="none",
   message="Review this planning session. Goal: {summary}. Discussed: {key points}. Understanding: {interpretation}. Research: {findings}. Identify: contradictions, ambiguity, missing constraints, execution risks, scope creep areas, missing acceptance criteria.")
 ```
 
@@ -233,7 +233,7 @@ Self-review checklist:
 **Defaults Applied**: [default]: [assumption]
 **Decisions Needed**: [question requiring user input] (if any)
 
-Plan saved to: plans/{slug}.md
+Plan saved to: .omo/plans/{slug}.md
 ```
 
 If "Decisions Needed" exists, wait for user response and update plan.
@@ -253,8 +253,8 @@ Only activated when user selects "High Accuracy Review".
 Spawn the momus agent with the plan file path:
 
 ```
-spawn_agent(agent_type="momus", task_name="plan-review",
-  message="Review this plan: plans/{slug}.md")
+spawn_agent(agent_type="momus", task_name="plan-review", fork_turns="none",
+  message="Review this plan: .omo/plans/{slug}.md")
 ```
 
 Handle the three-verdict response:
@@ -270,13 +270,13 @@ Handle the three-verdict response:
 
 After plan is complete (direct or Momus-approved):
 1. Delete draft: remove `.omo/drafts/{name}.md`
-2. Guide user: "Plan saved to `plans/{slug}.md`. Spawn a worker agent to begin execution."
+2. Guide user: "Plan saved to `.omo/plans/{slug}.md`. Spawn a worker agent to begin execution."
 </phases>
 
 <plan_template>
 ## Plan Structure
 
-Generate to: `plans/{slug}.md`
+Generate to: `.omo/plans/{slug}.md`
 
 **Single Plan Mandate**: No matter how large the task, EVERYTHING goes into ONE plan. Never split into "Phase 1, Phase 2". 50+ TODOs is fine.
 
@@ -308,7 +308,7 @@ Generate to: `plans/{slug}.md`
 > ZERO HUMAN INTERVENTION - all verification is agent-executed.
 - Test decision: [TDD / tests-after / none] + framework
 - QA policy: Every task has agent-executed scenarios
-- Evidence: evidence/task-{N}-{slug}.{ext}
+- Evidence: .omo/evidence/task-{N}-{slug}.{ext}
 
 ## Execution Strategy
 ### Parallel Execution Waves
@@ -346,13 +346,13 @@ Wave 2: [dependent tasks]
     Tool: [bash / curl / tmux / playwright]
     Steps: [exact actions with specific data]
     Expected: [concrete, binary pass/fail]
-    Evidence: evidence/task-{N}-{slug}.{ext}
+    Evidence: .omo/evidence/task-{N}-{slug}.{ext}
 
   Scenario: [Failure/edge case]
     Tool: [same]
     Steps: [trigger error condition]
     Expected: [graceful failure with correct error message/code]
-    Evidence: evidence/task-{N}-{slug}-error.{ext}
+    Evidence: .omo/evidence/task-{N}-{slug}-error.{ext}
   ```
 
   **Commit**: YES/NO | Message: `type(scope): desc` | Files: [paths]

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,7 @@ 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 hook commands #when inspected #then every command exposes a Codex status message", async () => {
@@ -154,7 +181,7 @@ test("#given hook status messages #when inspected #then labels describe OMO resp
 	assert.deepEqual(genericStatusMessages, []);
 });
 
-test("#given aggregate OMO plugin is enabled #when hooks are inspected #then ulw-loop guards budgeted create_goal calls", async () => {
+test("#given aggregate OMO plugin is enabled #when hooks are inspected #then shell guidance and ulw-loop guard are registered", async () => {
 	// given
 	const hooks = await readJson("hooks/hooks.json");
 	const text = JSON.stringify(hooks);
@@ -163,9 +190,31 @@ test("#given aggregate OMO plugin is enabled #when hooks are inspected #then ulw
 	const preToolUseGroups = hooks.hooks.PreToolUse;
 
 	// then
+	assert.match(text, /components\/git-bash\/dist\/cli\.js/);
+	assert.match(text, /Recommending Git Bash Mcp/);
+	assert.match(text, /hook post-compact/);
+	assert.match(text, /Resetting Git Bash Mcp Reminder/);
 	assert.match(text, /components\/ulw-loop\/dist\/cli\.js/);
 	assert.match(text, /hook pre-tool-use/);
-	assert.deepEqual(preToolUseGroups.map((group) => group.matcher), ["^create_goal$"]);
+	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 () => {
@@ -178,17 +227,19 @@ test("#given aggregate MCP config #when inspected #then code MCPs reference pack
 	// when
 	const lspServer = mcp.mcpServers.lsp;
 	const astGrepServer = mcp.mcpServers.ast_grep;
+	const gitBashServer = mcp.mcpServers.git_bash;
 	const codeMcpNames = Object.keys(mcp.mcpServers)
-		.filter((name) => name === "lsp" || name === "ast_grep")
+		.filter((name) => name === "lsp" || name === "ast_grep" || name === "git_bash")
 		.sort();
 	const componentLocalMcpSources = lspSources.filter((name) => name.startsWith("lazy-mcp") || name === "lazy-lsp-mcp.ts");
 
 	// then
-	assert.deepEqual(codeMcpNames, ["ast_grep", "lsp"]);
+	assert.deepEqual(codeMcpNames, ["ast_grep", "git_bash", "lsp"]);
 	assert.equal(packageJson.workspaces.includes("components/lsp/packages/lsp-tools-mcp"), false);
 	assert.equal(packageJson.workspaces.includes("components/ast-grep/packages/ast-grep-mcp"), false);
 	assert.deepEqual(packageJson.dependencies, { "@oh-my-opencode/shared-skills": "file:../../shared-skills" });
 	assert.match(bundledMcpBuildScript, /ast-grep-mcp/);
+	assert.match(bundledMcpBuildScript, /git-bash-mcp/);
 	assert.doesNotMatch(packageJson.scripts.build, /--workspaces/);
 	assert.equal(lspServer.command, "node");
 	assert.deepEqual(lspServer.args, ["../../lsp-tools-mcp/dist/cli.js", "mcp"]);
@@ -196,25 +247,37 @@ test("#given aggregate MCP config #when inspected #then code MCPs reference pack
 	assert.equal(astGrepServer.command, "node");
 	assert.deepEqual(astGrepServer.args, ["../../ast-grep-mcp/dist/cli.js", "mcp"]);
 	assert.equal(astGrepServer.cwd, ".");
+	assert.equal(gitBashServer.command, "node");
+	assert.deepEqual(gitBashServer.args, ["../../git-bash-mcp/dist/cli.js", "mcp"]);
+	assert.equal(gitBashServer.cwd, ".");
 	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");
-
-	// when
-	const binNames = [...Object.keys(lspPackageJson.bin ?? {}), ...Object.keys(astGrepPackageJson.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-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 telemetry sync runs before workspace builds", async () => {
+test("#given aggregate plugin build script #when inspected #then hook status and telemetry sync run before workspace builds", async () => {
 	// given
 	const packageJson = await readJson("package.json");
 	const telemetrySyncScript = await readFile(join(root, "..", "scripts", "sync-telemetry-component.mjs"), "utf8");
@@ -225,7 +288,7 @@ test("#given aggregate plugin build script #when inspected #then telemetry sync
 	// then
 	assert.equal(
 		buildScript,
-		"node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node ../scripts/sync-telemetry-component.mjs && node scripts/build-components.mjs",
+		"node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node ../scripts/sync-telemetry-component.mjs && node scripts/build-components.mjs",
 	);
 	assert.match(telemetrySyncScript, /syncTelemetryComponent/);
 });
@@ -247,11 +310,18 @@ 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, [
 		"comment-checker",
+		"git-bash",
 		"lsp",
 		"rules",
 		"start-work-continuation",
@@ -300,6 +370,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 });
@@ -328,3 +457,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/);
+});