oh-my-opencode 4.6.0 → 4.7.1

package/packages/omo-codex/plugin/components/ulw-loop/test/checkpoint.test.ts

@@ -2,6 +2,7 @@
 import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 
 import { checkpointUlwLoop } from "../src/checkpoint.js";
@@ -12,7 +13,7 @@ import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan, UlwLoopSuccessCriter
 import { UlwLoopError } from "../src/types.js";
 
 const NOW = "2026-05-23T00:00:00.000Z";
-const QUALITY_GATE_PATH = join(process.cwd(), "test", "fixtures", "sample-quality-gate.json");
+const QUALITY_GATE_PATH = fileURLToPath(new URL("./fixtures/sample-quality-gate.json", import.meta.url));
 
 function criterion(id: string, status: UlwLoopSuccessCriterion["status"]): UlwLoopSuccessCriterion {
 	return { id, scenario: `${id} scenario`, userModel: "happy", expectedEvidence: `${id} proof`, capturedEvidence: status === "pass" ? `${id} passed` : null, status };
@@ -142,6 +143,23 @@ describe("checkpointUlwLoop final story", () => {
 		expect(result.ledgerEntry.kind).toBe("aggregate_completed");
 	});
 
+	it("ACCEPTS complete when active task-scoped Codex objective maps to the ulw-loop brief", async () => {
+		const taskObjective = "Create only research artifacts with source evidence";
+		const repo = await repoWith(plan([passGoal("G001")], { activeGoalId: "G001" }));
+		await writeFile(ulwLoopBriefPath(repo), `${taskObjective}\n`, "utf8");
+
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G001",
+			status: "complete",
+			evidence: "final implementation complete and quality gate passed",
+			codexGoalJson: snapshot("active", taskObjective),
+			qualityGateJson: QUALITY_GATE_PATH,
+		});
+
+		expect(result.aggregateCompletion?.status).toBe("complete");
+		expect(result.ledgerEntry.kind).toBe("aggregate_completed");
+	});
+
 	it("explains final task-scoped objective mapping when completed Codex objective is unrelated", async () => {
 		const repo = await repoWith(plan([passGoal("G001")], { activeGoalId: "G001" }));
 		await writeFile(ulwLoopBriefPath(repo), "Fix ulw-loop objective mismatch and install local ulw\n", "utf8");

package/packages/omo-codex/plugin/hooks/hooks.json

@@ -20,6 +20,17 @@
 						"statusMessage": "LazyCodex(0.1.0): Recording Session Telemetry"
 					}
 				]
+			},
+			{
+				"matcher": "^startup$",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/scripts/auto-update.mjs\" hook session-start",
+						"timeout": 5,
+						"statusMessage": "LazyCodex(0.1.0): Checking Auto Update"
+					}
+				]
 			}
 		],
 		"UserPromptSubmit": [
@@ -86,13 +97,13 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/comment-checker/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "LazyCodex(0.1.1): Checking Comments"
+						"statusMessage": "LazyCodex(0.1.0): Checking Comments"
 					},
 					{
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "LazyCodex(0.2.0): Checking LSP Diagnostics"
+						"statusMessage": "LazyCodex(0.1.0): Checking LSP Diagnostics"
 					}
 				]
 			},
@@ -130,6 +141,17 @@
 						"statusMessage": "LazyCodex(0.1.0): Resetting Project Rule Cache"
 					}
 				]
+			},
+			{
+				"matcher": "manual|auto",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-compact",
+						"timeout": 5,
+						"statusMessage": "LazyCodex(0.1.0): Resetting LSP Diagnostics Cache"
+					}
+				]
 			}
 		],
 		"Stop": [

package/packages/omo-codex/plugin/model-catalog.json

@@ -0,0 +1,49 @@
+{
+	"version": "2026-06-03.gpt-5.5-400k",
+	"current": {
+		"model": "gpt-5.5",
+		"model_context_window": 400000,
+		"model_reasoning_effort": "high",
+		"plan_mode_reasoning_effort": "xhigh"
+	},
+	"roles": {
+		"default": {
+			"model": "gpt-5.5",
+			"model_context_window": 400000,
+			"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": 1000000,
+				"model_reasoning_effort": "high",
+				"plan_mode_reasoning_effort": "xhigh"
+			}
+		},
+		{
+			"version": "legacy.gpt-5.5-272k",
+			"match": {
+				"model": "gpt-5.5",
+				"model_context_window": 272000
+			}
+		}
+	]
+}

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,18 +37,13 @@ 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;
 }
 
-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) {
@@ -74,7 +69,7 @@ export async function syncHookStatusMessages(root = defaultRoot) {
 	const componentVersions = await readComponentVersions(root);
 	const aggregateHooksPath = join(root, "hooks", "hooks.json");
 	const aggregateHooks = await readJson(aggregateHooksPath);
-	syncHooksJson(aggregateHooks, (command) => componentVersionForCommand(command, componentVersions, aggregateVersion));
+	syncHooksJson(aggregateHooks, () => aggregateVersion);
 	await writeJson(aggregateHooksPath, aggregateHooks);
 
 	for (const [componentName, version] of componentVersions.entries()) {

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