oh-my-opencode 4.13.0 → 4.14.1

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-safety-fixture.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -42,6 +42,46 @@ export function runTeamRaw(cwd, ...args) {
 	});
 }
 
+export function runTeamRawWithEnv(cwd, env, ...args) {
+	return spawnSync(process.execPath, [teamScript, ...args], {
+		cwd,
+		encoding: "utf8",
+		env: { ...process.env, ...env },
+		timeout: 10_000,
+	});
+}
+
+export function runTeamAsync(cwd, ...args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [teamScript, ...args], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		let stdout = "";
+		let stderr = "";
+		const timer = setTimeout(() => {
+			child.kill("SIGKILL");
+			reject(new Error(`team.mjs ${args.join(" ")} timed out`));
+		}, 10_000);
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+		child.on("close", (status, signal) => {
+			clearTimeout(timer);
+			resolve({ status, signal, stdout, stderr });
+		});
+	});
+}
+
 export function symlinkOrSkip(t, target, path, type) {
 	try {
 		symlinkSync(target, path, type);

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

@@ -10,7 +10,9 @@ import {
 	createTeamRoot,
 	readTeamJson,
 	runTeam,
+	runTeamAsync,
 	runTeamRaw,
+	runTeamRawWithEnv,
 	symlinkOrSkip,
 	teamDir,
 	teamJsonPath,
@@ -82,6 +84,97 @@ test("#given member A exists #when add-member receives A with trailing space #th
 	}
 });
 
+test("#given two add-member commands run concurrently #then both successful mutations are preserved", async () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-concurrent-add-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Concurrent", "--session-name", "Members", "--session", "safe-concurrent-add");
+
+		const [alpha, beta] = await Promise.all([
+			runTeamAsync(
+				tempRoot,
+				"add-member",
+				"--team",
+				"safe-concurrent-add",
+				"--id",
+				"A",
+				"--name",
+				"alpha",
+				"--focus",
+				"alpha",
+				"--lens",
+				"area",
+				"--deliverable",
+				"first",
+			),
+			runTeamAsync(
+				tempRoot,
+				"add-member",
+				"--team",
+				"safe-concurrent-add",
+				"--id",
+				"B",
+				"--name",
+				"beta",
+				"--focus",
+				"beta",
+				"--lens",
+				"perspective",
+				"--deliverable",
+				"second",
+			),
+		]);
+		const team = readTeamJson(tempRoot, "safe-concurrent-add");
+
+		assert.equal(alpha.status, 0, alpha.stderr);
+		assert.equal(beta.status, 0, beta.stderr);
+		assert.deepEqual(
+			team.members.map((member) => member.id).sort(),
+			["A", "B"],
+		);
+		assert.equal(team.log.filter((entry) => entry.event === "add-member").length, 2);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given another command holds the team lock #when add-member times out #then it fails without mutating team state", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-lock-timeout-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Locked", "--session-name", "Members", "--session", "safe-lock-timeout");
+		const lockDir = join(teamDir(tempRoot, "safe-lock-timeout"), ".team.lock");
+		mkdirSync(lockDir);
+		writeFileSync(
+			join(lockDir, "owner.json"),
+			`${JSON.stringify({ command: "held-test", pid: 12345, createdAt: "2026-06-30T00:00:00.000Z" }, null, 2)}\n`,
+		);
+
+		const result = runTeamRawWithEnv(
+			tempRoot,
+			{ OMO_TEAMMODE_LOCK_TIMEOUT_MS: "25", OMO_TEAMMODE_LOCK_RETRY_MS: "5" },
+			"add-member",
+			"--team",
+			"safe-lock-timeout",
+			"--id",
+			"A",
+			"--name",
+			"alpha",
+			"--focus",
+			"alpha",
+			"--lens",
+			"area",
+			"--deliverable",
+			"first",
+		);
+		const team = readTeamJson(tempRoot, "safe-lock-timeout");
+
+		assert.notEqual(result.status, 0);
+		assert.match(result.stderr, /team state is locked by held-test, pid 12345/);
+		assert.deepEqual(team.members, []);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
 test("#given member focus already exists #when add-member receives same focus with different spacing and case #then state is not partially mutated", () => {
 	const tempRoot = createTeamRoot("omo-codex-teammode-duplicate-focus-");
 	try {

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 () => {
@@ -242,6 +247,8 @@ test("#given nested component declares reserved omo bin #when linking bins #then
 		bin: {
 			omo: "./dist/cli.js",
 			"omo-ulw-loop": "./dist/cli.js",
+			ulw: "./dist/cli.js",
+			"ulw-loop": "./dist/cli.js",
 		},
 	});
 	await writeFile(join(componentRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
@@ -250,9 +257,13 @@ test("#given nested component declares reserved omo bin #when linking bins #then
 
 	assert.deepEqual(linked, [
 		{ name: "omo-ulw-loop", path: join(binDir, "omo-ulw-loop"), target: join(componentRoot, "dist", "cli.js") },
+		{ name: "ulw", path: join(binDir, "ulw"), target: join(componentRoot, "dist", "cli.js") },
+		{ name: "ulw-loop", path: join(binDir, "ulw-loop"), target: join(componentRoot, "dist", "cli.js") },
 	]);
 	await assert.rejects(readlink(join(binDir, "omo")));
 	assert.equal(await readlink(join(binDir, "omo-ulw-loop")), join(componentRoot, "dist", "cli.js"));
+	assert.equal(await readlink(join(binDir, "ulw")), join(componentRoot, "dist", "cli.js"));
+	assert.equal(await readlink(join(binDir, "ulw-loop")), join(componentRoot, "dist", "cli.js"));
 });
 
 test("#given stale managed ulw-loop omo symlink #when linking bins #then removes it without touching user-owned omo", async () => {