oh-my-opencode 4.7.4 → 4.8.0

package/packages/omo-codex/plugin/test/sync-skills-orchestration.test.mjs

@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { insertCodexCompatibilityGuidance } from "../scripts/sync-skills.mjs";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+async function listSkillNames() {
+	const skillsRoot = join(root, "skills");
+	const entries = await readdir(skillsRoot, { withFileTypes: true });
+	return entries
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
+}
+
+async function readSkill(skillName) {
+	return readFile(join(root, "skills", skillName, "SKILL.md"), "utf8");
+}
+
+function patternFromParts(parts, flags) {
+	return new RegExp(parts.join(""), flags);
+}
+
+test("#given synced aggregate Codex skills #when they contain OpenCode orchestration examples #then Codex tool compatibility guidance is injected", async () => {
+	// given
+	const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
+
+	// when / then
+	for (const skillName of await listSkillNames()) {
+		const content = await readSkill(skillName);
+		if (!opencodeOnlyToolPattern.test(content)) continue;
+
+		const compatibilityMatches = content.match(/## Codex Harness Tool Compatibility/g) ?? [];
+		const compatibilityIndex = content.indexOf("## Codex Harness Tool Compatibility");
+		assert.notEqual(compatibilityIndex, -1, `${skillName} is missing Codex compatibility guidance`);
+		assert.equal(compatibilityMatches.length, 1, `${skillName} must not duplicate Codex compatibility guidance`);
+		assert.ok(
+			compatibilityIndex < content.search(opencodeOnlyToolPattern),
+			`${skillName} must explain Codex tool translation before OpenCode-only examples`,
+		);
+	}
+});
+
+test("#given late variant Codex compatibility guidance #when adapting a skill #then it is moved without duplication", () => {
+	// given
+	const content = `---
+name: example
+---
+
+# Example Skill
+
+call_omo_agent(subagent_type="explore", prompt="inspect")
+
+## Codex Harness Tool Compatibility
+
+Older variant guidance.
+
+When translating \`load_skills=[...]\`, name the skills inside the spawned agent's \`message\`.
+
+---
+
+## Next Section
+
+task(category="quick", prompt="verify")
+`;
+
+	// when
+	const adapted = insertCodexCompatibilityGuidance(content);
+
+	// then
+	const compatibilityIndex = adapted.indexOf("## Codex Harness Tool Compatibility");
+	const firstToolIndex = adapted.search(/\b(?:call_omo_agent|task)\s*\(/);
+	assert.notEqual(compatibilityIndex, -1);
+	assert.ok(compatibilityIndex < firstToolIndex);
+	assert.equal(adapted.match(/## Codex Harness Tool Compatibility/g)?.length, 1);
+	assert.doesNotMatch(adapted, /Older variant guidance/);
+	assert.doesNotMatch(adapted, /When translating `load_skills=\[\.\.\.\]`/);
+	assert.match(adapted, /\n---\n\n## Next Section/);
+});
+
+test("#given early custom Codex compatibility guidance #when adapting a skill #then it is preserved exactly", () => {
+	// given
+	const content = `---
+name: example
+---
+
+## Codex Harness Tool Compatibility
+
+Custom guidance for this skill, including \`dispatchInternalPrompt(...)\`.
+
+# Example Skill
+
+call_omo_agent(subagent_type="explore", prompt="inspect")
+`;
+
+	// when
+	const adapted = insertCodexCompatibilityGuidance(content);
+
+	// then
+	assert.equal(adapted, content);
+});
+
+test("#given synced aggregate Codex skills #when they describe background orchestration #then liveness is framed as progress rather than timeout failure", async () => {
+	// given
+	const orchestrationPattern = /\b(?:run_in_background|background_output|wait_agent)\b/;
+	const requiredPatterns = [
+		["working progress message", /WORKING:/],
+		["blocked progress message", /BLOCKED:/],
+		["mailbox timeout framing", /timeout only means no new mailbox update arrived/],
+		["single liveness check", /single `list_agents` check|one `list_agents` check/],
+		["polling-loop guard", /Do not use `list_agents` as a polling loop|Do NOT use `list_agents` as a polling loop/],
+		["explicit fallback conditions", /Fallback only when|Mark a file for retry only when/],
+	];
+	const bannedPatterns = [
+		["timeout as failure", patternFromParts(["fails or ", "times out"], "i")],
+		["failed or timed out", patternFromParts(["failed or ", "timed out"], "i")],
+		["two waits heuristic", patternFromParts(["After two ", "waits"])],
+		["unresponsive timeout framing", patternFromParts(["timeout", ".*", "un" + "responsive"], "i")],
+		["old status-tool warning", patternFromParts(["polling or ", "status tool"])],
+		["large status replay wording", patternFromParts(["large agent status", " and latest-message"])],
+		["old wait-agent aphorism", patternFromParts(["wait_agent", ".*", "signal, not ", "proof"], "i")],
+	];
+
+	// when / then
+	for (const skillName of await listSkillNames()) {
+		const content = await readSkill(skillName);
+		if (!orchestrationPattern.test(content)) continue;
+
+		for (const [label, pattern] of requiredPatterns) {
+			assert.match(content, pattern, `${skillName} missing ${label}`);
+		}
+		for (const [label, pattern] of bannedPatterns) {
+			assert.doesNotMatch(content, pattern, `${skillName} still has ${label}`);
+		}
+	}
+});
+
+test("#given review-work skill #when some lanes do not finish #then aggregate result remains bounded", async () => {
+	const content = await readSkill("review-work");
+
+	assert.match(content, /pending\/PASS\/FAIL\/INCONCLUSIVE/);
+	assert.match(content, /Preserve completed lane results immediately/);
+	assert.match(content, /ALL 5 lanes have a terminal state/);
+	assert.match(content, /REVIEW INCONCLUSIVE - not approved/);
+	assert.match(content, /Overall Verdict: PASSED \/ FAILED \/ INCONCLUSIVE/);
+	assert.match(content, /PASS\/FAIL\/INCONCLUSIVE \| HIGH\/MED\/LOW/);
+	assert.match(content, /Do not spin in repeated/);
+	assert.match(content, /Do not use `send_message` as an interrupt/);
+});

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

@@ -13,7 +13,9 @@ const expectedSkills = [
 	"comment-checker",
 	"debugging",
 	"frontend-ui-ux",
+	"git-master",
 	"init-deep",
+	"lcx-contribute-bug-fix",
 	"lcx-report-bug",
 	"lsp",
 	"programming",
@@ -22,8 +24,10 @@ const expectedSkills = [
 	"review-work",
 	"rules",
 	"start-work",
+	"ultraresearch",
 	"ulw-loop",
 	"ulw-plan",
+	"visual-qa",
 ];
 
 const componentSkillSources = [
@@ -31,10 +35,12 @@ const componentSkillSources = [
 	["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 codexCompatibilityEndMarkers = [
-	"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.\n\n",
+	"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",
 ];
@@ -49,6 +55,71 @@ function removeCodexCompatibilityGuidance(content) {
 	return `${content.slice(0, start)}${content.slice(end + endMarker.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 reviewWorkCodexGatePattern =
+	/\nWhen `review-work` is used as a final implementation, PR, or `\$start-work`\ngate, it is blocking\. A timeout, missing deliverable, ack-only response,\nexplicit `BLOCKED:`, or inconclusive lane is not a pass\. Treat that lane as\nfailed, investigate the underlying uncertainty with the `debugging` skill when\nruntime behavior may be wrong, fix with evidence, and rerun the affected lane\nbefore claiming completion or handing off a PR\.\n\nReview evidence must be safe to share\. Redact or mask secrets and sensitive\nuser data before including evidence in logs, PR bodies, or handoffs\. Never\ninclude raw tokens, credentials, auth headers, cookies, API keys, env dumps,\nprivate logs, or PII; summarize with lengths, hashes, and short non-sensitive\nprefixes when identity is needed\.\n/;
+
+function removeCodexSkillOverlays(skillName, content) {
+	if (skillName === "start-work") {
+		return content
+			.replace(startWorkCodexCompletion, startWorkOriginalCompletion)
+			.replace(startWorkCodexHardRule, startWorkOriginalHardRule);
+	}
+	if (skillName === "review-work") {
+		return content.replace(reviewWorkCodexGatePattern, "");
+	}
+	return content;
+}
+
+async function listSkillFiles(dir) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			const nested = await listSkillFiles(join(dir, entry.name));
+			for (const nestedPath of nested) files.push(join(entry.name, nestedPath));
+		} else {
+			files.push(entry.name);
+		}
+	}
+	return files.sort();
+}
+
+async function readPackagedSkillFile(...segments) {
+	const path = join(root, "skills", ...segments);
+	const content = await readFile(path, "utf8");
+	return { path, content };
+}
+
+function assertPackagedContentMatches({ path, content }, requirements) {
+	for (const [label, pattern] of requirements) {
+		assert.match(content, pattern, `${path} missing packaged skill contract: ${label}`);
+	}
+}
+
 test("#given synced aggregate Codex skills #when inspected #then component and shared skills are present", async () => {
 	// given
 	const skillsRoot = join(root, "skills");
@@ -103,26 +174,44 @@ test("#given shared skill package source #when aggregate Codex shared skills are
 		const sharedContent = await readFile(join(sharedSkillsRoot, skillName, "SKILL.md"), "utf8");
 		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
 		assert.equal(
-			removeCodexCompatibilityGuidance(aggregateContent),
+			removeCodexSkillOverlays(skillName, removeCodexCompatibilityGuidance(aggregateContent)),
 			removeCodexCompatibilityGuidance(sharedContent),
 			`${skillName} drifted from shared-skills`,
 		);
 	}
 });
 
+test("#given shared skill source tests #when aggregate Codex skills are synced #then source tests are not packaged", async () => {
+	// given
+	const aggregateSkillsRoot = join(root, "skills");
+
+	// when
+	const visualQaFiles = await listSkillFiles(join(aggregateSkillsRoot, "visual-qa"));
+
+	// then
+	assert.equal(visualQaFiles.some((file) => file.endsWith(".test.ts")), false);
+});
+
 test("#given component skill sources #when aggregate Codex component skills are inspected #then generated copies have no hand-authored drift", async () => {
 	// given
 	const aggregateSkillsRoot = join(root, "skills");
 
 	// when / then
 	for (const [skillName, sourcePath] of componentSkillSources) {
-		const sourceContent = await readFile(join(root, sourcePath, "SKILL.md"), "utf8");
-		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
-		assert.equal(
-			removeCodexCompatibilityGuidance(aggregateContent),
-			removeCodexCompatibilityGuidance(sourceContent),
-			`${skillName} drifted from its component skill source`,
-		);
+		const sourceDir = join(root, sourcePath);
+		const aggregateDir = join(aggregateSkillsRoot, skillName);
+		const sourceFiles = await listSkillFiles(sourceDir);
+		const aggregateFiles = await listSkillFiles(aggregateDir);
+		assert.deepEqual(aggregateFiles, sourceFiles, `${skillName} resource set drifted from its component skill source`);
+		for (const relativePath of sourceFiles) {
+			const sourceContent = await readFile(join(sourceDir, relativePath), "utf8");
+			const aggregateContent = await readFile(join(aggregateDir, relativePath), "utf8");
+			assert.equal(
+				removeCodexCompatibilityGuidance(aggregateContent),
+				removeCodexCompatibilityGuidance(sourceContent),
+				`${skillName}/${relativePath} drifted from its component skill source`,
+			);
+		}
 	}
 });
 
@@ -155,24 +244,24 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 	assert.match(interfaceMetadata, /- "ulw-loop"/);
 });
 
-test("#given synced lcx-report-bug skill #when inspected #then it files LazyCodex bug issues from proven debugging evidence", async () => {
+test("#given synced git-master skill #when inspected #then commits and git history route through it", async () => {
 	// given
-	const skillRoot = join(root, "skills", "lcx-report-bug");
+	const skillRoot = join(root, "skills", "git-master");
 
 	// when
 	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
 	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
 
 	// then
-	assert.match(skill, /^---\r?\nname: lcx-report-bug\r?\n/m);
-	assert.match(skill, /code-yeongyu\/lazycodex/);
-	assert.match(skill, /\$omo:debugging/);
-	assert.match(skill, /gh issue create --repo code-yeongyu\/lazycodex/);
-	assert.match(skill, /Browser use fallback/);
-	assert.match(skill, /Computer use fallback/);
-	assert.match(skill, /## Issue Body Template/);
-	assert.match(interfaceMetadata, /display_name: "lcx-report-bug \(omo\)"/);
-	assert.match(interfaceMetadata, /- "lazycodex bug"/);
+	assert.match(skill, /^---\r?\nname: git-master\r?\n/m);
+	assert.match(skill, /MUST USE whenever a task needs a commit or git-history investigation/);
+	assert.match(skill, /Commit only the user's requested changes/);
+	assert.match(skill, /Choose the Git tool by the question/);
+	assert.match(skill, /git log -S "text"/);
+	assert.match(skill, /git blame -L start,end -- file/);
+	assert.match(interfaceMetadata, /display_name: "git-master \(omo\)"/);
+	assert.match(interfaceMetadata, /- "git commit"/);
+	assert.match(interfaceMetadata, /- "history search"/);
 });
 
 test("#given synced ulw-loop skill #when worker guidance is inspected #then context-hygiene guidance matches the source", async () => {
@@ -185,15 +274,19 @@ test("#given synced ulw-loop skill #when worker guidance is inspected #then cont
 	const syncedWorkflow = await readFile(join(root, "skills", "ulw-loop", "references", "full-workflow.md"), "utf8");
 	const requiredPatterns = [
 		["list_agents polling guard", /list_agents/],
-		["status polling warning", /polling or status tool/],
-		["large payload replay risk", /replay large agent status and latest-message payloads/],
+		["status polling warning", /polling loop/],
+		["large payload replay risk", /replay large payloads/],
 		["local spawned-name tracking", /Track spawned agent names locally/],
-		["wait_agent completion path", /wait_agent.*completion/],
-		["targeted followups", /targeted followups only when needed/],
-		["close_agent cleanup", /close_agent.*after integrating each result/],
+		["wait_agent mailbox path", /wait_agent.*mailbox signals/],
+		["progress status contract", /WORKING:/],
+		["single list_agents reassurance", /single `list_agents`/],
 		["long-running plan/reviewer background guidance", /Plan and reviewer agents may run for a long time/],
 		["bounded plan/reviewer polling", /short wait_agent cycles/],
 		["single long wait guard", /single long blocking wait/],
+		["git-master checkpointing", /git-master/],
+		["touched-path commit-style probe", /touched-path commit history/],
+		["verified work-unit commit", /verified work unit/],
+		["observed commit style", /commit in the observed style/],
 	];
 
 	// when / then
@@ -206,6 +299,46 @@ test("#given synced ulw-loop skill #when worker guidance is inspected #then cont
 	assert.match(syncedSkill, /close_agent/);
 });
 
+test("#given packaged start-work skill #when inspected #then no-plan bootstrap and adversarial verification contracts are shipped", async () => {
+	// given
+	const skillFile = await readPackagedSkillFile("start-work", "SKILL.md");
+
+	// when / then
+	assertPackagedContentMatches(skillFile, [
+		["executes Prometheus plan with Boulder state", /Prometheus work plan[\s\S]*Boulder state/],
+		["bootstraps ulw-plan when no selectable plan exists", /no selectable plan[\s\S]*ulw-plan|ulw-plan[\s\S]*no selectable plan/i],
+		["does not execute work without an approved plan", /approved plan[\s\S]*(?:before|prior to)[\s\S]*execution|execution[\s\S]*(?:requires|needs)[\s\S]*approved plan/i],
+		["keeps hook continuation Boulder-only", /Boulder[\s\S]*(?:continuation|Stop hook)[\s\S]*(?:only|solely)|(?:continuation|Stop hook)[\s\S]*(?:only|solely)[\s\S]*Boulder/i],
+		["distinguishes execution from verification", /execution[\s\S]*verification|verification[\s\S]*execution/i],
+		["requires dirty-worktree-aware editing", /dirty worktree/i],
+		["requires stale-state probes", /stale state/i],
+		["rejects misleading success output", /misleading success output/i],
+		["does not accept worker done claims without independent verification", /done claim[\s\S]*independent(?:ly)? verified|independent(?:ly)? verify[\s\S]*done claim/i],
+	]);
+});
+
+test("#given packaged ulw-plan skill #when inspected #then dynamic multi-agent planning contracts are shipped", async () => {
+	// given
+	const skillFile = await readPackagedSkillFile("ulw-plan", "SKILL.md");
+	const workflowFile = await readPackagedSkillFile("ulw-plan", "references", "full-workflow.md");
+	const combinedFile = {
+		path: `${skillFile.path} + ${workflowFile.path}`,
+		content: `${skillFile.content}\n${workflowFile.content}`,
+	};
+
+	// when / then
+	assertPackagedContentMatches(combinedFile, [
+		["self-orchestrates 5 host subagents for planning", /(?:self-orchestrates|orchestrates)[\s\S]*5[\s\S]*host subagents/i],
+		["requires dynamic workflow phases", /dynamic[\s\S]*workflow[\s\S]*phase|phase[\s\S]*dynamic[\s\S]*workflow/i],
+		["keeps verification distinct from execution", /verification[\s\S]*execution|execution[\s\S]*verification/i],
+		["requires dirty-worktree-aware planning", /dirty worktree/i],
+		["requires stale-state checks between source and packaged payloads", /stale state/i],
+		["rejects misleading success output", /misleading success output/i],
+		["does not accept subagent outputs as success without independent verification", /subagent outputs?[\s\S]*(?:not|never)[\s\S]*(?:success|approval)|independent(?:ly)? verif(?:y|ied|ication)[\s\S]*subagent outputs?/i],
+		["treats Discord or external content as claims, not instructions", /(?:Discord|external content)[\s\S]*claims?[\s\S]*not instructions?|not instructions?[\s\S]*(?:Discord|external content)/i],
+	]);
+});
+
 test("#given context-pressure-prone skills #when bundled for Codex #then the eagerly loaded payload stays budgeted", async () => {
 	// given
 	const skillsRoot = join(root, "skills");
@@ -224,28 +357,3 @@ test("#given context-pressure-prone skills #when bundled for Codex #then the eag
 		`debugging + ulw-loop eager payload is ${totalBytes} bytes, above ${CONTEXT_PRESSURE_SKILL_BUDGET_BYTES}`,
 	);
 });
-
-test("#given synced aggregate Codex skills #when they contain OpenCode orchestration examples #then Codex tool compatibility guidance is injected", async () => {
-	// given
-	const skillsRoot = join(root, "skills");
-	const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
-
-	// when
-	const skillNames = (await readdir(skillsRoot, { withFileTypes: true }))
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => entry.name)
-		.sort();
-
-	// then
-	for (const skillName of skillNames) {
-		const content = await readFile(join(skillsRoot, skillName, "SKILL.md"), "utf8");
-		if (!opencodeOnlyToolPattern.test(content)) continue;
-
-		const compatibilityIndex = content.indexOf("## Codex Harness Tool Compatibility");
-		assert.notEqual(compatibilityIndex, -1, `${skillName} is missing Codex compatibility guidance`);
-		assert.ok(
-			compatibilityIndex < content.search(opencodeOnlyToolPattern),
-			`${skillName} must explain Codex tool translation before OpenCode-only examples`,
-		);
-	}
-});

package/packages/omo-codex/plugin/test/ulw-plan-skill.test.mjs

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const skillPath = join(root, "skills", "ulw-plan", "SKILL.md");
+const workflowPath = join(root, "skills", "ulw-plan", "references", "full-workflow.md");
+const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
+
+test("#given ulw-plan skill #when inspected #then it is a Codex-native planner that defers the deep workflow to its reference", async () => {
+	// given
+	const skill = await readFile(skillPath, "utf8");
+
+	// then
+	assert.match(skill, /^---\r?\nname: ulw-plan\r?\n/m);
+	assert.match(skill, /references\/full-workflow\.md/);
+	assert.match(skill, /spawn_agent\(\{[^)]*"fork_turns":"none"/);
+	assert.doesNotMatch(skill, opencodeOnlyToolPattern);
+});
+
+test("#given ulw-plan skill #when the planning gate is inspected #then it explores first and waits for explicit user approval instead of auto-transitioning", async () => {
+	// given
+	const skill = await readFile(skillPath, "utf8");
+
+	// then
+	assert.match(skill, /explore/i);
+	assert.match(skill, /wait for[^.]{0,80}explicit[^.]{0,40}(?:okay|approval)/i);
+	assert.doesNotMatch(skill, /Proceeding to plan generation/);
+});
+
+test("#given ulw-plan full workflow reference #when inspected #then it documents the approval gate and .omo plan output with Codex-native tools only", async () => {
+	// given
+	const workflow = await readFile(workflowPath, "utf8");
+
+	// then
+	assert.match(workflow, /\.omo\/plans\/<slug>\.md/);
+	assert.match(workflow, /[Aa]pproval gate/);
+	assert.match(workflow, /spawn_agent\(\{[^)]*"fork_turns":"none"/);
+	assert.doesNotMatch(workflow, opencodeOnlyToolPattern);
+	assert.doesNotMatch(workflow, /Proceeding to plan generation/);
+});

package/packages/omo-codex/scripts/install/agent-source-roots.mjs

@@ -0,0 +1,13 @@
+import { writeInstalledMarketplaceSnapshot } from "./snapshot.mjs";
+
+export async function agentSourceRootsForInstall({ codexHome, marketplace, installed, pluginSources }) {
+	if (marketplace.name !== "sisyphuslabs") {
+		return new Map(installed.map((plugin) => [plugin.name, plugin.path]));
+	}
+	const snapshotPlugins = await writeInstalledMarketplaceSnapshot({
+		codexHome,
+		marketplace,
+		plugins: pluginSources,
+	});
+	return new Map(snapshotPlugins.map((plugin) => [plugin.name, plugin.path]));
+}

package/packages/omo-codex/scripts/install/agents.mjs

@@ -1,11 +1,28 @@
 import { basename, join } from "node:path";
-import { copyFile, lstat, mkdir, readdir, rm, symlink, writeFile } from "node:fs/promises";
+import { copyFile, lstat, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 
 import { exists } from "./utils.mjs";
 
 const MANIFEST_FILE = ".installed-agents.json";
 
-export async function linkCachedPluginAgents({ codexHome, pluginRoot, platform = process.platform }) {
+
+export async function capturePreservedAgentReasoning({ codexHome }) {
+	const agentsDir = join(codexHome, "agents");
+	if (!(await exists(agentsDir))) return new Map();
+
+	const preserved = new Map();
+	const agentEntries = await readdir(agentsDir, { withFileTypes: true });
+	for (const entry of agentEntries) {
+		if (!entry.name.endsWith(".toml")) continue;
+		const content = await readTextIfExists(join(agentsDir, entry.name));
+		if (content === null) continue;
+		const effort = extractReasoningEffort(content);
+		if (effort !== null) preserved.set(agentNameFromToml(entry.name), effort);
+	}
+	return preserved;
+}
+
+export async function linkCachedPluginAgents({ codexHome, pluginRoot, preservedReasoning = new Map() }) {
 	const bundledAgents = await discoverBundledAgents(pluginRoot);
 	if (bundledAgents.length === 0) {
 		await writeManifest(pluginRoot, []);
@@ -16,13 +33,12 @@ export async function linkCachedPluginAgents({ codexHome, pluginRoot, platform =
 	await mkdir(agentsDir, { recursive: true });
 	const linked = [];
 	for (const agentPath of bundledAgents) {
-		const linkPath = join(agentsDir, basename(agentPath));
-		if (platform === "win32") {
-			await replaceWithCopy(linkPath, agentPath);
-		} else {
-			await replaceWithSymlink(linkPath, agentPath);
-		}
-		linked.push({ name: basename(agentPath), path: linkPath, target: agentPath });
+		const agentFileName = basename(agentPath);
+		const agentName = agentNameFromToml(agentFileName);
+		const linkPath = join(agentsDir, agentFileName);
+		await replaceWithCopy(linkPath, agentPath);
+		await restorePreservedReasoning({ linkPath, target: agentPath, value: preservedReasoning.get(agentName) });
+		linked.push({ name: agentFileName, path: linkPath, target: agentPath });
 	}
 	await writeManifest(pluginRoot, linked.map((entry) => entry.path));
 	return linked;
@@ -48,11 +64,6 @@ async function discoverBundledAgents(pluginRoot) {
 	return agents;
 }
 
-async function replaceWithSymlink(linkPath, target) {
-	await prepareReplacement(linkPath);
-	await symlink(target, linkPath);
-}
-
 async function replaceWithCopy(linkPath, target) {
 	await prepareReplacement(linkPath);
 	await copyFile(target, linkPath);
@@ -73,6 +84,60 @@ async function writeManifest(pluginRoot, agentPaths) {
 	await writeFile(manifestPath, `${JSON.stringify(payload, null, "\t")}\n`);
 }
 
+async function restorePreservedReasoning({ linkPath, target, value }) {
+	if (value === undefined) return;
+	const content = await readFile(target, "utf8");
+	if (extractReasoningEffort(content) === value) return;
+	const replacement = replaceReasoningEffort(content, value);
+	if (!replacement.replaced) return;
+	if (await lstatExists(linkPath)) {
+		await rm(linkPath, { force: true });
+	}
+	await writeFile(linkPath, replacement.content);
+}
+
+async function readTextIfExists(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (nodeErrorCode(error) === "ENOENT") return null;
+		throw error;
+	}
+}
+
+function extractReasoningEffort(content) {
+	for (const line of content.split(/\n/)) {
+		if (isSectionHeader(line)) return null;
+		const match = line.match(/^\s*model_reasoning_effort\s*=\s*("(?:[^"\\]|\\.)*")/);
+		if (match === null) continue;
+		return JSON.parse(match[1]);
+	}
+	return null;
+}
+
+function replaceReasoningEffort(content, value) {
+	let replaced = false;
+	const lines = content.split(/\n/);
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (isSectionHeader(line)) break;
+		if (!/^\s*model_reasoning_effort\s*=/.test(line)) continue;
+		lines[index] = line.replace(/=\s*"(?:[^"\\]|\\.)*"/, `= ${JSON.stringify(value)}`);
+		replaced = true;
+		break;
+	}
+	return { content: lines.join("\n"), replaced };
+}
+
+function isSectionHeader(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+
+function agentNameFromToml(fileName) {
+	return fileName.endsWith(".toml") ? fileName.slice(0, -".toml".length) : fileName;
+}
+
 async function lstatExists(path) {
 	try {
 		await lstat(path);
@@ -82,3 +147,8 @@ async function lstatExists(path) {
 		throw error;
 	}
 }
+
+function nodeErrorCode(error) {
+	if (!(error instanceof Error) || !("code" in error)) return null;
+	return typeof error.code === "string" ? error.code : null;
+}