oh-my-opencode 4.7.5 → 4.8.0

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

@@ -1,44 +1,19 @@
 #!/usr/bin/env node
 
-import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
 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",
-			},
-		},
-	],
-};
+import { FALLBACK_CATALOG, readModelCatalog } from "./migrate-codex-config/catalog.mjs";
+import { configPaths } from "./migrate-codex-config/config-paths.mjs";
+import { ensureCodexReasoningConfig as applyReasoningProfile, readRootSettings } from "./migrate-codex-config/root-settings.mjs";
+import { readState, resolveStatePath, writeState } from "./migrate-codex-config/state.mjs";
 
-const MANAGED_KEYS = ["model", "model_context_window", "model_reasoning_effort", "plan_mode_reasoning_effort"];
+export { readModelCatalog } from "./migrate-codex-config/catalog.mjs";
+
+export function ensureCodexReasoningConfig(config, profile = FALLBACK_CATALOG.current) {
+	return applyReasoningProfile(config, profile);
+}
 
 export async function migrateCodexConfig({ env = process.env, cwd = process.cwd() } = {}) {
 	const catalog = await readModelCatalog(env);
@@ -66,7 +41,7 @@ export async function migrateCodexConfig({ env = process.env, cwd = process.cwd(
 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 };
+	if (!decision.apply) return { changed: false, written: readRootSettings(before), managed: decision.managed };
 	const after = ensureCodexReasoningConfig(before, catalog.current);
 	if (after === before) return { changed: false, written: catalog.current, managed: true };
 	await mkdir(dirname(configPath), { recursive: true });
@@ -74,35 +49,17 @@ export async function migrateConfigFile(configPath, { catalog = FALLBACK_CATALOG
 	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 (matchesProfile(current, catalog.current)) return { apply: false, reason: "current", managed: true };
 	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" };
+	return { apply: false, reason: "user-modified", managed: false };
 }
 
 function matchesProfile(current, profile) {
@@ -113,81 +70,10 @@ function matchesProfile(current, profile) {
 	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 isRegularFile(projectConfig))) continue;
-		if (!(await isRegularDirectory(dirname(projectConfig)))) continue;
-		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");
@@ -197,80 +83,6 @@ async function readConfig(configPath) {
 	}
 }
 
-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 isRegularFile(path) {
-	try {
-		return (await lstat(path)).isFile();
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
-		throw error;
-	}
-}
-
-async function isRegularDirectory(path) {
-	try {
-		return (await lstat(path)).isDirectory();
-	} 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;

package/packages/omo-codex/plugin/scripts/spawn-command.mjs

@@ -0,0 +1,11 @@
+const WINDOWS_CMD_SHIM_COMMANDS = new Set(["npm", "npx"]);
+
+export function resolveSpawnInvocation(command, args, platform = process.platform) {
+	const invocation = { command, args: Array.from(args) };
+	if (platform !== "win32") return invocation;
+	if (!WINDOWS_CMD_SHIM_COMMANDS.has(command.toLowerCase())) return invocation;
+	return {
+		command: "cmd.exe",
+		args: ["/d", "/s", "/c", `${command}.cmd`, ...invocation.args],
+	};
+}

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

@@ -31,17 +31,17 @@ async function readPackageVersion(path) {
 	return packageJson.version;
 }
 
-async function readComponentVersions(root) {
+async function readComponentNames(root) {
 	const componentsRoot = join(root, "components");
 	const entries = await readdir(componentsRoot, { withFileTypes: true });
-	const versions = new Map();
+	const names = [];
 	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));
+		names.push(entry.name);
 	}
-	return versions;
+	return names;
 }
 
 function syncHooksJson(hooksJson, versionForCommand) {
@@ -64,16 +64,30 @@ async function syncComponentHooks(root, componentName, 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);
+function normalizeReleaseVersion(version) {
+	if (typeof version !== "string") return "";
+	return version.trim();
+}
+
+function readReleaseVersion(options) {
+	const releaseVersion = normalizeReleaseVersion(options.releaseVersion ?? process.env.LAZYCODEX_RELEASE_VERSION);
+	if (releaseVersion.length > 0) return releaseVersion;
+	return undefined;
+}
+
+export async function syncHookStatusMessages(root = defaultRoot, options = {}) {
+	const releaseVersion = readReleaseVersion(options);
+	const aggregateVersion = releaseVersion ?? (await readPackageVersion(join(root, ".codex-plugin", "plugin.json")));
+	const componentNames = await readComponentNames(root);
 	const aggregateHooksPath = join(root, "hooks", "hooks.json");
 	const aggregateHooks = await readJson(aggregateHooksPath);
 	syncHooksJson(aggregateHooks, () => aggregateVersion);
 	await writeJson(aggregateHooksPath, aggregateHooks);
 
-	for (const [componentName, version] of componentVersions.entries()) {
-		await syncComponentHooks(root, componentName, version);
+	for (const componentName of componentNames) {
+		const componentVersion =
+			releaseVersion ?? (await readPackageVersion(join(root, "components", componentName, "package.json")));
+		await syncComponentHooks(root, componentName, componentVersion);
 	}
 }
 

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

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { sharedSkillsRootPath } from "@oh-my-opencode/shared-skills";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const sharedSkillsRoot = sharedSkillsRootPath();
 const skillsRoot = join(root, "skills");
+const sourceTestFilePattern = /\.test\.ts$/;
 const skillSources = [
 	["comment-checker", "components/comment-checker/skills/comment-checker"],
 	["lsp", "components/lsp/skills/lsp"],
 	["rules", "components/rules/skills/rules"],
 	["ulw-loop", "components/ulw-loop/skills/ulw-loop"],
+	["ulw-plan", "components/ultrawork/skills/ulw-plan"],
 ];
 
 const opencodeOnlyOrchestrationPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
@@ -22,54 +24,155 @@ 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="...", 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 |
+| \`call_omo_agent(subagent_type="explore", ...)\` | \`spawn_agent({"task_name":"...","message":"TASK: act as an explorer. ...","fork_turns":"none"})\` |
+| \`call_omo_agent(subagent_type="librarian", ...)\` | \`spawn_agent({"task_name":"...","message":"TASK: act as a librarian. ...","fork_turns":"none"})\` |
+| \`task(subagent_type="plan", ...)\` | \`spawn_agent({"task_name":"...","message":"TASK: act as a planning agent. ...","fork_turns":"none"})\` |
+| \`task(subagent_type="oracle", ...)\` for final verification | \`spawn_agent({"task_name":"...","message":"TASK: act as a rigorous reviewer. ...","fork_turns":"none"})\` |
+| \`task(category="...", ...)\` for implementation or QA | \`spawn_agent({"task_name":"...","message":"TASK: act as an implementation or QA worker. ...","fork_turns":"none"})\` |
+| \`background_output(task_id="...")\` | \`wait_agent(...)\` for mailbox signals; after a timeout, run one \`list_agents\` check for the named child if reassurance is needed |
 | \`team_*(...)\` | Use Codex native subagents plus \`send_message\`, \`followup_task\`, \`wait_agent\`, and \`close_agent\` |
 
-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 full-history forks inherit parent context, so role-specific behavior must be described in a self-contained \`message\` and usually should 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.
+
+For work likely to exceed one wait cycle, require the child to send \`WORKING: <task> - <current phase>\` before long passes and \`BLOCKED: <reason>\` only when progress stops. A \`wait_agent\` timeout only means no new mailbox update arrived. Treat a running child or latest \`WORKING:\` message as alive. Do not use \`list_agents\` as a polling loop. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly \`BLOCKED:\`, or no longer running.
 
 `;
 
-function insertCodexCompatibilityGuidance(content) {
+const codexCompatibilityEndMarkers = [
+	"For work likely to exceed one wait cycle, require the child to send `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A `wait_agent` timeout only means no new mailbox update arrived. Treat a running child or latest `WORKING:` message as alive. Do not use `list_agents` as a polling loop. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.\n\n",
+	"Codex full-history forks inherit parent context, so role-specific behavior must be described in a self-contained `message` and usually should 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.\n\n",
+	"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.\n\n",
+	"When translating `load_skills=[...]`, name the skills inside the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
+];
+
+function findCodexCompatibilitySectionEnd(content, searchStart) {
+	const structuralEndPattern = /\n(?:---|#{1,6}\s)/g;
+	structuralEndPattern.lastIndex = searchStart;
+	const structuralEnd = structuralEndPattern.exec(content);
+	if (structuralEnd) return structuralEnd.index + 1;
+
+	const knownEndMarker = codexCompatibilityEndMarkers.find((marker) => content.indexOf(marker, searchStart) !== -1);
+	if (knownEndMarker === undefined) return content.length;
+
+	return content.indexOf(knownEndMarker, searchStart) + knownEndMarker.length;
+}
+
+function removeCodexCompatibilityGuidance(content) {
+	const heading = "## Codex Harness Tool Compatibility";
+	let withoutGuidance = content;
+
+	while (true) {
+		const start = withoutGuidance.indexOf(heading);
+		if (start === -1) return withoutGuidance;
+
+		const end = findCodexCompatibilitySectionEnd(withoutGuidance, start + heading.length);
+
+		withoutGuidance = `${withoutGuidance.slice(0, start)}${withoutGuidance.slice(end)}`;
+	}
+}
+
+export function insertCodexCompatibilityGuidance(content) {
 	if (!opencodeOnlyOrchestrationPattern.test(content)) return content;
-	if (content.includes("## Codex Harness Tool Compatibility")) return content;
+	const firstExampleIndex = content.search(opencodeOnlyOrchestrationPattern);
+	const compatibilityIndex = content.indexOf("## Codex Harness Tool Compatibility");
+	if (compatibilityIndex !== -1 && compatibilityIndex < firstExampleIndex) return content;
 
-	const frontmatterMatch = content.match(/^---\n[\s\S]*?\n---\n+/);
+	const contentWithoutGuidance = removeCodexCompatibilityGuidance(content);
+
+	const frontmatterMatch = contentWithoutGuidance.match(/^---\n[\s\S]*?\n---\n+/);
 	if (!frontmatterMatch) {
-		return `${codexHarnessToolCompatibility}${content}`;
+		return `${codexHarnessToolCompatibility}${contentWithoutGuidance}`;
 	}
 
-	return `${frontmatterMatch[0]}${codexHarnessToolCompatibility}${content.slice(frontmatterMatch[0].length)}`;
+	return `${frontmatterMatch[0]}${codexHarnessToolCompatibility}${contentWithoutGuidance.slice(frontmatterMatch[0].length)}`;
+}
+
+const startWorkOriginalCompletion = `When all top-level checkboxes in \`## TODOs\` and \`## Final Verification Wave\` are complete:
+
+1. Run the plan's final verification commands.
+2. If worktree mode was used, sync \`.omo/\` state back to the main repo, merge or hand off exactly as requested, and remove the worktree only after successful merge or explicit handoff.
+3. Remove or mark the Boulder work as completed.
+4. Print an \`ORCHESTRATION COMPLETE\` block with the plan path, verification commands, artifacts, and cleanup receipts.`;
+
+const startWorkCodexCompletion = `When all top-level checkboxes in \`## TODOs\` and \`## Final Verification Wave\` are complete:
+
+1. Run the plan's final verification commands.
+2. Complete the **Global Review and Debugging Gate** before any completion claim, PR handoff, or branch handoff:
+   - Invoke the \`review-work\` skill with the final diff, changed files, user goal, constraints, run command, and verification evidence. All five review lanes must return PASS. A timeout, missing deliverable, ack-only child, \`BLOCKED:\`, or inconclusive lane is a gate failure, not approval.
+   - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append the ruled-out or confirmed result to \`.omo/start-work/ledger.jsonl\`.
+   - If any review lane or debugging hypothesis fails, invoke the \`debugging\` skill, confirm root cause with runtime evidence, add the minimal failing test or reproduction, fix it, rerun the affected verification, then rerun the Global Review and Debugging Gate.
+   - Evidence hygiene is mandatory: redact or mask secrets and sensitive user data before writing \`.omo/start-work/ledger.jsonl\`, a PR body, or a handoff. Never include raw tokens, credentials, auth headers, cookies, API keys, env dumps, private logs, or PII; use concise summaries, lengths, hashes, or short non-sensitive prefixes instead.
+   - If the work includes creating, updating, or handing off a PR, refresh \`git status\` and the PR/branch state after the gate, and include only redacted review/debugging evidence in the PR body or handoff.
+3. If worktree mode was used, sync \`.omo/\` state back to the main repo, merge or hand off exactly as requested, and remove the worktree only after successful merge or explicit handoff.
+4. Remove or mark the Boulder work as completed.
+5. Print an \`ORCHESTRATION COMPLETE\` block with the plan path, verification commands, Global Review and Debugging Gate verdict, artifacts, and cleanup receipts.`;
+
+const startWorkOriginalHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
+
+const startWorkCodexHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No `ORCHESTRATION COMPLETE`, final response, PR creation, or PR handoff before the Global Review and Debugging Gate passes with recorded evidence.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
+
+const reviewWorkAnchor = "Launch 5 specialized sub-agents in parallel to review completed implementation work from every angle. All 5 must pass for the review to pass. If even ONE fails, the review fails.\n";
+
+const reviewWorkCodexGate = `
+When \`review-work\` is used as a final implementation, PR, or \`$start-work\`
+gate, it is blocking. A timeout, missing deliverable, ack-only response,
+explicit \`BLOCKED:\`, or inconclusive lane is not a pass. Treat that lane as
+failed, investigate the underlying uncertainty with the \`debugging\` skill when
+runtime behavior may be wrong, fix with evidence, and rerun the affected lane
+before claiming completion or handing off a PR.
+
+Review evidence must be safe to share. Redact or mask secrets and sensitive
+user data before including evidence in logs, PR bodies, or handoffs. Never
+include raw tokens, credentials, auth headers, cookies, API keys, env dumps,
+private logs, or PII; summarize with lengths, hashes, and short non-sensitive
+prefixes when identity is needed.
+`;
+
+function applyCodexSkillOverlays(skillName, content) {
+	if (skillName === "start-work") {
+		return content
+			.replace(startWorkOriginalCompletion, startWorkCodexCompletion)
+			.replace(startWorkOriginalHardRule, startWorkCodexHardRule);
+	}
+	if (skillName === "review-work" && !content.includes("When `review-work` is used as a final implementation")) {
+		return content.replace(reviewWorkAnchor, `${reviewWorkAnchor}${reviewWorkCodexGate}`);
+	}
+	return content;
 }
 
 async function adaptSkillForCodex(skillName) {
 	const skillPath = join(skillsRoot, skillName, "SKILL.md");
 	const content = await readFile(skillPath, "utf8");
-	const adapted = insertCodexCompatibilityGuidance(content);
+	const adapted = applyCodexSkillOverlays(skillName, insertCodexCompatibilityGuidance(content));
 	if (adapted !== content) {
 		await writeFile(skillPath, adapted, "utf8");
 	}
 }
 
-await rm(skillsRoot, { recursive: true, force: true });
-await mkdir(skillsRoot, { recursive: true });
+async function syncSkills() {
+	await rm(skillsRoot, { recursive: true, force: true });
+	await mkdir(skillsRoot, { recursive: true });
 
-for (const [name, source] of skillSources) {
-	await cp(join(root, source), join(skillsRoot, name), { recursive: true });
-	await adaptSkillForCodex(name);
-}
+	for (const [name, source] of skillSources) {
+		await cp(join(root, source), join(skillsRoot, name), { recursive: true });
+		await adaptSkillForCodex(name);
+	}
+
+	const sharedSkillEntries = await readdir(sharedSkillsRoot, { withFileTypes: true });
+	const sharedSkillNames = sharedSkillEntries
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
 
-const sharedSkillEntries = await readdir(sharedSkillsRoot, { withFileTypes: true });
-const sharedSkillNames = sharedSkillEntries
-	.filter((entry) => entry.isDirectory())
-	.map((entry) => entry.name)
-	.sort();
+	for (const skillName of sharedSkillNames) {
+		await cp(join(sharedSkillsRoot, skillName), join(skillsRoot, skillName), {
+			filter: (source) => !sourceTestFilePattern.test(source),
+			recursive: true,
+		});
+		await adaptSkillForCodex(skillName);
+	}
+}
 
-for (const skillName of sharedSkillNames) {
-	await cp(join(sharedSkillsRoot, skillName), join(skillsRoot, skillName), { recursive: true });
-	await adaptSkillForCodex(skillName);
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	await syncSkills();
 }

package/packages/omo-codex/plugin/skills/debugging/references/methodology/04-oracle-triple.md

@@ -48,7 +48,7 @@ task(subagent_type="oracle", load_skills=[], run_in_background=true,
      - attached to the wrong instance of the service
      - test harness running different code than the app
      - editing src/ while running dist/
-     
+
      Give me exactly three candidate causes ranked by likelihood, with one sentence each explaining why our evidence is consistent with each.")
 
 task(subagent_type="oracle", load_skills=[], run_in_background=true,
@@ -64,7 +64,7 @@ task(subagent_type="oracle", load_skills=[], run_in_background=true,
      - shared-library version mismatch (system lib vs bundled lib)
      - ABI difference (native addons, glibc versions, musl vs glibc)
      - wrong transport (HTTP/1.1 vs HTTP/2, TLS version negotiation)
-     
+
      Give me three candidate causes, each naming the specific boundary and the specific contract assumption that might be violated.")
 
 task(subagent_type="oracle", load_skills=[], run_in_background=true,
@@ -75,7 +75,7 @@ task(subagent_type="oracle", load_skills=[], run_in_background=true,
      Enumerate the five assumptions most load-bearing to our current hypotheses, then for each:
      - describe the smallest runtime query that would falsify it
      - predict what the observable would be if the invariant holds vs if it fails
-     
+
      We want at least one of these queries to be decisive.")
 ```