oh-my-opencode 4.5.12 → 4.7.0

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

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
+
+const FALLBACK_CATALOG = {
+	version: "fallback.gpt-5.5-400k",
+	current: {
+		model: "gpt-5.5",
+		model_context_window: 400_000,
+		model_reasoning_effort: "high",
+		plan_mode_reasoning_effort: "xhigh",
+	},
+	roles: {
+		default: {
+			model: "gpt-5.5",
+			model_context_window: 400_000,
+			model_reasoning_effort: "high",
+			plan_mode_reasoning_effort: "xhigh",
+		},
+		verifier: { model: "gpt-5.5", model_reasoning_effort: "xhigh" },
+		worker: { model: "gpt-5.4", model_reasoning_effort: "high" },
+	},
+	managedProfiles: [
+		{ version: "legacy.gpt-5.2", match: { model: "gpt-5.2" } },
+		{
+			version: "legacy.gpt-5.4-1m",
+			match: {
+				model: "gpt-5.4",
+				model_context_window: 1_000_000,
+				model_reasoning_effort: "high",
+				plan_mode_reasoning_effort: "xhigh",
+			},
+		},
+	],
+};
+
+const MANAGED_KEYS = ["model", "model_context_window", "model_reasoning_effort", "plan_mode_reasoning_effort"];
+
+export async function migrateCodexConfig({ env = process.env, cwd = process.cwd() } = {}) {
+	const catalog = await readModelCatalog(env);
+	const statePath = resolveStatePath(env);
+	const state = await readState(statePath);
+	const paths = await configPaths({ env, cwd });
+	const changed = [];
+	const nextState = { catalogVersion: catalog.version, files: {} };
+	for (const configPath of paths) {
+		const result = await migrateConfigFile(configPath, {
+			catalog,
+			previousState: state.files?.[configPath],
+		});
+		if (result.changed) changed.push(configPath);
+		nextState.files[configPath] = {
+			catalogVersion: catalog.version,
+			written: result.written,
+			managed: result.managed,
+		};
+	}
+	await writeState(statePath, nextState);
+	return { changed };
+}
+
+export async function migrateConfigFile(configPath, { catalog = FALLBACK_CATALOG, previousState } = {}) {
+	const before = await readConfig(configPath);
+	const decision = shouldApplyCatalog(before, catalog, previousState);
+	if (!decision.apply) return { changed: false, written: readRootSettings(before), managed: false };
+	const after = ensureCodexReasoningConfig(before, catalog.current);
+	if (after === before) return { changed: false, written: catalog.current, managed: true };
+	await mkdir(dirname(configPath), { recursive: true });
+	await writeFile(configPath, `${after.trimEnd()}\n`);
+	return { changed: true, written: catalog.current, managed: true };
+}
+
+export function ensureCodexReasoningConfig(config, profile = FALLBACK_CATALOG.current) {
+	let next = replaceOrInsertRootSetting(config, "model", JSON.stringify(profile.model));
+	next = replaceOrInsertRootSetting(next, "model_context_window", profile.model_context_window.toString());
+	next = replaceOrInsertRootSetting(next, "model_reasoning_effort", JSON.stringify(profile.model_reasoning_effort));
+	next = replaceOrInsertRootSetting(next, "plan_mode_reasoning_effort", JSON.stringify(profile.plan_mode_reasoning_effort));
+	return next;
+}
+
+export async function readModelCatalog(env = process.env) {
+	const catalogPath = env.LAZYCODEX_MODEL_CATALOG_PATH?.trim() || join(dirname(fileURLToPath(import.meta.url)), "..", "model-catalog.json");
+	try {
+		return parseCatalog(JSON.parse(await readFile(catalogPath, "utf8"))) ?? FALLBACK_CATALOG;
+	} catch (error) {
+		if (error instanceof Error) return FALLBACK_CATALOG;
+		throw error;
+	}
+}
+
+function shouldApplyCatalog(config, catalog, previousState) {
+	const current = readRootSettings(config);
+	if (Object.keys(current).length === 0) return { apply: true, reason: "empty" };
+	if (matchesProfile(current, catalog.current)) return { apply: false, reason: "current" };
+	if (previousState?.managed === true && matchesProfile(current, previousState.written)) {
+		return { apply: true, reason: "managed-state" };
+	}
+	for (const profile of catalog.managedProfiles) {
+		if (matchesProfile(current, profile.match)) return { apply: true, reason: profile.version };
+	}
+	return { apply: false, reason: "user-modified" };
+}
+
+function matchesProfile(current, profile) {
+	if (!isRecord(profile)) return false;
+	for (const [key, value] of Object.entries(profile)) {
+		if (current[key] !== value) return false;
+	}
+	return true;
+}
+
+function readRootSettings(config) {
+	const settings = {};
+	for (const line of config.split(/\n/)) {
+		if (isSectionHeader(line)) break;
+		for (const key of MANAGED_KEYS) {
+			if (!isRootSetting(line, key)) continue;
+			const value = parseTomlScalar(line.slice(line.indexOf("=") + 1));
+			if (value !== undefined) settings[key] = value;
+		}
+	}
+	return settings;
+}
+
+function parseTomlScalar(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+		try {
+			return JSON.parse(trimmed);
+		} catch (error) {
+			if (error instanceof SyntaxError) return undefined;
+			throw error;
+		}
+	}
+	const numeric = Number(trimmed);
+	return Number.isFinite(numeric) ? numeric : undefined;
+}
+
+function parseCatalog(value) {
+	if (!isRecord(value) || !isRecord(value.current) || !Array.isArray(value.managedProfiles)) return null;
+	if (typeof value.version !== "string" || !isReasoningProfile(value.current)) return null;
+	const managedProfiles = [];
+	for (const profile of value.managedProfiles) {
+		if (!isRecord(profile) || typeof profile.version !== "string" || !isRecord(profile.match)) return null;
+		managedProfiles.push({ version: profile.version, match: profile.match });
+	}
+	return { version: value.version, current: value.current, managedProfiles, roles: isRecord(value.roles) ? value.roles : {} };
+}
+
+function isReasoningProfile(value) {
+	return (
+		isRecord(value) &&
+		typeof value.model === "string" &&
+		typeof value.model_context_window === "number" &&
+		typeof value.model_reasoning_effort === "string" &&
+		typeof value.plan_mode_reasoning_effort === "string"
+	);
+}
+
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function configPaths({ env, cwd }) {
+	const codexHome = resolve(env.CODEX_HOME?.trim() || join(homedir(), ".codex"));
+	const paths = new Set([join(codexHome, "config.toml")]);
+	for (const projectConfig of projectConfigPaths({ cwd, stopAt: homedir() })) {
+		if (await pathExists(projectConfig)) paths.add(projectConfig);
+	}
+	return [...paths];
+}
+
+function projectConfigPaths({ cwd, stopAt }) {
+	const paths = [];
+	let current = resolve(cwd);
+	const stop = resolve(stopAt);
+	while (true) {
+		paths.push(join(current, ".codex", "config.toml"));
+		if (current === stop || current === dirname(current)) break;
+		current = dirname(current);
+	}
+	return paths;
+}
+
+async function readConfig(configPath) {
+	try {
+		return await readFile(configPath, "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return "";
+		throw error;
+	}
+}
+
+function resolveStatePath(env) {
+	if (env.LAZYCODEX_MODEL_CATALOG_STATE_PATH?.trim()) return env.LAZYCODEX_MODEL_CATALOG_STATE_PATH;
+	const dataRoot = env.PLUGIN_DATA?.trim() || join(homedir(), ".local", "share", "lazycodex");
+	return join(dataRoot, "model-catalog-state.json");
+}
+
+async function readState(statePath) {
+	try {
+		const parsed = JSON.parse(await readFile(statePath, "utf8"));
+		return isRecord(parsed) ? parsed : {};
+	} catch (error) {
+		if (error instanceof Error) return {};
+		throw error;
+	}
+}
+
+async function writeState(statePath, state) {
+	await mkdir(dirname(statePath), { recursive: true });
+	await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+async function pathExists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+function replaceOrInsertRootSetting(config, key, value) {
+	const lines = config.split(/\n/);
+	const output = [];
+	let replaced = false;
+	let inserted = false;
+	for (const line of lines) {
+		if (!inserted && isSectionHeader(line)) {
+			if (!replaced) output.push(`${key} = ${value}`);
+			inserted = true;
+		}
+		if (isRootSetting(line, key)) {
+			if (!replaced) {
+				output.push(`${key} = ${value}`);
+				replaced = true;
+			}
+			continue;
+		}
+		output.push(line);
+	}
+	if (!replaced && !inserted) output.push(`${key} = ${value}`);
+	return output.join("\n");
+}
+
+function isSectionHeader(line) {
+	const trimmed = 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;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	migrateCodexConfig().catch((error) => {
+		if (!(error instanceof Error)) throw error;
+		process.exit(0);
+	});
+}

package/packages/omo-codex/plugin/scripts/sync-hook-status-messages.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { access, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
+
+import { formatLazyCodexHookStatusMessage, normalizeLazyCodexHookStatusLabel } from "./hook-status-message.mjs";
+
+const defaultRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+async function exists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function readJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+
+async function writeJson(path, value) {
+	await writeFile(path, `${JSON.stringify(value, null, "\t")}\n`);
+}
+
+async function readPackageVersion(path) {
+	const packageJson = await readJson(path);
+	return packageJson.version;
+}
+
+async function readComponentVersions(root) {
+	const componentsRoot = join(root, "components");
+	const entries = await readdir(componentsRoot, { withFileTypes: true });
+	const versions = new Map();
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const packageJsonPath = join(componentsRoot, entry.name, "package.json");
+		if (!(await exists(packageJsonPath))) continue;
+		versions.set(entry.name, await readPackageVersion(packageJsonPath));
+	}
+	return versions;
+}
+
+function componentVersionForCommand(command, componentVersions, fallbackVersion) {
+	for (const [componentName, version] of componentVersions.entries()) {
+		if (command.includes(`/components/${componentName}/dist/cli.js`)) return version;
+	}
+	return fallbackVersion;
+}
+
+function syncHooksJson(hooksJson, versionForCommand) {
+	for (const groups of Object.values(hooksJson.hooks)) {
+		for (const group of groups) {
+			for (const hook of group.hooks) {
+				if (hook.type !== "command") continue;
+				const label = normalizeLazyCodexHookStatusLabel(hook.statusMessage);
+				hook.statusMessage = formatLazyCodexHookStatusMessage(versionForCommand(hook.command), label);
+			}
+		}
+	}
+}
+
+async function syncComponentHooks(root, componentName, version) {
+	const hooksPath = join(root, "components", componentName, "hooks", "hooks.json");
+	if (!(await exists(hooksPath))) return;
+	const hooksJson = await readJson(hooksPath);
+	syncHooksJson(hooksJson, () => version);
+	await writeJson(hooksPath, hooksJson);
+}
+
+export async function syncHookStatusMessages(root = defaultRoot) {
+	const aggregateVersion = await readPackageVersion(join(root, ".codex-plugin", "plugin.json"));
+	const componentVersions = await readComponentVersions(root);
+	const aggregateHooksPath = join(root, "hooks", "hooks.json");
+	const aggregateHooks = await readJson(aggregateHooksPath);
+	syncHooksJson(aggregateHooks, (command) => componentVersionForCommand(command, componentVersions, aggregateVersion));
+	await writeJson(aggregateHooksPath, aggregateHooks);
+
+	for (const [componentName, version] of componentVersions.entries()) {
+		await syncComponentHooks(root, componentName, version);
+	}
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	await syncHookStatusMessages();
+}

package/packages/omo-codex/plugin/scripts/sync-skills.mjs

@@ -22,15 +22,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.
 
 `;
 

package/packages/omo-codex/plugin/skills/init-deep/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.
 
 # /init-deep
 

package/packages/omo-codex/plugin/skills/lcx-report-bug/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: lcx-report-bug
+description: "Create a high-signal LazyCodex bug report for code-yeongyu/lazycodex. Use this whenever the user asks to report, file, open, or triage a LazyCodex, lazycodex-ai, omo-codex, or Codex plugin bug, especially when they need root cause, reproduction steps, expected fix guidance, and a GitHub issue."
+metadata:
+  short-description: Report LazyCodex bugs with debugging evidence
+---
+
+# lcx-report-bug
+
+You are a LazyCodex bug reporter. Produce one useful GitHub issue in English for `code-yeongyu/lazycodex`, backed by runtime evidence rather than guesses.
+
+Use GPT-5.5 style: outcome first, concise, evidence-bound. Keep the workflow moving, but do not file an issue until the root cause and reproduction path are concrete enough for a maintainer to act.
+
+## Goal
+
+Create or prepare a GitHub issue that includes:
+
+- clear title
+- environment
+- reproducible steps
+- expected behavior
+- actual behavior
+- confirmed or strongly evidenced root cause
+- fix approach, including files or components likely involved
+- verification plan
+
+## Required Workflow
+
+1. Read the user's bug report and identify the affected surface: LazyCodex installer, Codex plugin, skill, hook, MCP, CLI alias, GitHub marketplace sync, or web/docs.
+2. Invoke `$omo:debugging` for the investigation. If Codex exposes only unqualified skill names in the current session, invoke `$debugging` and state that it is the OMO debugging skill.
+3. Follow the debugging skill far enough to gather runtime evidence:
+   - form at least three plausible hypotheses
+   - run the smallest reproduction that exercises the real surface
+   - confirm the root cause by observing the failing state
+   - identify the minimal fix path or maintainer action
+4. Search for an existing issue before creating a new one:
+
+```bash
+gh issue list --repo code-yeongyu/lazycodex --search "<short error or symptom>" --state open
+```
+
+5. If a matching open issue exists, add a comment with the new evidence instead of creating a duplicate.
+6. If no matching issue exists, create the issue with `gh`.
+
+## Issue Body Template
+
+Write the issue body in English and keep it direct:
+
+```markdown
+## Summary
+[One or two sentences describing the user-visible failure.]
+
+## Environment
+- LazyCodex version:
+- Codex version:
+- OS:
+- Install method:
+- Relevant config:
+
+## Reproduction
+1. [Exact command or UI action]
+2. [Exact next step]
+3. [Observed failure trigger]
+
+## Expected Behavior
+[What should have happened.]
+
+## Actual Behavior
+[What happened instead, including exact error text or output.]
+
+## Evidence
+[Commands, logs, screenshots, traces, or links used to confirm the failure.]
+
+## Root Cause
+[Confirmed cause. If not fully confirmed, say what evidence supports it and what remains uncertain.]
+
+## Proposed Fix
+[Concrete implementation or operational fix. Include likely files, components, or commands.]
+
+## Verification Plan
+- [Check that reproduces the original failure]
+- [Check that proves the fix]
+- [Regression check for adjacent LazyCodex/Codex plugin behavior]
+```
+
+## GitHub Creation Path
+
+Prefer `gh`:
+
+```bash
+ISSUE_BODY="/tmp/lcx-report-bug-$(date +%Y%m%d-%H%M%S).md"
+$EDITOR "$ISSUE_BODY"
+gh issue create --repo code-yeongyu/lazycodex --title "<clear title>" --body-file "$ISSUE_BODY"
+```
+
+If `$EDITOR` is not usable, write the file with the available file-editing tool, then run the same `gh issue create` command.
+
+After creating or commenting, return the issue URL and a short summary of the evidence used.
+
+## Browser use fallback
+
+If `gh` is unavailable, unauthenticated, or blocked, use Browser Use against the real GitHub page:
+
+1. Open `https://github.com/code-yeongyu/lazycodex/issues/new`.
+2. Fill the title and body from the template.
+3. Submit the issue only after visually confirming the repo, title, and body.
+4. Capture the resulting issue URL.
+
+## Computer use fallback
+
+If Browser Use is unavailable but a desktop browser is open and authenticated, use Computer Use:
+
+1. Navigate to `https://github.com/code-yeongyu/lazycodex/issues/new`.
+2. Fill the title and body.
+3. Verify the target repository and final text before submission.
+4. Submit and capture the issue URL.
+
+## Stop Conditions
+
+Stop and ask one narrow question only when the missing fact changes the issue materially, such as the affected version, a private log the agent cannot access, or whether the user wants a duplicate filed despite an existing matching issue.
+
+Do not file:
+
+- a vague issue without reproduction steps
+- an issue that claims a root cause not supported by runtime evidence
+- a duplicate when commenting on an existing issue is enough
+- a fix PR unless the user separately asks for one

package/packages/omo-codex/plugin/skills/lcx-report-bug/agents/openai.yaml

@@ -0,0 +1,9 @@
+interface:
+  display_name: "lcx-report-bug (omo)"
+  short_description: "Report LazyCodex bugs with debugging evidence"
+  search_terms:
+    - "lcx-report-bug"
+    - "lazycodex bug"
+    - "lazycodex issue"
+    - "omo-codex bug"
+  default_prompt: "Use $lcx-report-bug to investigate this LazyCodex bug and file a clear issue with reproduction, root cause, and fix guidance."

package/packages/omo-codex/plugin/skills/refactor/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.
 
 export const REFACTOR_TEMPLATE = `# Intelligent Refactor Command
 

package/packages/omo-codex/plugin/skills/remove-ai-slops/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.
 
 # Remove AI Slops Skill
 

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

@@ -8,15 +8,35 @@ 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
+
+Every `spawn_agent` message must be self-contained. Start with
+`TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and
+`VERIFY`. State that it is an executable assignment, not a context
+handoff. Role selection requires `agent_type`; `model` +
+`reasoning_effort` alone creates a default agent, not a reviewer or
+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. 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
+waits with no substantive result, send one targeted followup:
+`TASK STILL ACTIVE: return <deliverable> or BLOCKED: <reason>`. If the
+child stays silent or ack-only, mark that review lane inconclusive, do
+not count it as PASS or approval, close if safe, and respawn a smaller
+`fork_turns: "none"` reviewer with the missing deliverable.
 
 # Review Work - 5-Agent Parallel Review Orchestrator
 
@@ -493,9 +513,12 @@ OUTPUT FORMAT:
 
 ## Phase 2: Wait & Collect
 
-After launching all 5 agents in one turn, **end your response**. Wait for system notifications as each agent completes.
+After launching all 5 agents in one turn, wait for completions in bounded
+cycles. Do not treat a timeout, ack-only reply, or empty child result as
+a PASS.
 
-As each completes, collect via `background_output(task_id="bg_...")`. Store each verdict:
+As each completes, collect via the Codex mapping above (`wait_agent`,
+then the child's substantive final result). Store each verdict:
 
 | Agent | Verdict | Notes |
 |-------|---------|-------|
@@ -506,6 +529,8 @@ As each completes, collect via `background_output(task_id="bg_...")`. Store each
 | 5. Context Mining | pending | - |
 
 Do NOT deliver the final report until ALL 5 have completed.
+If a lane remains silent after the reliability followup, record it as
+inconclusive and respawn a smaller reviewer/worker for that exact lane.
 
 ---