oh-my-opencode 4.13.0 → 4.14.0

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

@@ -6,6 +6,7 @@ export const CONTEXT_PRESSURE_SKILL_BUDGET_BYTES = 25_000;
 
 export const expectedSkills = [
 	"ast-grep",
+	"coding-agent-sessions",
 	"comment-checker",
 	"debugging",
 	"frontend",
@@ -27,6 +28,7 @@ export const expectedSkills = [
 	"ultraresearch",
 	"ulw-loop",
 	"ulw-plan",
+	"ulw-research",
 	"visual-qa",
 ];
 
@@ -41,6 +43,7 @@ export const componentSkillSources = [
 
 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 `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived. Treat a running child as alive. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.\n\n",
+	"On `multi_agent_v2` sessions the same `agent_type` applies (the OMO installer exposes it) with `fork_turns` instead of `fork_context`. If a code block below conflicts with this section, this section wins.\n\n",
 	"Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. 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",
@@ -64,29 +67,29 @@ export function removeCodexCompatibilityGuidance(content) {
 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.
+2. For PR/branch work, finish the lifecycle from the task-owned worktree: sync \`.omo/\` state back to the main repo, create or update the PR, wait for review/verification gates, merge by default unless explicitly opted out, 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:
+2. Complete the **Global Review and Debugging Gate** before any completion claim, PR creation, PR handoff, branch handoff, or merge:
    - 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.
+   - If the work includes creating, updating, or handing off a PR, refresh \`git status\` and the PR/branch state from the task-owned worktree after the gate, and include only redacted review/debugging evidence in the PR body or handoff.
+3. Finish the PR/branch lifecycle from its task-owned worktree: sync \`.omo/\` state back to the main repo, create or update the PR when requested, wait for CI/review/Cubic gates, merge by default unless explicitly opted out, 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 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 PR/branch implementation, review, or merge in the main worktree; use the task-owned git worktree.\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 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, PR handoff, or merge before the Global Review and Debugging Gate passes with recorded evidence.\n- No PR/branch implementation or review in the main worktree; create or use a task-owned git worktree first.\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/;
+	/\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, creating or handing off a PR, or merging\.\n\nWhen reviewing a PR or branch, collect diff, file contents, and verification\nresults from a dedicated review worktree attached to that branch\. Never\ncheckout, test, or edit the review branch in the main worktree\.\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/;
 
 export function removeCodexSkillOverlays(skillName, content) {
 	if (skillName === "start-work") {

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

@@ -112,10 +112,22 @@ test("#given shared skill source tests #when aggregate Codex skills are synced #
 	const aggregateSkillsRoot = join(root, "skills");
 
 	// when
-	const visualQaFiles = await listSkillFiles(join(aggregateSkillsRoot, "visual-qa"));
+	const forbiddenFiles = [];
+	for (const skillName of expectedSkills) {
+		for (const file of await listSkillFiles(join(aggregateSkillsRoot, skillName))) {
+			const normalized = file.replaceAll("\\", "/");
+			const segments = normalized.split("/");
+			const scriptsIndex = segments.lastIndexOf("scripts");
+			const hasPythonTestDir = scriptsIndex !== -1 && segments[scriptsIndex + 1] === "tests";
+			const isSourceMetadata = normalized === ".gitignore" || normalized === ".npmignore" || normalized === "pyrightconfig.json";
+			if (normalized.endsWith(".test.ts") || hasPythonTestDir || segments.includes("__pycache__") || normalized.endsWith(".pyc") || isSourceMetadata) {
+				forbiddenFiles.push(`${skillName}/${normalized}`);
+			}
+		}
+	}
 
 	// then
-	assert.equal(visualQaFiles.some((file) => file.endsWith(".test.ts")), false);
+	assert.deepEqual(forbiddenFiles, []);
 });
 
 test("#given component skill sources #when aggregate Codex component skills are inspected #then generated copies have no hand-authored drift", async () => {
@@ -169,6 +181,20 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 	assert.match(interfaceMetadata, /- "ulw-loop"/);
 });
 
+test("#given synced legacy ultraresearch alias #when inspected #then it points users at ulw-research", async () => {
+	// given
+	const skillRoot = join(root, "skills", "ultraresearch");
+
+	// 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: ultraresearch\r?\n/m);
+	assert.match(skill, /legacy name for `ulw-research`/);
+	assert.match(interfaceMetadata, /display_name: "\(OmO\) ultraresearch"/);
+});
+
 test("#given synced git-master skill #when inspected #then commits and git history route through it", async () => {
 	// given
 	const skillRoot = join(root, "skills", "git-master");

package/packages/omo-codex/plugin/test/teammode-communication.test.mjs

@@ -53,6 +53,9 @@ test("#given a bound team #when the member field manual renders #then it gives c
 		// then - an explicit peer-notify rule so cross-cutting findings are pushed, not siloed
 		assert.match(guide, /to a \*\*peer\*\*/, "guide must have an explicit peer-notify rule");
 		assert.match(guide, /touches their slice/, "guide must trigger peer messages on slice-touching findings");
+		// then - the reassurance WHY that ties the two halves together: frequent reporting is what earns
+		// uninterrupted focus, so the leader has no reason to interrupt a member who keeps it informed
+		assert.match(guide, /uninterrupted focus/i, "guide must tell members frequent updates buy uninterrupted focus from the leader");
 		// then - the end-only directive that previously won is gone (it licensed batch-at-the-end reporting)
 		assert.doesNotMatch(guide, /the moment your work is complete/, "the standalone end-only report directive must be removed");
 	} finally {
@@ -85,3 +88,20 @@ test("#given the leader-facing SKILL.md #when it describes communication #then i
 	assert.match(skill, /--session <your own thread id>/, "SKILL.md must require init --session <your own thread id>");
 	assert.match(skill, /stuck polling|cannot report to you/i, "SKILL.md must explain why --session matters");
 });
+
+// The leader (a GPT-5.5 main session) over-polls when nothing reframes silence as work: real jobdori
+// run 019f07a6- fired 6 leader->child pings, 4 pure "WORKING CHECK"/"NUDGE" nags that interrupted the
+// child mid-slice. The member guide already mandates frequent reporting; the missing half is telling the
+// leader to WAIT. These tests pin that the leader-facing skill reframes quiet-as-working and gates any
+// outbound ping behind concrete decision rules instead of letting anxiety drive a barrage.
+test("#given the leader-facing SKILL.md #when it covers waiting on members #then it reframes a quiet member as working and gates leader pings behind decision rules", () => {
+	const skill = readFileSync(join(root, "components", "teammode", "skills", "teammode", "SKILL.md"), "utf8");
+
+	// then - a quiet member between heartbeats is reframed as working, not a stall to chase
+	// (\s+ tolerates markdown line-wrapping between the two words)
+	assert.match(skill, /working,\s+not stalled/i, "SKILL.md must reframe a quiet member as working, not stalled");
+	// then - outbound leader messages are gated behind explicit decision rules, not anxiety
+	assert.match(skill, /Message a member only when/i, "SKILL.md must gate leader pings behind a concrete decision rule");
+	// then - the anti-pattern nag pings the real run produced are named as what NOT to send
+	assert.match(skill, /are you\s+done\?/i, "SKILL.md must name the 'are you done?' style nag as forbidden");
+});

package/packages/omo-codex/plugin/test/teammode-thread-links.test.mjs

@@ -0,0 +1,117 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+import { cleanupTeamRoot, createTeamRoot, runTeam, teamDir } from "./teammode-safety-fixture.mjs";
+
+function addMember(tempRoot, sessionId, { id, name, focus, lens, deliverable }) {
+	runTeam(
+		tempRoot,
+		"add-member",
+		"--team",
+		sessionId,
+		"--id",
+		id,
+		"--name",
+		name,
+		"--focus",
+		focus,
+		"--lens",
+		lens,
+		"--deliverable",
+		deliverable,
+	);
+}
+
+test("#given a worktree-backed team has bound member threads #when guide and status render #then they include codex thread links", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-thread-links-");
+	try {
+		const sessionId = "thread-links";
+		runTeam(tempRoot, "init", "--name", "Review", "--session-name", "worktrees", "--session", sessionId, "--worktree");
+		addMember(tempRoot, sessionId, {
+			id: "A",
+			name: "qa-review-r2",
+			focus: "review PR 545 QA audit",
+			lens: "perspective",
+			deliverable: "write qa-review artifact",
+		});
+		addMember(tempRoot, sessionId, {
+			id: "B",
+			name: "pr-driver",
+			focus: "drive PR readiness",
+			lens: "ownership",
+			deliverable: "prepare review handoff",
+		});
+		runTeam(
+			tempRoot,
+			"bind-thread",
+			"--team",
+			sessionId,
+			"--id",
+			"A",
+			"--thread",
+			"019ef350-ee78-72a3-bd5e-e40cebc3d814",
+			"--cwd",
+			"/tmp/review-worktree",
+		);
+		runTeam(
+			tempRoot,
+			"bind-thread",
+			"--team",
+			sessionId,
+			"--id",
+			"B",
+			"--thread",
+			"019ef2dd-5b99-7ae2-8461-ffa6ca309d23",
+			"--cwd",
+			"/tmp/pr-driver-worktree",
+		);
+
+		const guide = readFileSync(`${teamDir(tempRoot, sessionId)}/guide.md`, "utf8");
+		const status = runTeam(tempRoot, "status", "--team", sessionId).stdout;
+		const prompt = runTeam(tempRoot, "member-prompt", "--team", sessionId, "--id", "A").stdout;
+
+		assert.match(guide, /codex:\/\/threads\/019ef350-ee78-72a3-bd5e-e40cebc3d814/);
+		assert.match(guide, /codex:\/\/threads\/019ef2dd-5b99-7ae2-8461-ffa6ca309d23/);
+		assert.match(guide, /worktree `\/tmp\/review-worktree`/);
+		assert.match(status, /link=codex:\/\/threads\/019ef350-ee78-72a3-bd5e-e40cebc3d814/);
+		assert.match(prompt, /Your Codex thread link is codex:\/\/threads\/019ef350-ee78-72a3-bd5e-e40cebc3d814/);
+		assert.match(prompt, /Work inside `\/tmp\/review-worktree`/);
+		assert.match(prompt, /Before editing, verify that your assigned worktree exists and contains repo files/);
+		assert.match(prompt, /BLOCKED: worktree not ready/);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a worktree member has no cwd bound yet #when guide and prompt render #then they tell Codex to wait for readiness", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-worktree-wait-");
+	try {
+		const sessionId = "worktree-wait";
+		runTeam(tempRoot, "init", "--name", "Wait", "--session-name", "worktrees", "--session", sessionId, "--worktree", "--base-branch", "main");
+		addMember(tempRoot, sessionId, {
+			id: "A",
+			name: "worktree-driver",
+			focus: "drive a pending Codex worktree thread",
+			lens: "ownership",
+			deliverable: "ready worktree report",
+		});
+		addMember(tempRoot, sessionId, {
+			id: "B",
+			name: "integration-watch",
+			focus: "watch integration boundaries",
+			lens: "perspective",
+			deliverable: "integration notes",
+		});
+		runTeam(tempRoot, "bind-thread", "--team", sessionId, "--id", "A", "--thread", "019ef350-ee78-72a3-bd5e-e40cebc3d814");
+
+		const guide = readFileSync(`${teamDir(tempRoot, sessionId)}/guide.md`, "utf8");
+		const prompt = runTeam(tempRoot, "member-prompt", "--team", sessionId, "--id", "A").stdout;
+
+		assert.match(guide, /If Codex returns only `pendingWorktreeId`/);
+		assert.match(guide, /wait until Codex surfaces a real thread id/);
+		assert.match(prompt, /If this prompt arrived before your Codex worktree checkout is ready/);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});

package/packages/omo-codex/plugin/test/teammode-worktree.test.mjs

@@ -78,9 +78,12 @@ test("#given a worktree team #when worktree-add A #then a real git worktree on a
 		assert.equal(member.worktree.branch, expectedBranch);
 		assert.ok(samePath(member.cwd, expectedPath), "cwd must be the member worktree dir");
 
-		// then - the leader is told the exact cd target
-		assert.match(result.stdout, /cd /);
+		// then - the leader is told the exact worktree target without prompting an unbound member
+		assert.match(result.stdout, new RegExp(expectedPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
 		assert.match(result.stdout, /A/);
+		assert.match(result.stdout, /wait for the real Codex thread id/);
+		assert.match(result.stdout, /bind-thread before sending bootstrap/);
+		assert.doesNotMatch(result.stdout, /Tell that member to:/);
 	} finally {
 		cleanupTeamRoot(tempRoot);
 	}

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

@@ -0,0 +1,285 @@
+// allow: SIZE_OK - ULW research skill contract tests inspect one bundled prompt protocol; this release introduces the contract and future additions should split by protocol phase.
+
+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";
+import { sharedSkillsRootPath } from "@oh-my-opencode/shared-skills";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+async function readUlwResearchCopies() {
+	const sharedPath = join(sharedSkillsRootPath(), "ulw-research", "SKILL.md");
+	const packagedPath = join(root, "skills", "ulw-research", "SKILL.md");
+	return [
+		{ label: "shared", path: sharedPath, content: await readFile(sharedPath, "utf8") },
+		{ label: "packaged", path: packagedPath, content: await readFile(packagedPath, "utf8") },
+	];
+}
+
+function frontmatterDescription(content) {
+	const match = content.match(/^---\r?\n[\s\S]*?\bdescription:\s*"([\s\S]*?)"\r?\n[\s\S]*?---/);
+	assert.notEqual(match, null, "SKILL.md frontmatter description not found");
+	return match[1];
+}
+
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function markdownSection(content, heading, nextHeading) {
+	const headingPattern = new RegExp(`^${escapeRegExp(heading)}\\r?$`, "m");
+	const headingMatch = content.match(headingPattern);
+	assert.notEqual(headingMatch, null, `SKILL.md section not found: ${heading}`);
+	assert.notEqual(headingMatch.index, undefined, `SKILL.md section index not found: ${heading}`);
+	const bodyStart = headingMatch.index + headingMatch[0].length;
+	if (nextHeading === undefined) {
+		return content.slice(bodyStart);
+	}
+	const nextHeadingIndex = content.indexOf(`\n${nextHeading}`, bodyStart);
+	assert.notEqual(nextHeadingIndex, -1, `SKILL.md next section not found: ${nextHeading}`);
+	return content.slice(bodyStart, nextHeadingIndex);
+}
+
+test("#given renamed research skill #when frontmatter is inspected #then ulw-research is the canonical name", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(copy.content, /^name: ulw-research$/m, `${copy.label}: frontmatter must expose ulw-research`);
+	}
+});
+
+test("#given renamed research skill #when activation marker is inspected #then ulw-research is the canonical marker", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/`ULW-RESEARCH MODE ENABLED!`/,
+			`${copy.label}: body must expose the ulw-research activation marker`,
+		);
+		assert.doesNotMatch(
+			copy.content,
+			/`ULTRARESEARCH MODE ENABLED!`/,
+			`${copy.label}: body must not expose the old ultraresearch activation marker`,
+		);
+	}
+});
+
+test("#given ulw-research skill #when scanned for non-English content #then it contains no Hangul", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.doesNotMatch(
+			copy.content,
+			/[ᄀ-ᇿ㄰-㆏가-힣]/,
+			`${copy.label} copy contains Hangul characters`,
+		);
+	}
+});
+
+test("#given ulw-research description #when activation policy is inspected #then it gates on explicit research demands only", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		const description = frontmatterDescription(copy.content);
+		assert.match(description, /ulw-research/i, `${copy.label}: description must name the ulw-research trigger`);
+		assert.match(description, /ultraresearch/i, `${copy.label}: description must preserve ultraresearch discoverability`);
+		assert.match(description, /\bulw\b/i, `${copy.label}: description must preserve ulw discoverability`);
+		assert.match(description, /explicit/i, `${copy.label}: description must gate activation on explicit demand`);
+		assert.match(
+			description,
+			/ultra-precise investigation/i,
+			`${copy.label}: description must name the ultra-precise investigation trigger`,
+		);
+		assert.match(description, /\bresearch\b/i, `${copy.label}: description must name the research trigger`);
+	}
+});
+
+test("#given ulw-research body #when authority is inspected #then it takes precedence over exploration-bounding instructions", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/exploration-bounding|exploration (?:caps|budgets|limits)/i,
+			`${copy.label}: body must name the exploration-bounding instructions it overrides`,
+		);
+		assert.match(
+			copy.content,
+			/supersede|override|do(?:es)? not (?:bind|apply)/i,
+			`${copy.label}: body must state precedence while the mode is active`,
+		);
+	}
+});
+
+test("#given ulw-research worker protocol #when EXPAND flow is inspected #then markers travel as message text and workers never write files", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(copy.content, /EXPAND/, `${copy.label}: body must keep the EXPAND marker protocol`);
+		assert.match(
+			copy.content,
+			/(?:reply|message|response) text|end (?:its|the|your) (?:reply|response|final message)/i,
+			`${copy.label}: EXPAND markers must be returned as message text`,
+		);
+		assert.match(
+			copy.content,
+			/read-only|cannot write files|never ask (?:a )?worker(?:s)? to write/i,
+			`${copy.label}: body must state the read-only worker constraint`,
+		);
+		assert.doesNotMatch(
+			copy.content,
+			/APPEND (?:your )?findings to \$SESSION_DIR/i,
+			`${copy.label}: workers must not be instructed to append session-dir files`,
+		);
+	}
+});
+
+test("#given ulw-research journaling #when ownership is inspected #then the orchestrator owns the session journal", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/orchestrator[\s\S]{0,200}journal|journal[\s\S]{0,200}orchestrator/i,
+			`${copy.label}: body must assign session-journal writes to the orchestrator`,
+		);
+		assert.match(copy.content, /SESSION_DIR/, `${copy.label}: body must keep the session directory protocol`);
+	}
+});
+
+test("#given ulw-research expansion loop #when stop rules are inspected #then convergence rules and a depth cap are stated", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(copy.content, /converg/i, `${copy.label}: body must define convergence`);
+		assert.match(copy.content, /depth/i, `${copy.label}: body must define an expansion depth cap`);
+		assert.match(
+			copy.content,
+			/minimum (?:of )?(?:2|two) expansion waves|at least (?:2|two) expansion waves/i,
+			`${copy.label}: body must require a minimum of two expansion waves before convergence`,
+		);
+	}
+});
+
+test("#given ulw-research under ultrawork #when coexistence is inspected #then marker and done-definition conflicts are resolved", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(copy.content, /ultrawork|\bulw\b/i, `${copy.label}: body must address ultrawork coexistence`);
+		assert.match(
+			copy.content,
+			/first(?:-| )line/i,
+			`${copy.label}: body must resolve the first-line activation marker conflict`,
+		);
+	}
+});
+
+test("#given ulw-research worker sizing #when spawn guidance is inspected #then capable-model and high-effort routing is stated", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/capable model|high(?:est)? (?:reasoning )?effort/i,
+			`${copy.label}: body must route research workers to a capable model or high effort`,
+		);
+	}
+});
+
+test("#given ulw-research execution substrate #when team usage is inspected #then it prefers a cooperating team with harness-native team tools", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/cooperating team/i,
+			`${copy.label}: body must encourage running the swarm as a cooperating team`,
+		);
+		assert.match(copy.content, /\bteammode\b/i, `${copy.label}: body must name the Codex teammode skill`);
+		assert.match(copy.content, /team_mode/i, `${copy.label}: body must name the OpenCode team_mode path`);
+	}
+});
+
+test("#given ulw-research team composition #when member slicing is inspected #then members map to part/ownership/perspective, never job titles", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/by part, ownership, or perspective/i,
+			`${copy.label}: body must compose members by part, ownership, or perspective`,
+		);
+		assert.match(
+			copy.content,
+			/never a job title|not (?:a |by )?job title/i,
+			`${copy.label}: body must forbid vague job-title members`,
+		);
+	}
+});
+
+test("#given ulw-research team communication #when the raise law is inspected #then members broadcast every lead immediately rather than hoarding", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/raise law|broadcast every lead/i,
+			`${copy.label}: body must state the raise/broadcast law`,
+		);
+		assert.match(copy.content, /over-communicate/i, `${copy.label}: body must demand over-communication`);
+		assert.match(
+			copy.content,
+			/the (?:moment|instant) it (?:surfaces|appears|lands)/i,
+			`${copy.label}: body must require raising leads the moment they surface`,
+		);
+		assert.match(
+			copy.content,
+			/hoard/i,
+			`${copy.label}: body must reject hoarding leads for a final dump`,
+		);
+	}
+});
+
+test("#given ulw-research default swarm #when team guidance is inspected #then teammode, many teammates, and hyperdebate are defaulted", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		const teamSection = markdownSection(copy.content, "## Run the swarm as a cooperating team", "## Worker ground rules");
+		assert.match(teamSection, /default(?:s)? to teammode|teammode by default/i, `${copy.label}: teammode must be the default`);
+		assert.match(teamSection, /many teammates|larger roster|5-8 teammates|5\+ teammates/i, `${copy.label}: body must prefer many teammates`);
+		assert.match(teamSection, /hyperdebate|ultradebate/i, `${copy.label}: body must require adversarial debate`);
+		assert.match(teamSection, /skeptic|red-team|cross-critique/i, `${copy.label}: body must include a critique perspective`);
+	}
+});
+
+test("#given ulw-research non-code verification #when the gate is inspected #then a claim ledger / verified-claims data-flow-lock exists", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/claim ledger|verified-claims/i,
+			`${copy.label}: body must define the non-code claim-ledger verification gate`,
+		);
+	}
+});
+
+test("#given ulw-research claim ledger #when ownership is inspected #then workers never write the ledger / verified-claims artifact", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.doesNotMatch(
+			copy.content,
+			/worker[^.]*\b(?:write|append|create)s?\b[^.]*(?:ledger|verified-claims)/i,
+			`${copy.label}: workers must not be instructed to write/append/create the ledger or verified-claims`,
+		);
+	}
+});
+
+test("#given ulw-research report output #when defaults are inspected #then HTML/PDF reports go through frontend, visual QA, and reviewer approval", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		const phase0 = markdownSection(copy.content, "## Phase 0 — Decompose and open the journal", "## Phase 1 — Saturation wave");
+		const phase4 = markdownSection(copy.content, "## Phase 4 — Synthesize", "## Phase 5 — Final materials");
+		const phase5 = markdownSection(copy.content, "## Phase 5 — Final materials", "## Search craft");
+		assert.match(phase0, /Final material format:\s*<HTML\/PDF default \| explicit format \| markdown only>/, `${copy.label}: Phase 0 must track the default final-material contract`);
+		assert.match(phase4, /citation source of truth/i, `${copy.label}: Phase 4 synthesis must be a source of truth, not the default final artifact`);
+		assert.doesNotMatch(phase4, /When no report was requested, this is the deliverable/i, `${copy.label}: Phase 4 must not contradict default HTML/PDF final materials`);
+		assert.match(phase5, /Default final materials to HTML\/PDF unless the user explicitly asks/i, `${copy.label}: Phase 5 must default final materials to HTML/PDF`);
+		assert.match(phase5, /HTML first[\s\S]{0,120}PDF default/i, `${copy.label}: report output must default to HTML with PDF availability`);
+		assert.match(phase5, /\bfrontend\b/i, `${copy.label}: report assembly must load the frontend skill`);
+		assert.match(phase5, /visual-qa/i, `${copy.label}: report assembly must require visual-qa`);
+		assert.match(phase5, /ulw-loop|ULW loop/i, `${copy.label}: report QA must run under the ULW loop`);
+		assert.match(phase5, /reviewer[\s\S]{0,120}(?:approve|says no broken parts|no broken parts)/i, `${copy.label}: report completion must wait for reviewer approval`);
+	}
+});
+
+test("#given ulw-research final materials #when visual artifact guidance is inspected #then charts Mermaid graphs and imagegen are strongly required", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		const phase5 = markdownSection(copy.content, "## Phase 5 — Final materials", "## Search craft");
+		assert.match(phase5, /actively use charts/i, `${copy.label}: reports must strongly require charts`);
+		assert.match(phase5, /Mermaid graphs/i, `${copy.label}: reports must require Mermaid graphs`);
+		assert.match(phase5, /imagegen skill/i, `${copy.label}: reports must require imagegen visuals`);
+		assert.match(phase5, /generated (?:diagrams|visuals)|generated diagrams or editorial visuals/i, `${copy.label}: report assets must include generated visual guidance`);
+	}
+});
+
+test("#given ulw-research blocked sources #when escalation is inspected #then it routes through the ultimate-browsing skill", async () => {
+	for (const copy of await readUlwResearchCopies()) {
+		assert.match(
+			copy.content,
+			/ultimate-browsing/,
+			`${copy.label}: body must escalate blocked sources via the ultimate-browsing skill`,
+		);
+	}
+});

package/packages/omo-codex/scripts/install-bin-links.test.mjs

@@ -1,3 +1,5 @@
+// allow: SIZE_OK - bin link installer tests share one cross-platform link fixture; this release adds narrow link cases and future additions should split by platform family.
+
 import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import { chmod, lstat, mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
@@ -154,7 +156,10 @@ test("#given Windows platform #when linking cached plugin bins #then writes comm
 	assert.deepEqual(linked, [{ name: "alpha", path: join(binDir, "alpha.cmd"), target: join(pluginRoot, "dist", "cli.js") }]);
 	const shim = await readFile(join(binDir, "alpha.cmd"), "utf8");
 	assert.match(shim, /@echo off/);
-	assert.match(shim, new RegExp(`node "${join(pluginRoot, "dist", "cli.js").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}" %\\*`));
+	assert.match(shim, /NODE_REPL_NODE_PATH/);
+	assert.match(shim, /"%OMO_NODE_BINARY%"/);
+	assert.match(shim, new RegExp(`"${join(pluginRoot, "dist", "cli.js").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}" %\\*`));
+	assert.doesNotMatch(shim, new RegExp(`node "${join(pluginRoot, "dist", "cli.js").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}" %\\*`));
 });
 
 test("#given existing custom Windows command shim #when linking bins #then rejects without overwriting", async () => {

package/packages/omo-codex/scripts/install-cache-copy.test.mjs

@@ -87,6 +87,57 @@ test("#given cached file dependency is rewritten #when lockfile exists #then pac
 	assert.equal(cachedPackageLock.packages["node_modules/@scope/lsp-tools"].resolved, packageLockDependencyPath);
 });
 
+test("#given npm creates workspace bin shims in the cache #when caching plugin #then plugin-owned shims are removed", async () => {
+	// given
+	const root = await makeTempDir();
+	const codexHome = join(root, "codex-home");
+	const sourceRoot = join(root, "plugin");
+	const componentRoot = join(sourceRoot, "components", "ulw-loop");
+	await mkdir(join(componentRoot, "dist"), { recursive: true });
+	await writeFile(
+		join(sourceRoot, "package.json"),
+		JSON.stringify({
+			name: "@scope/omo",
+			version: "0.1.0",
+			workspaces: ["components/ulw-loop"],
+		}),
+	);
+	await writeFile(
+		join(componentRoot, "package.json"),
+		JSON.stringify({
+			name: "@code-yeongyu/codex-ulw-loop",
+			version: "0.1.0",
+			bin: { "omo-ulw-loop": "dist/cli.js" },
+		}),
+	);
+	await writeFile(join(componentRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+
+	// when
+	const installed = await installCachedPlugin({
+		codexHome,
+		marketplaceName: "debug",
+		name: "omo",
+		sourcePath: sourceRoot,
+		version: "0.1.0",
+		runCommand: async (_command, args, options) => {
+			if (args.join(" ") !== "ci --omit=dev") return;
+			const npmBinDir = join(options.cwd, "node_modules", ".bin");
+			await mkdir(npmBinDir, { recursive: true });
+			await writeFile(join(npmBinDir, "omo-ulw-loop"), "#!/bin/sh\nnode ../@code-yeongyu/codex-ulw-loop/dist/cli.js \"$@\"\n");
+			await writeFile(
+				join(npmBinDir, "omo-ulw-loop.cmd"),
+				'@echo off\r\nnode "%~dp0\\..\\@code-yeongyu\\codex-ulw-loop\\dist\\cli.js" %*\r\n',
+			);
+			await writeFile(join(npmBinDir, "other-tool.cmd"), "@echo off\r\necho preserved\r\n");
+		},
+	});
+
+	// then
+	await assert.rejects(stat(join(installed.path, "node_modules", ".bin", "omo-ulw-loop")));
+	await assert.rejects(stat(join(installed.path, "node_modules", ".bin", "omo-ulw-loop.cmd")));
+	assert.equal(await readFile(join(installed.path, "node_modules", ".bin", "other-tool.cmd"), "utf8"), "@echo off\r\necho preserved\r\n");
+});
+
 test("#given existing cache #when npm install fails #then previous active cache is preserved", async () => {
 	// given
 	const root = await makeTempDir();