oh-my-opencode 4.6.0 → 4.7.0

package/packages/omo-codex/plugin/skills/review-work/SKILL.md

@@ -8,15 +8,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.
 
 ## Codex Subagent Reliability
 
@@ -28,7 +28,7 @@ handoff. Role selection requires `agent_type`; `model` +
 worker. Prefer `fork_turns: "none"` unless full history is truly
 required; paste only the review context that worker needs.
 
-Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them. While any child is active, keep the parent visibly alive with brief status updates that include active subagent count, agent names, last heartbeat, and whether the parent is waiting for mailbox updates.
 
 Use `wait_agent` for completion signals, but treat `wait_agent` as a
 mailbox signal, not proof of completion, content, or errors. After two

package/packages/omo-codex/plugin/skills/start-work/SKILL.md

@@ -9,11 +9,11 @@ This skill ports the OpenCode `/start-work` flow onto Codex. Any OpenCode-only t
 
 | OpenCode example | Codex tool to use |
 | --- | --- |
-| `task(subagent_type="explore", ...)` | `spawn_agent(agent_type="explorer", task_name="...", message="...")` |
-| `task(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="...")` |
+| `task(subagent_type="explore", ...)` | `spawn_agent(agent_type="explorer", task_name="...", message="...", fork_turns="none")` |
+| `task(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(...)` |
 | `dispatchInternalPrompt(...)` | the `Stop` hook emits `{"decision":"block","reason":"<prompt>"}` automatically; see Continuation |
 | `team_*(...)` | `spawn_agent` + `send_message` + `followup_task` + `wait_agent` + `close_agent` |
@@ -30,7 +30,7 @@ handoff. Role selection requires `agent_type`; `model` +
 worker. Prefer `fork_turns: "none"` unless full history is truly
 required; paste only the context the child needs.
 
-Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them. While any child is active, keep the parent visibly alive with brief status updates that include active subagent count, agent names, last heartbeat, and whether the parent is waiting for mailbox updates.
 
 Use `wait_agent` for completion signals, but treat `wait_agent` as a
 mailbox signal, not proof of completion, content, or errors. After two

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

@@ -25,6 +25,7 @@ This Codex skill is intentionally compact to avoid adding a large operating manu
 - Delegate code edits, test writes, fixes, and QA execution to right-sized Codex subagents when the workflow requires it.
 - Every `spawn_agent` message starts with `TASK:`, then names `DELIVERABLE`, `SCOPE`, and `VERIFY`; role selection requires `agent_type`, while `model` + `reasoning_effort` alone creates a default agent, not a reviewer or worker; prefer `fork_turns: "none"` unless full history is truly required.
 - Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+- While any child is active, keep the parent visibly alive with brief status updates that include active subagent count, agent names, last heartbeat, and whether the parent is waiting for mailbox updates.
 - Avoid `list_agents` as a polling or status tool in large runs; it can replay large agent status and latest-message payloads. Track spawned agent names locally, use `wait_agent` for completion signals, targeted followups only when needed, and `close_agent` after integrating each result.
 - Treat `wait_agent` as a mailbox signal, not proof of completion, content, or errors. After two waits with no substantive result, send one targeted followup, then record inconclusive and respawn a smaller `fork_turns: "none"` task if the child stays silent or ack-only.
 
@@ -34,10 +35,10 @@ The full workflow may mention OpenCode-style orchestration examples. In Codex, t
 
 | Workflow intent | Codex tool |
 | --- | --- |
-| Plan agent | `spawn_agent(agent_type="plan", ...)` |
-| Search/read-only worker | `spawn_agent(agent_type="explorer", ...)` |
-| Implementation or QA worker | `spawn_agent(agent_type="worker", ...)` |
-| Final verification reviewer | `spawn_agent(agent_type="codex-ultrawork-reviewer", ...)` |
+| Plan agent | `spawn_agent(agent_type="plan", fork_turns="none", ...)` |
+| Search/read-only worker | `spawn_agent(agent_type="explorer", fork_turns="none", ...)` |
+| Implementation or QA worker | `spawn_agent(agent_type="worker", fork_turns="none", ...)` |
+| Final verification reviewer | `spawn_agent(agent_type="codex-ultrawork-reviewer", fork_turns="none", ...)` |
 | Wait for background result | `wait_agent(...)` |
 | Clean up finished worker | `close_agent(...)` |
 

package/packages/omo-codex/plugin/skills/ulw-loop/references/full-workflow.md

@@ -33,9 +33,9 @@ Size each worker to the task — never spend `xhigh` on a one-liner, never send
 | Task shape | agent_type | model | reasoning_effort |
 |---|---|---|---|
 | Trivial / mechanical (rename, move, obvious one-liner, config edit) | `worker` | `gpt-5.4-mini` | `low` |
-| Pure implementation against a clear spec (new function, endpoint, test from a named pattern) | `worker` | `gpt-5.3-codex` | `high` |
+| Pure implementation against a clear spec (new function, endpoint, test from a named pattern) | `worker` | `gpt-5.4` | `high` |
 | Deep debugging / race / perf / subtle cross-module reasoning | `worker` | `gpt-5.5` | `xhigh` |
-| QA execution (drive a channel, capture evidence) | `worker` | `gpt-5.3-codex` | `high` |
+| QA execution (drive a channel, capture evidence) | `worker` | `gpt-5.4` | `high` |
 | Read-only codebase search | `explorer` | role default | role default |
 | External library / docs research | `librarian` | role default | role default |
 | Final verification audit | `codex-ultrawork-reviewer` | role default | role default |
@@ -48,6 +48,7 @@ Codex subagent reliability:
 - Start every `spawn_agent` message with `TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and `VERIFY`. State that it is an executable assignment, not a context handoff.
 - Prefer `fork_turns: "none"` unless full history is truly required; paste only the context the child needs. Full-history forks can make the child continue old parent context instead of the delegated task.
 - Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+- While any child is active, keep the parent visibly alive with brief status updates that include active subagent count, agent names, last heartbeat, and whether the parent is waiting for mailbox updates.
 - Do not use `list_agents` as a polling or status tool in long or high-context runs; it can replay large agent status and latest-message payloads. Track spawned agent names locally, use `wait_agent` for completion signals, targeted followups only when needed, and `close_agent` after integrating each result.
 - Treat `wait_agent` as a mailbox signal, not proof of completion, content, or errors. After two waits with no substantive result, send one targeted followup: `TASK STILL ACTIVE: return <deliverable> or BLOCKED: <reason>`. If still silent or ack-only, record inconclusive, do not count it as pass/review approval, close if safe, and respawn a smaller `fork_turns: "none"` task with the missing deliverable.
 
@@ -147,7 +148,7 @@ Loop per goal. Cap at 5 cycles per goal. Cap identical same-criterion failures a
 2. Register atomic todos: `path: <action> for <criterion> - verify by <check>`.
 3. DELEGATE-IN-PARALLEL: dispatch every independent task in the wave at once via right-sized `spawn_agent` workers (Delegation table). Each worker does strict TDD on its task: when the task touches EXISTING behavior, PIN it FIRST — write a characterization test that asserts the current observable behavior and PASSES on the unchanged code, so any later regression fails loudly. Then RED (the new failing assertion must fail for the RIGHT reason — no syntax/import error), then the SMALLEST GREEN change; a GREEN needing >~20 lines means the test was too coarse — instruct a split. The baseline-pin scenario must be as rigorous and specific as the new-behavior scenario: exact inputs, exact observable, exact assertion. Serialize only on a NAMED dependency.
 4. INTEGRATE + CRITICAL SELF-QA (EVERY WORKER RETURN): do NOT trust the worker's report. Read the diff yourself, re-run its tests, and run LSP diagnostics on the changed files. Treat "done" as a claim to disprove. If the diff drifts, the test is hollow, or evidence is missing, RESPAWN the worker with the specific failure context. Forward every finding/learning to subsequent workers.
-5. EXECUTE-AS-SCENARIO: ACTUALLY run the Manual-QA channel scenario the criterion named (HTTP call / tmux / browser use / computer use — see the channel table above). Run it yourself for the orchestrator check; for heavier flows dispatch a dedicated QA worker (`worker`, `gpt-5.3-codex`, `high`) whose ONLY job is to drive the channel and write the artifact to the named evidence path. The unit suite being green is NEVER substitute. If the scenario FAILS, respawn the implementing worker with the captured failure — do not hand-patch around it.
+5. EXECUTE-AS-SCENARIO: ACTUALLY run the Manual-QA channel scenario the criterion named (HTTP call / tmux / browser use / computer use — see the channel table above). Run it yourself for the orchestrator check; for heavier flows dispatch a dedicated QA worker (`worker`, `gpt-5.4`, `high`) whose ONLY job is to drive the channel and write the artifact to the named evidence path. The unit suite being green is NEVER substitute. If the scenario FAILS, respawn the implementing worker with the captured failure — do not hand-patch around it.
 6. CAPTURE: collect the observable artifact path: transcript, stdout, screenshot, assertion, status+body, diff, or parsed dump. No artifact written at the evidence path — not done; record BLOCKED and respawn QA.
 7. CLEAN (PAIRED, NEVER SKIP): tear down every runtime artifact step 5 spawned BEFORE recording — server PIDs (`kill`, verify `kill -0` fails), `tmux` sessions (`tmux kill-session -t ulw-qa-<criterion>`; confirm `tmux ls`), browser / Playwright contexts (`.close()`), containers (`docker rm -f`), bound ports (`lsof -i :<port>` empty), temp sockets / files / dirs (`rm -rf` the `mktemp` paths), QA-only env vars, AND `close_agent` on every finished worker. Register each teardown as its own todo the moment the QA spawns the resource (scripts, tmux assets, browsers / agent-browser sessions, PIDs, ports) so none is forgotten. Embed a one-line cleanup receipt in the evidence string, e.g. `cleanup: killed 12345; tmux kill-session ulw-qa-foo; rm -rf /tmp/ulw.aB12cD; close_agent w-3`. Missing receipt → record BLOCKED, not PASS.
 8. RECORD exactly one result:

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 () => {
@@ -172,6 +199,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 +253,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 +310,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 +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 });
@@ -343,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/);
+});

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"],
@@ -74,6 +75,7 @@ async function readComponentVersions() {
 	const versions = new Map();
 	for (const entry of components) {
 		if (!entry.isDirectory()) continue;
+		if (!(await exists(join("components", entry.name, "package.json")))) continue;
 		const packageJson = await readJson(join("components", entry.name, "package.json"));
 		versions.set(entry.name, packageJson.version);
 	}