oh-my-opencode 4.12.1 → 4.13.0

package/packages/omo-codex/plugin/test/auto-update-restart-notice.test.mjs

@@ -9,8 +9,6 @@ import { fileURLToPath } from "node:url";
 import { resolveAutoUpdatePlan, runAutoUpdateCheck } from "../scripts/auto-update.mjs";
 
 const SCRIPT_PATH = fileURLToPath(new URL("../scripts/auto-update.mjs", import.meta.url));
-const STARTED_NOTICE =
-	"[LazyCodex] Auto-update started in the background: v1.0.0 -> v1.0.1. Tell the user a new LazyCodex version is installing and that they should start a new Codex session after it completes to apply it.";
 const COMPLETED_NOTICE =
 	"[LazyCodex] Auto-update completed: v1.0.0 -> v1.0.1. This session is already running the new version. Tell the user the auto-update was applied.";
 
@@ -26,6 +24,17 @@ function autoUpdateEnv(root, extra = {}) {
 	};
 }
 
+function assertStartedNotice(notices) {
+	assert.equal(notices.length, 1);
+	const [notice] = notices;
+	assert.equal(typeof notice, "string");
+	assert.match(notice, /v1\.0\.0 -> v1\.0\.1/);
+	assert.match(notice, /Auto-update started in the background/i);
+	assert.match(notice, /new Codex session after it completes/i);
+	assert.match(notice, /user's preferred tone/i);
+	assert.match(notice, /Release notes for v1\.0\.1 were not available/);
+}
+
 test("#given a newer version #when resolving auto update plan #then plan carries current and latest versions", () => {
 	const plan = resolveAutoUpdatePlan({
 		env: { LAZYCODEX_CURRENT_VERSION: "1.0.0", LAZYCODEX_LATEST_VERSION: "1.0.1" },
@@ -54,7 +63,7 @@ test("#given a newer version #when waited update succeeds #then returns update-s
 
 	assert.equal(result.started, true);
 	assert.equal(result.status, 0);
-	assert.deepEqual(result.notices, [STARTED_NOTICE]);
+	assertStartedNotice(result.notices);
 	const state = JSON.parse(await readFile(env.LAZYCODEX_AUTO_UPDATE_STATE_PATH, "utf8"));
 	assert.deepEqual(state.pendingNotice, {
 		fromVersion: "1.0.0",

package/packages/omo-codex/plugin/test/component-codegraph-mcp-smoke.test.mjs

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+
+import { root } from "./aggregate-plugin-fixture.mjs";
+
+const MCP_SMOKE_TIMEOUT_MS = 45_000;
+
+test("#given built CodeGraph MCP wrapper #when an MCP client initializes #then the resolved child responds over stdio", () => {
+	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codex-codegraph-mcp-smoke-"));
+	try {
+		const fakeBinaryPath = join(tempRoot, "codegraph-fake.cjs");
+		writeFileSync(
+			fakeBinaryPath,
+			[
+				"#!/usr/bin/env node",
+				"const readline = require('node:readline');",
+				"const rl = readline.createInterface({ input: process.stdin });",
+				"rl.on('line', (line) => {",
+				"  const request = JSON.parse(line);",
+				"  if (request.method !== 'initialize') return;",
+				"  process.stdout.write(JSON.stringify({",
+				"    jsonrpc: '2.0',",
+				"    id: request.id,",
+				"    result: {",
+				"      protocolVersion: request.params?.protocolVersion ?? '2024-11-05',",
+				"      capabilities: { tools: { listChanged: false } },",
+				"      serverInfo: { name: 'fake-codegraph', version: '0.0.0' }",
+				"    }",
+				"  }) + '\\n');",
+				"});",
+				"",
+			].join("\n"),
+		);
+		chmodSync(fakeBinaryPath, 0o755);
+
+		const result = spawnSync(process.execPath, [join(root, "components", "codegraph", "dist", "serve.js")], {
+			cwd: root,
+			encoding: "utf8",
+			env: {
+				...process.env,
+				HOME: tempRoot,
+				OMO_CODEGRAPH_BIN: fakeBinaryPath,
+			},
+			input: `${JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "initialize",
+				params: {
+					capabilities: {},
+					clientInfo: { name: "lazycodex-smoke", version: "0.0.0" },
+					protocolVersion: "2024-11-05",
+				},
+			})}\n`,
+			timeout: MCP_SMOKE_TIMEOUT_MS,
+		});
+
+		assert.equal(result.status, 0, `stderr: ${result.stderr}`);
+		assert.equal(result.stderr, "");
+		const response = JSON.parse(result.stdout.trim());
+		assert.deepEqual(response, {
+			jsonrpc: "2.0",
+			id: 1,
+			result: {
+				capabilities: { tools: { listChanged: false } },
+				protocolVersion: "2024-11-05",
+				serverInfo: { name: "fake-codegraph", version: "0.0.0" },
+			},
+		});
+	} finally {
+		rmSync(tempRoot, { recursive: true, force: true });
+	}
+});

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

@@ -23,6 +23,7 @@ export const expectedSkills = [
 	"rules",
 	"start-work",
 	"teammode",
+	"ultimate-browsing",
 	"ultraresearch",
 	"ulw-loop",
 	"ulw-plan",

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

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+
+import { root } from "./aggregate-plugin-fixture.mjs";
+import { cleanupTeamRoot, createTeamRoot, runTeam, teamDir } from "./teammode-safety-fixture.mjs";
+
+// The teammode guide.md is what every member actually reads. The real run of leader session
+// 019eed1e- proved members default to silence: 10 members, ~6 min, 4 end-of-work reports, zero
+// peer messages, zero mid-task reports, zero send_message_to_thread calls - because the prose said
+// "over-communicate relentlessly" (aspirational, no trigger) and never named the tool or targets.
+// These tests pin the fix: a concrete push-communication protocol is the default the manual renders.
+
+function buildTwoMemberTeam(tempRoot, sessionId) {
+	runTeam(tempRoot, "init", "--name", "Comms", "--session-name", "frequent", "--session", sessionId);
+	runTeam(tempRoot, "add-member", "--team", sessionId, "--id", "A", "--name", "alpha", "--focus", "slice one", "--lens", "area", "--deliverable", "x");
+	runTeam(tempRoot, "add-member", "--team", sessionId, "--id", "B", "--name", "beta", "--focus", "slice two", "--lens", "area", "--deliverable", "y");
+	runTeam(tempRoot, "bind-thread", "--team", sessionId, "--id", "A", "--thread", "thread-A");
+	runTeam(tempRoot, "bind-thread", "--team", sessionId, "--id", "B", "--thread", "thread-B");
+}
+
+function readGuide(tempRoot, sessionId) {
+	return readFileSync(join(teamDir(tempRoot, sessionId), "guide.md"), "utf8");
+}
+
+test("#given a bound team #when the member field manual renders #then it names the cross-thread tool and the team.json address book", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-comms-");
+	try {
+		buildTwoMemberTeam(tempRoot, "comms-tool");
+		const guide = readGuide(tempRoot, "comms-tool");
+
+		// then - members are told the concrete TOOL to reach leader+peers, not left to narrate
+		assert.match(guide, /codex_app\.send_message_to_thread/, "guide must name the cross-thread messaging tool");
+		// then - members are pointed at the concrete address book in team.json
+		assert.match(guide, /leader\.sessionId/, "guide must say the leader thread id is team.json leader.sessionId");
+		assert.match(guide, /members\[\]\.threadId/, "guide must say peer thread ids are team.json members[].threadId");
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a bound team #when the member field manual renders #then it gives concrete per-moment cadence triggers, not aspirational 'constantly'", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-comms-");
+	try {
+		buildTwoMemberTeam(tempRoot, "comms-cadence");
+		const guide = readGuide(tempRoot, "comms-cadence");
+
+		// then - a concrete heartbeat cadence the model can bind to
+		assert.match(guide, /every few tool calls/, "guide must give a concrete heartbeat trigger");
+		assert.match(guide, /WORKING:/, "guide must keep the WORKING heartbeat marker");
+		assert.match(guide, /BLOCKED:/, "guide must keep the BLOCKED marker");
+		// 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 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 {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a member bootstrap trigger #when it is generated #then it points at the push tool and a continuous cadence, not an end-of-work report", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-comms-");
+	try {
+		buildTwoMemberTeam(tempRoot, "comms-bootstrap");
+		const prompt = runTeam(tempRoot, "member-prompt", "--team", "comms-bootstrap", "--id", "A").stdout;
+
+		// then - the first thing a member reads tells it to push via the tool as it works
+		assert.match(prompt, /codex_app\.send_message_to_thread/, "bootstrap must name the push tool");
+		assert.match(prompt, /never just one report at the end/, "bootstrap must reject end-only reporting");
+		// then - it no longer frames reporting as a one-shot completion event
+		assert.doesNotMatch(prompt, /report to the leader the moment you are done/, "the end-only bootstrap line must be removed");
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given the leader-facing SKILL.md #when it describes communication #then it requires --session so members can reach the leader and frames members as pushing", () => {
+	const skill = readFileSync(join(root, "components", "teammode", "skills", "teammode", "SKILL.md"), "utf8");
+
+	// then - the leader is told members PUSH to it (not only that the leader sends)
+	assert.match(skill, /Members push to you/i, "SKILL.md must frame members as pushing to the leader");
+	// then - the --session requirement is stated WITH its reason (member->leader push needs a real leader thread)
+	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");
+});

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

@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import { readFileSync, writeFileSync } from "node:fs";
+import test from "node:test";
+
+import { cleanupTeamRoot, createTeamRoot, readTeamJson, runTeam, runTeamRaw, teamJsonPath } from "./teammode-safety-fixture.mjs";
+
+function addMember(tempRoot, sessionId, { id, name, focus, lens, deliverable }) {
+	const args = ["add-member", "--team", sessionId, "--id", id, "--focus", focus, "--lens", lens, "--deliverable", deliverable];
+	if (name !== undefined) args.push("--name", name);
+	return runTeam(tempRoot, ...args);
+}
+
+test("#given two members with distinct names #when added #then each thread title is per-member and the two never collide", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-title-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Recovery", "--session-name", "app-server-research", "--session", "title-distinct");
+		addMember(tempRoot, "title-distinct", { id: "A", name: "app-server-lifecycle", focus: "app-server thread lifecycle", lens: "area", deliverable: "lifecycle map" });
+		addMember(tempRoot, "title-distinct", { id: "B", name: "mailbox-delivery", focus: "mailbox live-delivery path", lens: "ownership", deliverable: "delivery audit" });
+
+		const team = readTeamJson(tempRoot, "title-distinct");
+		const byId = Object.fromEntries(team.members.map((m) => [m.id, m]));
+
+		// then - the title carries the member's own name, not a fixed team-wide session name
+		assert.equal(byId.A.threadTitle, "[Recovery] app-server-lifecycle");
+		assert.equal(byId.B.threadTitle, "[Recovery] mailbox-delivery");
+		// then - the member name is recorded for identity
+		assert.equal(byId.A.name, "app-server-lifecycle");
+		assert.equal(byId.B.name, "mailbox-delivery");
+		// then - no two members share a title (the core bug)
+		assert.notEqual(byId.A.threadTitle, byId.B.threadTitle);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a member added without an explicit name #when state is read #then the title falls back to the focus, never a shared session name", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-title-fallback-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Recovery", "--session-name", "shared-session", "--session", "title-fallback");
+		addMember(tempRoot, "title-fallback", { id: "A", focus: "installer config", lens: "area", deliverable: "x" });
+		addMember(tempRoot, "title-fallback", { id: "B", focus: "runtime qa", lens: "perspective", deliverable: "y" });
+
+		const team = readTeamJson(tempRoot, "title-fallback");
+		const byId = Object.fromEntries(team.members.map((m) => [m.id, m]));
+
+		// then - fallback uses the member's own focus, so titles still differ per member
+		assert.equal(byId.A.threadTitle, "[Recovery] installer config");
+		assert.equal(byId.B.threadTitle, "[Recovery] runtime qa");
+		assert.notEqual(byId.A.threadTitle, byId.B.threadTitle);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a member name already exists #when add-member receives the same name with different spacing and case #then state is not partially mutated", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-title-duplicate-name-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Recovery", "--session-name", "shared-session", "--session", "title-duplicate-name");
+		addMember(tempRoot, "title-duplicate-name", {
+			id: "A",
+			name: "App Server",
+			focus: "app-server lifecycle",
+			lens: "area",
+			deliverable: "lifecycle map",
+		});
+
+		const result = runTeamRaw(
+			tempRoot,
+			"add-member",
+			"--team",
+			"title-duplicate-name",
+			"--id",
+			"B",
+			"--name",
+			" app   server ",
+			"--focus",
+			"mailbox delivery",
+			"--lens",
+			"ownership",
+			"--deliverable",
+			"delivery audit",
+		);
+		const team = readTeamJson(tempRoot, "title-duplicate-name");
+
+		assert.notEqual(result.status, 0);
+		assert.match(result.stderr, /member name "app   server" duplicates "App Server"/);
+		assert.equal(team.members.length, 1);
+		assert.deepEqual(
+			team.members.map((member) => ({ id: member.id, name: member.name, threadTitle: member.threadTitle })),
+			[{ id: "A", name: "App Server", threadTitle: "[Recovery] App Server" }],
+		);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given persisted team.json has duplicate member names #when a command loads the team #then stale state is rejected", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-title-stale-duplicate-name-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Recovery", "--session-name", "shared-session", "--session", "title-stale-duplicate-name");
+		addMember(tempRoot, "title-stale-duplicate-name", {
+			id: "A",
+			name: "App Server",
+			focus: "app-server lifecycle",
+			lens: "area",
+			deliverable: "lifecycle map",
+		});
+		addMember(tempRoot, "title-stale-duplicate-name", {
+			id: "B",
+			name: "Mailbox Delivery",
+			focus: "mailbox delivery",
+			lens: "ownership",
+			deliverable: "delivery audit",
+		});
+		const path = teamJsonPath(tempRoot, "title-stale-duplicate-name");
+		const team = JSON.parse(readFileSync(path, "utf8"));
+		team.members[1].name = " app   server ";
+		writeFileSync(path, `${JSON.stringify(team, null, 2)}\n`);
+
+		const result = runTeamRaw(tempRoot, "status", "--team", "title-stale-duplicate-name");
+
+		assert.notEqual(result.status, 0);
+		assert.match(result.stderr, /member name " app   server " duplicates "App Server"/);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given persisted team.json has duplicate thread titles with distinct member names #when bind-thread runs #then state is rejected before activation", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-title-stale-duplicate-title-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Recovery", "--session-name", "shared-session", "--session", "title-stale-duplicate-title");
+		addMember(tempRoot, "title-stale-duplicate-title", {
+			id: "A",
+			name: "App Server",
+			focus: "app-server lifecycle",
+			lens: "area",
+			deliverable: "lifecycle map",
+		});
+		addMember(tempRoot, "title-stale-duplicate-title", {
+			id: "B",
+			name: "Mailbox Delivery",
+			focus: "mailbox delivery",
+			lens: "ownership",
+			deliverable: "delivery audit",
+		});
+		const path = teamJsonPath(tempRoot, "title-stale-duplicate-title");
+		const team = JSON.parse(readFileSync(path, "utf8"));
+		team.members[0].threadTitle = "[Legacy] Alpha";
+		team.members[1].threadTitle = "[Legacy] Alpha";
+		writeFileSync(path, `${JSON.stringify(team, null, 2)}\n`);
+
+		const result = runTeamRaw(tempRoot, "bind-thread", "--team", "title-stale-duplicate-title", "--id", "A", "--thread", "thread-a");
+		const persisted = readTeamJson(tempRoot, "title-stale-duplicate-title");
+
+		assert.notEqual(result.status, 0);
+		assert.match(result.stderr, /member threadTitle "\[Legacy\] Alpha" duplicates "\[Legacy\] Alpha"/);
+		assert.deepEqual(
+			persisted.members.map((member) => ({ id: member.id, status: member.status, threadId: member.threadId })),
+			[
+				{ id: "A", status: "pending", threadId: null },
+				{ id: "B", status: "pending", threadId: null },
+			],
+		);
+		assert.equal(persisted.log.some((entry) => entry.event === "bind-thread"), false);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});

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

@@ -0,0 +1,246 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+
+import { cleanupTeamRoot, createTeamRoot, readTeamJson, runTeam, runTeamRaw, teamDir, teamJsonPath } from "./teammode-safety-fixture.mjs";
+
+function memberWorktreePath(tempRoot, sessionId, memberId) {
+	return join(tempRoot, ".omo", "teams", sessionId, "worktrees", memberId);
+}
+
+// Compare two on-disk paths regardless of OS: realpathSync canonicalizes separators, drive-letter
+// case (Windows), and symlinks (macOS /var -> /private/var). Returns false if either side is gone.
+function samePath(a, b) {
+	try {
+		return realpathSync(a) === realpathSync(b);
+	} catch {
+		return false;
+	}
+}
+
+function git(cwd, ...args) {
+	const result = spawnSync("git", args, { cwd, encoding: "utf8" });
+	assert.equal(result.status, 0, `git ${args.join(" ")} failed: ${result.stderr || result.stdout}`);
+	return result.stdout;
+}
+
+// A real git repo on a known base branch so worktree-add/integrate exercise real git, not mocks.
+function initGitRepo(cwd, { baseBranch = "main" } = {}) {
+	git(cwd, "init", "-b", baseBranch);
+	git(cwd, "config", "user.email", "team@example.com");
+	git(cwd, "config", "user.name", "Teammode Test");
+	writeFileSync(join(cwd, "file.txt"), "base\n");
+	git(cwd, "add", "file.txt");
+	git(cwd, "commit", "-m", "base commit");
+	return baseBranch;
+}
+
+function bootstrapTeam(cwd, sessionId, { worktree = false, baseBranch = "main" } = {}) {
+	const args = ["init", "--name", "WT", "--session-name", "wt-session", "--session", sessionId, "--base-branch", baseBranch];
+	if (worktree) args.push("--worktree");
+	runTeam(cwd, ...args);
+	runTeam(cwd, "add-member", "--team", sessionId, "--id", "A", "--focus", "alpha slice", "--lens", "area", "--deliverable", "a");
+	runTeam(cwd, "add-member", "--team", sessionId, "--id", "B", "--focus", "beta slice", "--lens", "ownership", "--deliverable", "b");
+}
+
+// The branch each worktree is checked out on. Branch refs are "/"-delimited on every OS, so this
+// is a separator-proof way to assert which worktrees git knows about (porcelain paths are not).
+function worktreeBranches(cwd) {
+	return git(cwd, "worktree", "list", "--porcelain")
+		.split("\n")
+		.filter((line) => line.startsWith("branch "))
+		.map((line) => line.slice("branch ".length).replace("refs/heads/", ""));
+}
+
+function branchExists(cwd, branch) {
+	return spawnSync("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], { cwd, encoding: "utf8" }).status === 0;
+}
+
+test("#given a worktree team #when worktree-add A #then a real git worktree on a derived branch is created and recorded", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-add-");
+	try {
+		initGitRepo(tempRoot);
+		bootstrapTeam(tempRoot, "wt-add", { worktree: true });
+
+		const result = runTeam(tempRoot, "worktree-add", "--team", "wt-add", "--id", "A");
+
+		// then - git itself knows about the worktree on the member branch
+		const expectedBranch = "team/wt-add/A";
+		assert.equal(branchExists(tempRoot, expectedBranch), true, "member branch must exist");
+		assert.ok(worktreeBranches(tempRoot).includes(expectedBranch), "git worktree list must include the member branch");
+
+		// then - team.json records the worktree for the member (compare by realpath: OS-agnostic)
+		const expectedPath = memberWorktreePath(tempRoot, "wt-add", "A");
+		const member = readTeamJson(tempRoot, "wt-add").members.find((m) => m.id === "A");
+		assert.ok(existsSync(member.worktree.path) && samePath(member.worktree.path, expectedPath), "worktree.path must point at the member worktree dir");
+		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 /);
+		assert.match(result.stdout, /A/);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given worktree-add ran #when the field manual is regenerated #then it flips the member's guide to ISOLATION IS ON with the derived branch", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-guide-");
+	try {
+		initGitRepo(tempRoot);
+		bootstrapTeam(tempRoot, "wt-guide", { worktree: false });
+		// before: no isolation, so the manual tells members to signal collisions instead
+		assert.match(readFileSync(join(teamDir(tempRoot, "wt-guide"), "guide.md"), "utf8"), /does not use isolated git worktrees/);
+
+		runTeam(tempRoot, "worktree-add", "--team", "wt-guide", "--id", "A");
+
+		const guide = readFileSync(join(teamDir(tempRoot, "wt-guide"), "guide.md"), "utf8");
+		assert.match(guide, /ISOLATION IS ON/);
+		assert.match(guide, /team\/wt-guide\/A/, "the member's row must show its derived worktree branch");
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a team initialized WITHOUT --worktree #when worktree-add is called mid-run #then it auto-enables isolation (conflict-triggered)", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-autoenable-");
+	try {
+		initGitRepo(tempRoot);
+		bootstrapTeam(tempRoot, "wt-auto", { worktree: false });
+		assert.equal(readTeamJson(tempRoot, "wt-auto").worktree.enabled, false, "precondition: worktree starts disabled");
+
+		runTeam(tempRoot, "worktree-add", "--team", "wt-auto", "--id", "A");
+
+		const team = readTeamJson(tempRoot, "wt-auto");
+		assert.equal(team.worktree.enabled, true, "worktree-add must flip the team into isolation mode");
+		assert.ok(worktreeBranches(tempRoot).includes("team/wt-auto/A"), "git must have created the member worktree");
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given an existing member worktree #when worktree-add runs again #then it is a safe no-op that reports the existing worktree", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-idem-");
+	try {
+		initGitRepo(tempRoot);
+		bootstrapTeam(tempRoot, "wt-idem", { worktree: true });
+		runTeam(tempRoot, "worktree-add", "--team", "wt-idem", "--id", "A");
+
+		const second = runTeam(tempRoot, "worktree-add", "--team", "wt-idem", "--id", "A");
+
+		assert.match(second.stdout, /exist/i, "re-running must report the worktree already exists, not crash");
+		assert.equal(worktreeBranches(tempRoot).filter((b) => b === "team/wt-idem/A").length, 1, "no duplicate worktree");
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a member worktree #when worktree-remove A #then git drops it and team.json clears the path", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-remove-");
+	try {
+		initGitRepo(tempRoot);
+		bootstrapTeam(tempRoot, "wt-rm", { worktree: true });
+		runTeam(tempRoot, "worktree-add", "--team", "wt-rm", "--id", "A");
+		assert.ok(worktreeBranches(tempRoot).includes("team/wt-rm/A"));
+
+		runTeam(tempRoot, "worktree-remove", "--team", "wt-rm", "--id", "A");
+
+		assert.ok(!worktreeBranches(tempRoot).includes("team/wt-rm/A"), "git worktree list must no longer include the removed worktree");
+		const member = readTeamJson(tempRoot, "wt-rm").members.find((m) => m.id === "A");
+		assert.equal(member.worktree.path, null);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a member committed work in its worktree #when integrate --id A #then the base branch gets a NO-FF merge commit", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-integrate-");
+	try {
+		initGitRepo(tempRoot);
+		bootstrapTeam(tempRoot, "wt-int", { worktree: true });
+		runTeam(tempRoot, "worktree-add", "--team", "wt-int", "--id", "A");
+
+		// member A does work inside its own worktree and commits
+		const wtA = join(tempRoot, ".omo", "teams", "wt-int", "worktrees", "A");
+		writeFileSync(join(wtA, "alpha.txt"), "alpha work\n");
+		git(wtA, "add", "alpha.txt");
+		git(wtA, "commit", "-m", "alpha: add alpha.txt");
+
+		runTeam(tempRoot, "integrate", "--team", "wt-int", "--id", "A");
+
+		// then - base branch carries the member's file via a merge commit (not a fast-forward / squash)
+		const mergeCommits = git(tempRoot, "log", "main", "--merges", "--oneline");
+		assert.notEqual(mergeCommits.trim(), "", "integrate must produce a merge commit on the base branch");
+		const tracked = git(tempRoot, "ls-files");
+		assert.match(tracked, /alpha\.txt/, "the member's committed file must be present on the base branch");
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given two members edited the same line #when integrate hits the conflict #then it stops, reports the conflicting member, and exits non-zero", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-conflict-");
+	try {
+		initGitRepo(tempRoot);
+		bootstrapTeam(tempRoot, "wt-conf", { worktree: true });
+		runTeam(tempRoot, "worktree-add", "--team", "wt-conf", "--id", "A");
+		runTeam(tempRoot, "worktree-add", "--team", "wt-conf", "--id", "B");
+
+		const wtA = join(tempRoot, ".omo", "teams", "wt-conf", "worktrees", "A");
+		writeFileSync(join(wtA, "file.txt"), "A changed the line\n");
+		git(wtA, "commit", "-am", "A edits file.txt");
+		const wtB = join(tempRoot, ".omo", "teams", "wt-conf", "worktrees", "B");
+		writeFileSync(join(wtB, "file.txt"), "B changed the line\n");
+		git(wtB, "commit", "-am", "B edits file.txt");
+
+		runTeam(tempRoot, "integrate", "--team", "wt-conf", "--id", "A");
+		const conflict = runTeamRaw(tempRoot, "integrate", "--team", "wt-conf", "--id", "B");
+
+		assert.notEqual(conflict.status, 0, "a merge conflict must surface as a non-zero exit");
+		assert.match(`${conflict.stdout}${conflict.stderr}`, /conflict/i);
+		assert.match(`${conflict.stdout}${conflict.stderr}`, /\bB\b/);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a member branch that cannot be merged #when integrate runs #then it surfaces git's real reason, not a fake conflict", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-fatal-");
+	try {
+		initGitRepo(tempRoot);
+		bootstrapTeam(tempRoot, "wt-fatal", { worktree: true });
+		runTeam(tempRoot, "worktree-add", "--team", "wt-fatal", "--id", "A");
+		// point member A at a branch that does not exist: a fatal git error, NOT a content conflict
+		const team = readTeamJson(tempRoot, "wt-fatal");
+		team.members.find((m) => m.id === "A").worktree.branch = "ghost-branch-404";
+		writeFileSync(teamJsonPath(tempRoot, "wt-fatal"), `${JSON.stringify(team, null, 2)}\n`);
+
+		const result = runTeamRaw(tempRoot, "integrate", "--team", "wt-fatal", "--id", "A");
+
+		const out = `${result.stdout}${result.stderr}`;
+		assert.notEqual(result.status, 0);
+		assert.match(out, /could not integrate|not something we can merge|ghost-branch-404/i, "must surface git's actual reason");
+		assert.doesNotMatch(out, /Conflicting files/, "a non-conflict failure must NOT be mislabeled as a merge conflict");
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given a member id that is not a safe path segment #when worktree-add runs #then it refuses instead of escaping the team dir", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-wt-escape-");
+	try {
+		initGitRepo(tempRoot);
+		runTeam(tempRoot, "init", "--name", "WT", "--session-name", "wt", "--session", "wt-escape", "--base-branch", "main", "--worktree");
+		runTeam(tempRoot, "add-member", "--team", "wt-escape", "--id", "A", "--focus", "alpha", "--lens", "area", "--deliverable", "a");
+		// craft an unsafe member id directly in state, then try to provision a worktree for it
+		mkdirSync(join(tempRoot, "sentinel"), { recursive: true });
+		const result = runTeamRaw(tempRoot, "worktree-add", "--team", "wt-escape", "--id", "../../sentinel");
+
+		assert.notEqual(result.status, 0);
+		assert.match(`${result.stdout}${result.stderr}`, /unsafe|no member|escape/i);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});

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

@@ -172,3 +172,33 @@ test("#given ultraresearch team communication #when the raise law is inspected #
 		);
 	}
 });
+
+test("#given ultraresearch non-code verification #when the gate is inspected #then a claim ledger / verified-claims data-flow-lock exists", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.match(
+			copy.content,
+			/claim ledger|verified-claims/i,
+			`${copy.label}: body must define the non-code claim-ledger verification gate`,
+		);
+	}
+});
+
+test("#given ultraresearch claim ledger #when ownership is inspected #then workers never write the ledger / verified-claims artifact", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		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 ultraresearch blocked sources #when escalation is inspected #then it routes through the ultimate-browsing skill", async () => {
+	for (const copy of await readUltraresearchCopies()) {
+		assert.match(
+			copy.content,
+			/ultimate-browsing/,
+			`${copy.label}: body must escalate blocked sources via the ultimate-browsing skill`,
+		);
+	}
+});