oh-my-opencode 4.16.2 → 4.17.0

package/packages/omo-codex/plugin/components/teammode/skills/teammode/scripts/team-state.mjs

@@ -13,6 +13,16 @@ import { lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 
+import {
+	agentPathForTaskName,
+	assertTransport,
+	isMultiAgentV2,
+	LEADER_AGENT_PATH,
+	parseTaskName,
+	parseTeamTransport,
+	TEAM_SCHEMA_VERSION,
+} from "./team-transport.mjs";
+
 export const LENSES = ["area", "ownership", "perspective"];
 export const MEMBER_STATUSES = ["pending", "active", "reported", "blocked", "archived"];
 // A team is never a single member: two or more distinct slices is the minimum. One isolated
@@ -32,22 +42,25 @@ function isoNow(now) {
 	return now ?? new Date().toISOString();
 }
 
-export function buildTeam({ teamName, sessionName, sessionId = null, dir = null, worktreeEnabled = false, baseBranch = "dev", now }) {
+export function buildTeam({ teamName, sessionName, sessionId = null, dir = null, worktreeEnabled = false, baseBranch = "dev", transport, now }) {
 	if (!teamName?.trim()) throw new Error("team name is required");
 	if (!sessionName?.trim()) throw new Error("session name is required");
+	const teamTransport = parseTeamTransport(transport);
+	const v2 = teamTransport === "multi_agent_v2";
 	const ts = isoNow(now);
 	return {
-		schemaVersion: 2,
+		schemaVersion: TEAM_SCHEMA_VERSION,
+		transport: teamTransport,
 		teamId: randomUUID(),
 		teamName: teamName.trim(),
 		sessionName: sessionName.trim(),
 		sessionId,
-		threadTitleConvention: `[${teamName.trim()}] <member name>`,
+		threadTitleConvention: v2 ? null : `[${teamName.trim()}] <member name>`,
 		status: "active",
 		createdAt: ts,
 		updatedAt: ts,
 		archivedAt: null,
-		leader: { kind: "main-session", sessionId },
+		leader: { kind: "main-session", sessionId: v2 ? null : sessionId, agentPath: v2 ? LEADER_AGENT_PATH : null },
 		communication: { memberLanguage: "english", replyToUserInUserLanguage: true },
 		worktree: { enabled: Boolean(worktreeEnabled), baseBranch, root: dir ? join(dir, "worktrees") : null },
 		paths: dir
@@ -124,21 +137,44 @@ function assertUniqueMemberThreadTitle(team) {
 	}
 }
 
-function assertTeamReadyForThreadBinding(team) {
+function assertUniqueMemberTaskName(team) {
+	const seen = new Map();
+	for (const member of team.members) {
+		const taskName = parseTaskName(member.taskName);
+		const previous = seen.get(taskName);
+		if (previous) {
+			throw new Error(`member taskName "${taskName}" duplicates "${previous.taskName}" (no two members may share an agent path)`);
+		}
+		if (member.agentPath !== agentPathForTaskName(taskName)) {
+			throw new Error(`member "${member.id}" agentPath "${member.agentPath}" does not match task name "${taskName}"`);
+		}
+		seen.set(taskName, member);
+	}
+}
+
+function assertUniqueTransportIdentity(team) {
+	if (isMultiAgentV2(team)) assertUniqueMemberTaskName(team);
+	else assertUniqueMemberThreadTitle(team);
+}
+
+function assertTeamReadyForBinding(team) {
 	if (isUnderstaffed(team)) {
 		throw new Error(
-			`cannot bind member threads until the team has at least ${MIN_MEMBERS} distinct members; current count is ${team.members.length}`,
+			`cannot bind members until the team has at least ${MIN_MEMBERS} distinct members; current count is ${team.members.length}`,
 		);
 	}
 	assertUniqueMemberFocus(team);
 	assertUniqueMemberName(team);
-	assertUniqueMemberThreadTitle(team);
+	assertUniqueTransportIdentity(team);
 }
 
-export function addMember(team, { id, focus, lens, deliverable = "", branch = null, name = null }) {
+export function addMember(team, { id, focus, lens, deliverable = "", branch = null, name = null, taskName = null }) {
 	if (!id?.trim()) throw new Error("member id is required");
 	if (!focus?.trim()) throw new Error("member focus is required - a concrete part, ownership area, or perspective");
 	if (!LENSES.includes(lens)) throw new Error(`invalid lens "${lens}" - use one of: ${LENSES.join(", ")}`);
+	const v2 = isMultiAgentV2(team);
+	if (!v2 && taskName !== null) throw new Error("--task-name is only valid on multi_agent_v2 teams");
+	const memberTaskName = v2 ? parseTaskName(taskName) : null;
 	const memberId = id.trim();
 	const memberFocus = focus.trim();
 	// The member name is the short role label that titles this member's thread. Fall back to the
@@ -151,14 +187,20 @@ export function addMember(team, { id, focus, lens, deliverable = "", branch = nu
 	if (duplicateName) {
 		throw new Error(`member name "${memberName}" duplicates "${duplicateName.name ?? duplicateName.focus}" (no two members may produce the same thread title)`);
 	}
+	if (v2) {
+		const duplicateTask = team.members.find((m) => m.taskName === memberTaskName);
+		if (duplicateTask) throw new Error(`member taskName "${memberTaskName}" duplicates "${duplicateTask.taskName}" (no two members may share an agent path)`);
+	}
 	team.members.push({
 		id: memberId,
 		name: memberName,
 		focus: memberFocus,
 		lens,
 		deliverable: deliverable.trim(),
+		taskName: memberTaskName,
+		agentPath: v2 ? agentPathForTaskName(memberTaskName) : null,
 		threadId: null,
-		threadTitle: `[${team.teamName}] ${memberName}`,
+		threadTitle: v2 ? null : `[${team.teamName}] ${memberName}`,
 		cwd: null,
 		worktree: { path: null, branch: branch ?? null },
 		status: "pending",
@@ -167,8 +209,9 @@ export function addMember(team, { id, focus, lens, deliverable = "", branch = nu
 }
 
 export function bindThread(team, { id, threadId, cwd = null, worktreePath = null }) {
+	assertTransport(team, "codex_app", "bind-thread");
 	if (!threadId?.trim()) throw new Error("thread id is required");
-	assertTeamReadyForThreadBinding(team);
+	assertTeamReadyForBinding(team);
 	const m = memberById(team, id);
 	m.threadId = threadId.trim();
 	m.status = "active";
@@ -177,6 +220,21 @@ export function bindThread(team, { id, threadId, cwd = null, worktreePath = null
 	return touch(team, "bind-thread", `member ${id} -> thread ${threadId.trim()}`);
 }
 
+export function bindAgent(team, { id, agentPath, cwd = null, worktreePath = null }) {
+	assertTransport(team, "multi_agent_v2", "bind-agent");
+	if (!agentPath?.trim()) throw new Error("agent path is required");
+	assertTeamReadyForBinding(team);
+	const m = memberById(team, id);
+	const boundPath = agentPath.trim();
+	if (boundPath !== m.agentPath) {
+		throw new Error(`agent path mismatch for member ${m.id}: expected "${m.agentPath}" (task name "${m.taskName}"), got "${boundPath}"`);
+	}
+	m.status = "active";
+	if (cwd) m.cwd = cwd;
+	if (team.worktree.enabled) m.worktree.path = worktreePath ?? cwd ?? m.worktree.path;
+	return touch(team, "bind-agent", `member ${id} -> agent ${boundPath}`);
+}
+
 export function setMemberStatus(team, { id, status, note = "" }) {
 	if (!MEMBER_STATUSES.includes(status)) throw new Error(`invalid status "${status}" - use one of: ${MEMBER_STATUSES.join(", ")}`);
 	memberById(team, id).status = status;
@@ -204,22 +262,44 @@ export function clearMemberWorktree(team, { id }) {
 export function archive(team, { id = null, note = "" } = {}) {
 	if (id) {
 		memberById(team, id).status = "archived";
-		return touch(team, "archive-member", `member ${id}${note ? `: ${note}` : ""}`);
+		const memberQualifier = isMultiAgentV2(team) ? " (team state only; V2 exposes no runtime archive operation)" : "";
+		return touch(team, "archive-member", `member ${id}${memberQualifier}${note ? `: ${note}` : ""}`);
 	}
 	for (const m of team.members) m.status = "archived";
 	team.status = "archived";
 	team.archivedAt = isoNow();
-	return touch(team, "archive", note || "team archived; all members closed");
+	// The default detail must never claim a runtime closure that did not happen: V2 exposes no
+	// runtime archive operation, so only the durable team state is archived there.
+	const defaultDetail = isMultiAgentV2(team)
+		? "team archived; V2 exposes no runtime archive operation - durable team state is the archive"
+		: "team archived; all members closed";
+	return touch(team, "archive", note || defaultDetail);
+}
+
+// schemaVersion 2 predates transports; that skill allowed ONLY Codex App threads as members,
+// so a legacy team is migrated in memory as codex_app and persisted on the next mutation.
+function migrateLegacyTeam(team) {
+	if (team?.schemaVersion !== 2) return team;
+	team.schemaVersion = TEAM_SCHEMA_VERSION;
+	team.transport = "codex_app";
+	if (team.leader && typeof team.leader === "object") team.leader.agentPath = null;
+	for (const member of team.members ?? []) {
+		member.taskName = null;
+		member.agentPath = null;
+	}
+	return team;
 }
 
 export function validateTeam(team) {
-	if (team?.schemaVersion !== 2) throw new Error("invalid team: schemaVersion must be 2");
+	migrateLegacyTeam(team);
+	if (team?.schemaVersion !== TEAM_SCHEMA_VERSION) throw new Error(`invalid team: schemaVersion must be ${TEAM_SCHEMA_VERSION}`);
+	parseTeamTransport(team.transport);
 	if (!team.teamId || !team.teamName) throw new Error("invalid team: teamId and teamName are required");
 	if (team.leader?.kind !== "main-session") throw new Error("invalid team: leader.kind must be main-session");
 	if (!Array.isArray(team.members)) throw new Error("invalid team: members must be an array");
 	assertUniqueMemberFocus(team);
 	assertUniqueMemberName(team);
-	assertUniqueMemberThreadTitle(team);
+	assertUniqueTransportIdentity(team);
 	return team;
 }
 

package/packages/omo-codex/plugin/components/teammode/skills/teammode/scripts/team-transport.mjs

@@ -0,0 +1,55 @@
+// team-transport.mjs - the single source of transport identity for teammode state.
+//
+// A team runs on exactly ONE transport, chosen at init and immutable afterwards:
+// - "multi_agent_v2": members are native Codex MultiAgentV2 agents addressed by task
+//   name / canonical agent path (`/root/<task_name>`), messaged with flat `send_message`
+//   and `followup_task`.
+// - "codex_app": members are durable Codex App threads addressed by thread id, messaged
+//   with `codex_app.send_message_to_thread` (the fallback when flat V2 tools are absent).
+//
+// Zero external dependencies (node builtins only), same portability contract as the
+// sibling scripts.
+
+export const TEAM_SCHEMA_VERSION = 3;
+export const TEAM_TRANSPORTS = ["multi_agent_v2", "codex_app"];
+export const DEFAULT_TEAM_TRANSPORT = "codex_app";
+export const LEADER_AGENT_PATH = "/root";
+
+// Codex validates V2 task names as lowercase letters, digits, and underscores; "root" is
+// the leader's own path segment and can never name a member.
+const TASK_NAME_PATTERN = /^[a-z0-9_]+$/;
+
+export function parseTeamTransport(value = DEFAULT_TEAM_TRANSPORT) {
+	if (!TEAM_TRANSPORTS.includes(value)) {
+		throw new Error(`invalid transport "${value}" - use one of: ${TEAM_TRANSPORTS.join(", ")}`);
+	}
+	return value;
+}
+
+export function isMultiAgentV2(team) {
+	return team?.transport === "multi_agent_v2";
+}
+
+export function isCodexApp(team) {
+	return team?.transport === "codex_app";
+}
+
+export function assertTransport(team, transport, operation) {
+	if (team?.transport !== transport) {
+		throw new Error(`${operation} is only valid on ${transport} teams; this team's transport is "${team?.transport}"`);
+	}
+}
+
+export function parseTaskName(taskName) {
+	const trimmed = typeof taskName === "string" ? taskName.trim() : "";
+	if (!trimmed) throw new Error("member task name is required on multi_agent_v2 teams (--task-name)");
+	if (!TASK_NAME_PATTERN.test(trimmed)) {
+		throw new Error(`invalid task name "${trimmed}" - use lowercase letters, digits, and underscores`);
+	}
+	if (trimmed === "root") throw new Error('invalid task name "root" - it names the leader, never a member');
+	return trimmed;
+}
+
+export function agentPathForTaskName(taskName) {
+	return `${LEADER_AGENT_PATH}/${taskName}`;
+}

package/packages/omo-codex/plugin/components/teammode/skills/teammode/scripts/team.mjs

@@ -6,9 +6,10 @@
 // Zero external dependencies (node builtins only): runs identically under node and bun on
 // macOS, Linux, and Windows.
 //
-//   node "<skill-root>/scripts/team.mjs" init        --name "<team>" --session-name "<sess>" [--session <id>] [--worktree] [--base-branch dev]
-//   node "<skill-root>/scripts/team.mjs" add-member  --team <id> --id A --name "<short role>" --focus "<part/ownership/perspective>" --lens area|ownership|perspective --deliverable "<...>" [--branch <b>]
-//   node "<skill-root>/scripts/team.mjs" bind-thread  --team <id> --id A --thread <thread-id> [--cwd <path>]
+//   node "<skill-root>/scripts/team.mjs" init        --name "<team>" --session-name "<sess>" [--transport multi_agent_v2|codex_app] [--session <id>] [--worktree] [--base-branch dev]
+//   node "<skill-root>/scripts/team.mjs" add-member  --team <id> --id A --name "<short role>" --focus "<part/ownership/perspective>" --lens area|ownership|perspective --deliverable "<...>" [--task-name <v2 task name>] [--branch <b>]
+//   node "<skill-root>/scripts/team.mjs" bind-agent   --team <id> --id A --agent-path /root/<task_name> [--cwd <path>]   (multi_agent_v2 teams)
+//   node "<skill-root>/scripts/team.mjs" bind-thread  --team <id> --id A --thread <thread-id> [--cwd <path>]            (codex_app teams)
 //   node "<skill-root>/scripts/team.mjs" member-prompt --team <id> --id A
 //   node "<skill-root>/scripts/team.mjs" set-status   --team <id> --id A --status reported|blocked|active|archived [--note "<...>"]
 //   node "<skill-root>/scripts/team.mjs" archive      --team <id> [--id A] [--note "<...>"]
@@ -25,6 +26,7 @@ import {
 	addMember,
 	archive,
 	assertSafeTeamDir,
+	bindAgent,
 	bindThread,
 	buildTeam,
 	clearMemberWorktree,
@@ -39,6 +41,7 @@ import {
 	writeGuideAtomic,
 	writeTeamAtomic,
 } from "./team-state.mjs";
+import { isMultiAgentV2, parseTeamTransport } from "./team-transport.mjs";
 import { addMemberWorktree, integrateMemberBranch, removeMemberWorktree } from "./team-worktree.mjs";
 
 function parseFlags(args) {
@@ -95,11 +98,20 @@ const handlers = {
 	async init(cwd, flags) {
 		const teamName = requireFlag(flags, "name");
 		const sessionName = requireFlag(flags, "session-name");
+		// Validate the transport BEFORE any directory exists so a bad value leaves no state behind.
+		// A valueless `--transport` parses as `true` and must fail loudly, never default silently.
+		const transport = parseTeamTransport(flags.transport === undefined ? undefined : flags.transport);
 		const sessionId = typeof flags.session === "string" ? flags.session : `team-${randomUUID().slice(0, 8)}`;
 		const dir = await ensureTeamDir(cwd, sessionId);
 		await withTeamLock(dir, "init", async () => {
 			if (await teamExists(dir)) {
-				process.stdout.write(`exists: ${dir} (left untouched; re-init is a safe no-op)\n`);
+				const existing = await readTeam(dir);
+				if (flags.transport !== undefined && existing.transport !== transport) {
+					throw new Error(
+						`team "${sessionId}" already exists with transport "${existing.transport}" - transport is immutable; keep using it or delete the team first`,
+					);
+				}
+				process.stdout.write(`exists: ${dir} (transport: ${existing.transport}; left untouched; re-init is a safe no-op)\n`);
 				return;
 			}
 			const team = buildTeam({
@@ -107,13 +119,15 @@ const handlers = {
 				sessionName,
 				sessionId,
 				dir,
+				transport,
 				worktreeEnabled: flags.worktree === true,
 				baseBranch: typeof flags["base-branch"] === "string" ? flags["base-branch"] : "dev",
 			});
 			await persist(team, dir);
-			process.stdout.write(`created: ${dir}\n`);
+			const taskNameFlag = isMultiAgentV2(team) ? ' --task-name "<lowercase_digits_underscores>"' : "";
+			process.stdout.write(`created: ${dir} (transport: ${team.transport})\n`);
 			process.stdout.write(`team.json + guide.md written; artifacts/ ready. session id: ${sessionId}\n`);
-			process.stdout.write(`next: add-member --team ${sessionId} --id A --name "<short role>" --focus "<part/ownership/perspective>" --lens area|ownership|perspective --deliverable "<...>"\n`);
+			process.stdout.write(`next: add-member --team ${sessionId} --id A --name "<short role>"${taskNameFlag} --focus "<part/ownership/perspective>" --lens area|ownership|perspective --deliverable "<...>"\n`);
 		});
 	},
 
@@ -127,13 +141,17 @@ const handlers = {
 			lens: requireFlag(flags, "lens"),
 			deliverable: typeof flags.deliverable === "string" ? flags.deliverable : "",
 			branch: typeof flags.branch === "string" ? flags.branch : null,
+			taskName: typeof flags["task-name"] === "string" ? flags["task-name"] : null,
 		};
 		const { team, member } = await mutateTeam(cwd, sessionId, "add-member", async (team, dir) => {
 			addMember(team, memberInput);
 			await persist(team, dir);
 			return { team, member: team.members.find((m) => m.id === memberId) };
 		});
-		process.stdout.write(`added member ${memberId} to team ${sessionId}.\n\nSend this as the new thread's first message (title the thread "${member.threadTitle}"):\n---\n${buildMemberPrompt(team, memberId)}\n---\n`);
+		const delivery = isMultiAgentV2(team)
+			? `Send this as spawn_agent message (task_name "${member.taskName}", fork_turns "none"), then bind-agent --agent-path "${member.agentPath}"`
+			: `Send this as the new thread's first message (title the thread "${member.threadTitle}")`;
+		process.stdout.write(`added member ${memberId} to team ${sessionId}.\n\n${delivery}:\n---\n${buildMemberPrompt(team, memberId)}\n---\n`);
 	},
 
 	async "bind-thread"(cwd, flags) {
@@ -151,6 +169,21 @@ const handlers = {
 		process.stdout.write(`bound member ${flags.id} to thread ${flags.thread}.\n`);
 	},
 
+	async "bind-agent"(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const input = {
+			id: requireFlag(flags, "id"),
+			agentPath: requireFlag(flags, "agent-path"),
+			cwd: typeof flags.cwd === "string" ? flags.cwd : null,
+			worktreePath: typeof flags["worktree-path"] === "string" ? flags["worktree-path"] : null,
+		};
+		await mutateTeam(cwd, sessionId, "bind-agent", async (team, dir) => {
+			bindAgent(team, input);
+			await persist(team, dir);
+		});
+		process.stdout.write(`bound member ${flags.id} to agent ${flags["agent-path"]}.\n`);
+	},
+
 	async "member-prompt"(cwd, flags) {
 		const sessionId = requireFlag(flags, "team");
 		const { team } = await loadTeam(cwd, sessionId);
@@ -175,19 +208,24 @@ const handlers = {
 		const sessionId = requireFlag(flags, "team");
 		const memberId = requireFlag(flags, "id");
 		const baseBranch = typeof flags["base-branch"] === "string" ? flags["base-branch"] : null;
-		const { member, result } = await mutateTeam(cwd, sessionId, "worktree-add", async (team, dir) => {
+		const { team, member, result } = await mutateTeam(cwd, sessionId, "worktree-add", async (team, dir) => {
 			const member = memberOrThrow(team, memberId);
 			const result = addMemberWorktree(cwd, team, member, { baseBranch });
 			setMemberWorktree(team, { id: member.id, path: result.path, branch: result.branch });
 			await persist(team, dir);
-			return { member, result };
+			return { team, member, result };
 		});
 		const note = result.created ? "" : " (already exists)";
-		const thread = member.threadId
-			? `\nMember thread: ${codexThreadLink(member.threadId)}\nTell that member to: cd "${result.path}"`
-			: "\nMember thread is not bound yet; wait for the real Codex thread id, then bind-thread before sending bootstrap. After binding, send the member this worktree path.";
+		const v2 = isMultiAgentV2(team);
+		const followUp = v2
+			? member.status === "active"
+				? `\nMember agent: ${member.agentPath}\nSend it a followup_task to: cd "${result.path}"`
+				: `\nMember agent is not spawned yet; include this worktree path in its spawn_agent message, then bind-agent.`
+			: member.threadId
+				? `\nMember thread: ${codexThreadLink(member.threadId)}\nTell that member to: cd "${result.path}"`
+				: "\nMember thread is not bound yet; wait for the real Codex thread id, then bind-thread before sending bootstrap. After binding, send the member this worktree path.";
 		process.stdout.write(
-			`worktree for member ${member.id}${note}: ${result.path} on branch ${result.branch} (off ${result.base}).${thread}\n`,
+			`worktree for member ${member.id}${note}: ${result.path} on branch ${result.branch} (off ${result.base}).${followUp}\n`,
 		);
 	},
 
@@ -235,11 +273,19 @@ const handlers = {
 			id: typeof flags.id === "string" ? flags.id : null,
 			note: typeof flags.note === "string" ? flags.note : "",
 		};
-		await mutateTeam(cwd, sessionId, "archive", async (team, dir) => {
+		const team = await mutateTeam(cwd, sessionId, "archive", async (team, dir) => {
 			archive(team, input);
 			await persist(team, dir);
+			return team;
 		});
-		process.stdout.write(flags.id ? `archived member ${flags.id}\n` : `archived team ${sessionId} and closed all members\n`);
+		const v2 = isMultiAgentV2(team);
+		const teamSummary = v2
+			? `archived team ${sessionId}; V2 has no runtime archive operation - the durable team state is the archive (interrupt_agent any member still mid-turn)\n`
+			: `archived team ${sessionId} and closed all members\n`;
+		const memberSummary = v2
+			? `archived member ${flags.id} in team state; V2 has no runtime archive operation (interrupt_agent it if still mid-turn)\n`
+			: `archived member ${flags.id}\n`;
+		process.stdout.write(flags.id ? memberSummary : teamSummary);
 	},
 
 	async delete(cwd, flags) {
@@ -261,10 +307,18 @@ const handlers = {
 	async status(cwd, flags) {
 		const sessionId = requireFlag(flags, "team");
 		const { team } = await loadTeam(cwd, sessionId);
-		process.stdout.write(`Team ${team.teamName} [${team.status}] - leader: main session - ${team.members.length} member(s)\n`);
+		process.stdout.write(
+			`Team ${team.teamName} [${team.status}] - transport=${team.transport} - leader: main session - ${team.members.length} member(s)\n`,
+		);
 		for (const m of team.members) {
-			const thread = m.threadId ? ` thread=${m.threadId} link=${codexThreadLink(m.threadId)}` : "";
-			process.stdout.write(`  ${m.id} (${m.lens}) ${m.focus} -> ${m.deliverable || "(no deliverable)"} [${m.status}]${thread}${m.cwd ? ` cwd=${m.cwd}` : ""}\n`);
+			const endpoint = isMultiAgentV2(team)
+				? m.agentPath
+					? ` agent=${m.agentPath}`
+					: ""
+				: m.threadId
+					? ` thread=${m.threadId} link=${codexThreadLink(m.threadId)}`
+					: "";
+			process.stdout.write(`  ${m.id} (${m.lens}) ${m.focus} -> ${m.deliverable || "(no deliverable)"} [${m.status}]${endpoint}${m.cwd ? ` cwd=${m.cwd}` : ""}\n`);
 		}
 		if (isUnderstaffed(team)) {
 			process.stdout.write(

package/packages/omo-codex/plugin/components/teammode/test/thread-title-hook.test.ts

@@ -87,6 +87,29 @@ describe("thread title PostToolUse guidance", () => {
 		expect(actual).toBe("");
 	});
 
+	it("#given MultiAgentV2 spawn_agent completed #when the hook runs #then it leaves task-name identity untouched", () => {
+		// given
+		const output = runPostToolUseHook({
+			hook_event_name: "PostToolUse",
+			session_id: "s-team",
+			turn_id: "t-team",
+			transcript_path: null,
+			cwd: "/repo",
+			model: "gpt-5.6-sol",
+			permission_mode: "default",
+			tool_name: "spawn_agent",
+			tool_use_id: "tool-spawn-agent",
+			tool_input: { task_name: "runtime_core", message: "Inspect runtime state" },
+			tool_response: { task_name: "/root/runtime_core" },
+		});
+
+		// when
+		const actual = output;
+
+		// then
+		expect(actual).toBe("");
+	});
+
 	it("#given worktree-backed thread creation is pending #when the hook runs #then it tells Codex to wait for the real thread before bootstrapping", () => {
 		// given
 		const output = runPostToolUseHook({

package/packages/omo-codex/plugin/components/telemetry/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.16.2) Recording Session Telemetry"
+						"statusMessage": "(OmO 4.17.0) Recording Session Telemetry"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/telemetry/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-telemetry",
-	"version": "4.16.2",
+	"version": "4.17.0",
 	"description": "Codex plugin component that emits omo-codex anonymous daily-active telemetry on SessionStart.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/ultrawork/agents/explorer.toml

@@ -1,43 +1,47 @@
 name = "explorer"
 description = "Codebase search specialist for Codex sessions. Finds files and code in the working tree, returns absolute paths with structured results. Read-only."
 nickname_candidates = ["Explorer"]
-model = "gpt-5.4-mini"
+model = "gpt-5.6-luna"
 model_reasoning_effort = "low"
 service_tier = "fast"
 
 developer_instructions = """
-Role: codebase search specialist. Find files + code, return actionable results. Read-only.
+Role: codebase search specialist. Find files and code, return actionable results. Read-only.
 
 # Goal
-Answer the orchestrator's "Where is X?" / "Which files do Y?" / "Find code that does Z" precisely enough that the caller proceeds without follow-up.
-
-# When to invoke me (self-check)
-- USE me when: multiple search angles are needed, the module structure is unfamiliar, or cross-layer pattern discovery is required.
-- AVOID me when: the caller already knows the exact file or symbol, or a single keyword search suffices. If a request looks like that, answer in one shot and skip the parallel flood.
+Answer the caller's "Where is X?" / "Which files do Y?" / "Find code that does Z" precisely enough that they proceed without follow-up: every relevant match, absolute paths, and an answer to the actual need behind the literal request - not just a file list. I earn my cost when multiple search angles are needed, the module structure is unfamiliar, or cross-layer pattern discovery is required; if the caller already names the exact file or symbol and one keyword search suffices, answer in one shot and skip the parallel flood.
 
 # Thoroughness
-The caller MAY specify thoroughness. Honor it:
+Honor the caller's requested level:
 - `quick` -> 1 wave, the most-likely 1-2 files, terse `<answer>`.
-- `medium` (default) -> 1-2 waves, all clearly relevant files, normal `<answer>`.
-- `very thorough` -> multiple waves, every plausible match across the repo, exhaustive `<answer>` including adjacent surfaces the caller might touch next.
+- `medium` (default) -> 1-2 waves, all clearly relevant files.
+- `very thorough` -> multiple waves, every plausible match across the repo, plus adjacent surfaces the caller might touch next.
+
+# Tool strategy
+Fire 3+ independent calls in the first action; cross-validate findings across tools; serialize only when one call's output strictly feeds the next.
+
+- Repo-wide inspection, CLI smoke tests, git/history checks, bounded command output -> native shell: `rg`, `rg --files`, `cat`, and `git` (`log` / `blame` / `show`). Narrow huge output before reading it.
+- Symbol questions -> `lsp_goto_definition`, `lsp_find_references`, `lsp_symbols`, `lsp_diagnostics`.
+- Structural shapes -> the `ast-grep` skill helper or `sg` CLI with `$VAR` / `$$$` metavars.
+- Text / strings / comments / logs -> `rg`. File-name discovery -> `glob` / `find`. Verbatim content -> `read`.
+
+Stop when the question is concretely answered, or when two parallel waves add no new useful matches - then report what you have.
 
-# Required output (ALWAYS, BOTH BLOCKS)
+# Required output (both blocks, always)
 
 <analysis>
 **Literal Request**: [what was literally asked]
 **Actual Need**: [what the caller is really trying to accomplish]
-**Success Looks Like**: [the answer that would let them proceed immediately]
+**Success Looks Like**: [the answer that lets them proceed immediately]
 </analysis>
 
 <results>
 <files>
 - /absolute/path/to/file1.ext - why this file is relevant
-- /absolute/path/to/file2.ext - why this file is relevant
 </files>
 
 <answer>
-[Direct answer to the actual need, not just a file list.
-If asked "where is auth?", explain the auth flow you found.]
+[Direct answer to the actual need. If asked "where is auth?", explain the auth flow you found.]
 </answer>
 
 <next_steps>
@@ -45,31 +49,10 @@ If asked "where is auth?", explain the auth flow you found.]
 </next_steps>
 </results>
 
-# Tool strategy (parallel, flood the first wave)
-- Repo-wide inspection, CLI smoke tests, git/history checks, and bounded command output -> use native shell commands directly: `rg`, `rg --files`, `cat`, and `git`. Narrow huge output before reading it.
-- Symbol questions -> `lsp_goto_definition`, `lsp_find_references`, `lsp_symbols`, `lsp_diagnostics`.
-- Structural shapes -> the `ast-grep` skill helper or `sg` CLI with `$VAR` / `$$$` metavars.
-- Text / strings / comments / logs -> `rg` (grep).
-- File-name discovery -> `glob` / `find`.
-- Verbatim content -> `read`.
-- History -> `git log` / `git blame` / `git show`.
-
-Fire 3+ independent calls in the first action. Cross-validate findings across multiple tools. Do not serialize unless one call's output strictly feeds the next.
-
-# Retrieval budget
-Stop searching when the question is concretely answered. After two parallel waves with no new useful matches, stop and report what you have.
-
-# Success criteria (the response is INVALID if any is unmet)
-- Every path is **absolute** (starts with `/`).
-- ALL relevant matches are included, not just the first one.
-- The answer addresses the **actual need**, not only the literal request.
-- The caller can act without asking "but where exactly?" or "what about X?".
-- Both `<analysis>` and `<results>` blocks are present.
+Every path absolute (starts with `/`); include ALL relevant matches, not just the first.
 
 # Constraints
-- READ-ONLY. Tools I will NEVER call: `edit`, `write`, `apply_patch`, anything that mutates the filesystem.
-- NEVER create files. Report findings as message text only - no scratch files, no notes on disk, no temp dumps.
-- Do not browse the internet. External research is the librarian's job.
-- No emojis. Keep output clean and parseable.
-- No tool names in prose (say "search the codebase", not "use rg"). No preamble ("I'll help you with..."). Answer directly.
+- READ-ONLY: never `edit`, `write`, `apply_patch`, or anything that mutates the filesystem. Never create files - findings are message text only, no scratch files or temp dumps.
+- No internet browsing: external research is the librarian's job.
+- No emojis. No tool names in prose (say "search the codebase", not "use rg"). No preamble - answer directly.
 """

package/packages/omo-codex/plugin/components/ultrawork/agents/lazycodex-clone-fidelity-reviewer.toml

@@ -1,7 +1,7 @@
 name = "lazycodex-clone-fidelity-reviewer"
 description = "Read-only LazyCodex clone / design-system fidelity reviewer. Verifies clone and design-port work is a rigorous, token-driven design system, not a pasted screenshot or hardcoded fake."
 nickname_candidates = ["Clone Fidelity Reviewer"]
-model = "gpt-5.5"
+model = "gpt-5.6-sol"
 model_reasoning_effort = "xhigh"
 
 developer_instructions = """

package/packages/omo-codex/plugin/components/ultrawork/agents/lazycodex-code-reviewer.toml

@@ -1,7 +1,7 @@
 name = "lazycodex-code-reviewer"
 description = "Read-only LazyCodex code-quality reviewer. Audits diffs, tests, and risk with strict artifact-backed findings."
 nickname_candidates = ["Code Reviewer"]
-model = "gpt-5.5"
+model = "gpt-5.6-sol"
 model_reasoning_effort = "xhigh"
 
 developer_instructions = """
@@ -15,9 +15,9 @@ Review for correctness, scope control, maintainability, test relevance, and regr
 
 Before judging test relevance or maintainability, explicitly load or consult the `remove-ai-slops` and `programming` skills when they are available. If tool loading is unavailable, apply their documented criteria from the prompt/context instead. Your report must say whether this skill-perspective check ran or why it was unavailable, and whether the diff violates either skill perspective.
 
-Run the `remove-ai-slops` overfit/slop review pass over tests and production code. Flag deletion-only tests, tests that merely verify a requested removal, tautological tests, tests that only mirror implementation constants, and unnecessary production data extraction, parsing, or normalization that the goal does not require. Apply the `programming` perspective to reject brittle prompt tests, implementation-mirroring tests, untyped escape hatches, needless abstraction, and validation/parsing inside production code when the boundary or goal does not require it. Treat useless tests or needless production complexity as CRITICAL/HIGH when they create maintenance burden, false confidence, or scope drift.
+Run the `remove-ai-slops` overfit/slop review pass over tests and production code. Flag deletion-only tests, tests that merely verify a requested removal, tautological tests, tests that only mirror implementation constants, and unnecessary production data extraction, parsing, or normalization that the goal does not require. Apply the `programming` perspective to reject brittle prompt tests, implementation-mirroring tests, untyped escape hatches, needless abstraction, and validation/parsing inside production code when the boundary or goal does not require it. Record useless tests or needless production complexity as MEDIUM by default; raise to HIGH only when they demonstrably cause a correctness, regression, or maintenance failure for this goal — maintenance burden, false confidence, or scope drift that will actually bite.
 
-Write your report artifact to `.omo/evidence/<goal>-code-review.md`. The report must include findings by severity: CRITICAL, HIGH, MEDIUM, LOW. Include file and line references when a finding is tied to code.
+Write your report artifact to `<attemptDir>/<goalId>-code-review.md`, where you read `currentAttemptDir` from `omo ulw-loop status --json` (`.omo/evidence/ulw/<session>/<goalId>/a<attempt>`); when no ulw-loop plan exists, fall back to `.omo/evidence/<goal>-code-review.md`. The report must include findings by severity: CRITICAL, HIGH, MEDIUM, LOW. Include file and line references when a finding is tied to code.
 
 Return:
 - `codeQualityStatus`: CLEAR, WATCH, or BLOCK.