oh-my-opencode 4.6.0 → 4.7.0

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

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import { spawn, spawnSync } from "node:child_process";
+import { mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { migrateCodexConfig } from "./migrate-codex-config.mjs";
+
+const DEFAULT_INTERVAL_MS = 24 * 60 * 60 * 1_000;
+const DEFAULT_LOCK_STALE_MS = 10 * 60 * 1_000;
+
+export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), lastCheckedAt } = {}) {
+	if (env.LAZYCODEX_AUTO_UPDATE_DISABLED === "1" || env.OMO_CODEX_AUTO_UPDATE_DISABLED === "1") {
+		return { shouldRun: false, reason: "disabled" };
+	}
+
+	const intervalMs = parsePositiveInteger(env.LAZYCODEX_AUTO_UPDATE_INTERVAL_MS, DEFAULT_INTERVAL_MS);
+	if (typeof lastCheckedAt === "number" && intervalMs > 0 && now - lastCheckedAt < intervalMs) {
+		return { shouldRun: false, reason: "throttled" };
+	}
+
+	return {
+		shouldRun: true,
+		command: resolveCommand(env),
+		args: resolveArgs(env),
+		env: {
+			...env,
+			LAZYCODEX_AUTO_UPDATE_DISABLED: "1",
+			OMO_CODEX_AUTO_UPDATE_DISABLED: "1",
+		},
+	};
+}
+
+export async function runAutoUpdateCheck({ env = process.env, now = Date.now() } = {}) {
+	await runConfigMigration({ env });
+	const statePath = resolveStatePath(env);
+	const state = await readState(statePath);
+	const plan = resolveAutoUpdatePlan({ env, now, lastCheckedAt: state.lastCheckedAt });
+	if (!plan.shouldRun) return { started: false, reason: plan.reason };
+
+	const lock = await acquireLock(resolveLockPath(env, statePath), now, env);
+	if (lock === null) return { started: false, reason: "locked" };
+	try {
+		await writeState(statePath, { lastCheckedAt: now });
+		if (env.LAZYCODEX_AUTO_UPDATE_WAIT === "1") {
+			const result = spawnSync(plan.command, plan.args, {
+				env: plan.env,
+				stdio: "ignore",
+			});
+			return { started: true, status: result.status ?? 0 };
+		}
+
+		const child = spawn(plan.command, plan.args, {
+			env: plan.env,
+			stdio: "ignore",
+			detached: true,
+		});
+		child.unref();
+		return { started: true };
+	} finally {
+		await lock.release();
+	}
+}
+
+async function runConfigMigration({ env }) {
+	if (env.LAZYCODEX_CONFIG_MIGRATION_DISABLED === "1" || env.OMO_CODEX_CONFIG_MIGRATION_DISABLED === "1") return;
+	try {
+		await migrateCodexConfig({ env });
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		return;
+	}
+}
+
+function resolveCommand(env) {
+	return env.LAZYCODEX_AUTO_UPDATE_COMMAND?.trim() || "npx";
+}
+
+function resolveArgs(env) {
+	if (env.LAZYCODEX_AUTO_UPDATE_ARGS_JSON) {
+		const parsed = JSON.parse(env.LAZYCODEX_AUTO_UPDATE_ARGS_JSON);
+		if (!Array.isArray(parsed) || parsed.some((value) => typeof value !== "string")) {
+			throw new TypeError("LAZYCODEX_AUTO_UPDATE_ARGS_JSON must be a JSON string array");
+		}
+		return parsed;
+	}
+	return ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--skip-auth"];
+}
+
+function resolveStatePath(env) {
+	if (env.LAZYCODEX_AUTO_UPDATE_STATE_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_STATE_PATH;
+	const dataRoot = env.PLUGIN_DATA?.trim() || join(homedir(), ".local", "share", "lazycodex");
+	return join(dataRoot, "auto-update.json");
+}
+
+function resolveLockPath(env, statePath) {
+	if (env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH;
+	return `${statePath}.lock`;
+}
+
+async function acquireLock(lockPath, now, env) {
+	await mkdir(dirname(lockPath), { recursive: true });
+	const staleMs = parsePositiveInteger(env.LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS, DEFAULT_LOCK_STALE_MS);
+	try {
+		const handle = await open(lockPath, "wx");
+		await handle.writeFile(`${now}\n`);
+		await handle.close();
+		return {
+			release: () => rm(lockPath, { force: true }),
+		};
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+		if (!(await removeStaleLock(lockPath, now, staleMs))) return null;
+		return acquireLock(lockPath, now, { ...env, LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS: "0" });
+	}
+}
+
+async function removeStaleLock(lockPath, now, staleMs) {
+	if (staleMs <= 0) return false;
+	try {
+		const lockStat = await stat(lockPath);
+		if (now - lockStat.mtimeMs < staleMs) return false;
+		await rm(lockPath, { force: true });
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return true;
+		throw error;
+	}
+}
+
+async function readState(statePath) {
+	try {
+		const raw = await readFile(statePath, "utf8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed === "object" && parsed !== null ? parsed : {};
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
+		return {};
+	}
+}
+
+async function writeState(statePath, state) {
+	await mkdir(dirname(statePath), { recursive: true });
+	await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function parsePositiveInteger(value, fallback) {
+	if (value === undefined || value === "") return fallback;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	runAutoUpdateCheck().catch((error) => {
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exit(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

@@ -37,7 +37,9 @@ async function readComponentVersions(root) {
 	const versions = new Map();
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
-		versions.set(entry.name, await readPackageVersion(join(componentsRoot, entry.name, "package.json")));
+		const packageJsonPath = join(componentsRoot, entry.name, "package.json");
+		if (!(await exists(packageJsonPath))) continue;
+		versions.set(entry.name, await readPackageVersion(packageJsonPath));
 	}
 	return versions;
 }

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