oh-my-opencode 4.16.2 → 4.17.0

package/packages/omo-codex/plugin/components/rules/src/codex-hook.ts

@@ -182,6 +182,7 @@ export async function runPostToolUseHook(
 		completedPostCompactKind !== undefined
 			? withPostCompactBudget(dynamicConfig, { model: input.model, transcriptPath: input.transcript_path })
 			: dynamicConfig,
+		input.model,
 	);
 	hydrateEngineState(engine, cachePath);
 	debugTimer.lap("hydrate", {
@@ -189,7 +190,7 @@ export async function runPostToolUseHook(
 		dynamicTargetFingerprints: engine.state.dynamicTargetFingerprints.size,
 		staticDedup: engine.state.staticDedup.size,
 	});
-	const dynamicTargetFingerprints = fingerprintDynamicTargets(input.cwd, targetPaths, config);
+	const dynamicTargetFingerprints = fingerprintDynamicTargets(input.cwd, targetPaths, config, input.model);
 	debugTimer.lap("fingerprint", { fingerprints: dynamicTargetFingerprints.length });
 	const pendingTargetFingerprints = dynamicTargetFingerprints.filter(
 		(target) => engine.state.dynamicTargetFingerprints.get(target.cacheKey) !== target.fingerprint,

package/packages/omo-codex/plugin/components/rules/src/dynamic-target-fingerprints.ts

@@ -1,12 +1,15 @@
 import { statSync } from "node:fs";
 import { resolve } from "node:path";
-import { isSameOrChildPath, toPosixPath, uniqueStrings } from "./path-utils.js";
-import { createRuleDiscoveryCache, findRuleCandidates } from "@oh-my-opencode/rules-engine/engine";
-import { hashContent } from "@oh-my-opencode/rules-engine/engine";
-import { sortCandidates } from "@oh-my-opencode/rules-engine/engine";
-import { findProjectRoot } from "@oh-my-opencode/rules-engine/engine";
-import { disabledSourcesFromConfig } from "@oh-my-opencode/rules-engine/engine";
 import type { PiRulesConfig, RuleCandidate } from "@oh-my-opencode/rules-engine/engine";
+import {
+	createRuleDiscoveryCache,
+	disabledSourcesFromConfig,
+	findProjectRoot,
+	findRuleCandidates,
+	hashContent,
+	sortCandidates,
+} from "@oh-my-opencode/rules-engine/engine";
+import { isSameOrChildPath, toPosixPath, uniqueStrings } from "./path-utils.js";
 
 export interface DynamicTargetFingerprint {
 	targetPath: string;
@@ -18,6 +21,7 @@ export function fingerprintDynamicTargets(
 	cwd: string,
 	targetPaths: ReadonlyArray<string>,
 	config: PiRulesConfig,
+	model?: string,
 ): DynamicTargetFingerprint[] {
 	const disabledSources = disabledSourcesFromConfig(config);
 	const discoveryCache = createRuleDiscoveryCache();
@@ -34,6 +38,7 @@ export function fingerprintDynamicTargets(
 			targetFile: string;
 			disabledSources?: ReadonlySet<string>;
 			cache: ReturnType<typeof createRuleDiscoveryCache>;
+			model?: string;
 		} = {
 			projectRoot,
 			targetFile: targetPath,
@@ -42,6 +47,9 @@ export function fingerprintDynamicTargets(
 		if (disabledSources !== undefined) {
 			findOptions.disabledSources = disabledSources;
 		}
+		if (model !== undefined) {
+			findOptions.model = model;
+		}
 		const candidates = findRuleCandidates(findOptions);
 		const candidateFingerprint = sortCandidates(candidates).map(fingerprintCandidate).join("\u0001");
 		const cacheKey = dynamicTargetCacheKey(targetPath);
@@ -52,6 +60,7 @@ export function fingerprintDynamicTargets(
 				[
 					"v1",
 					config.enabledSources === "auto" ? "auto" : config.enabledSources.join(","),
+					model ?? "",
 					projectRoot ?? "",
 					cacheKey,
 					candidateFingerprint,

package/packages/omo-codex/plugin/components/rules/src/rules-engine-factory.ts

@@ -14,12 +14,17 @@ interface RulesEngineFactoryOptions {
 
 const componentRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 
-export function createRulesEngine(options: RulesEngineFactoryOptions, config = configFromEnvironment(options.env)) {
+export function createRulesEngine(
+	options: RulesEngineFactoryOptions,
+	config = configFromEnvironment(options.env),
+	model?: string,
+) {
 	const platform = options.platform ?? process.platform;
 	const pluginRoot = options.env?.["PLUGIN_ROOT"] ?? process.env["PLUGIN_ROOT"] ?? componentRoot;
 
 	return createEngine(config, {
-		findCandidates: (finderOptions) => findRuleCandidates({ ...finderOptions, platform, pluginRoot }),
+		findCandidates: (finderOptions) =>
+			findRuleCandidates({ ...finderOptions, platform, pluginRoot, ...(model === undefined ? {} : { model }) }),
 		findProjectRoot,
 		readFile: (path) => {
 			try {

package/packages/omo-codex/plugin/components/rules/src/static-injection.ts

@@ -47,7 +47,7 @@ export function runStaticInjection(
 	}
 
 	const effectiveConfig = eventName === "UserPromptSubmit" ? withPromptBudget(config) : config;
-	const engine = createRulesEngine(options, effectiveConfig);
+	const engine = createRulesEngine(options, effectiveConfig, model);
 	hydrateEngineState(engine, cachePath);
 	engine.state.cwd = cwd;
 
@@ -89,7 +89,7 @@ function runPostCompactRecovery(input: PostCompactRecoveryInput): string {
 		model: input.model,
 		transcriptPath: input.transcriptPath,
 	});
-	const engine = createRulesEngine(input.options, effectiveConfig);
+	const engine = createRulesEngine(input.options, effectiveConfig, input.model);
 	hydrateEngineState(engine, input.cachePath);
 	engine.state.cwd = input.cwd;
 

package/packages/omo-codex/plugin/components/rules/test/codex-hook.test.ts

@@ -28,6 +28,7 @@ type SessionCache = {
 };
 
 const CLI_PATH = fileURLToPath(new URL("../dist/cli.js", import.meta.url));
+const COMPONENT_ROOT = fileURLToPath(new URL("..", import.meta.url));
 
 function runHookCli(input: string, subcommand = "post-tool-use", env: NodeJS.ProcessEnv = {}): Promise<CliResult> {
 	return new Promise((resolve, reject) => {
@@ -70,6 +71,12 @@ const RULES_ONLY_ENV = {
 	CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
 };
 
+const DYNAMIC_BUNDLED_ONLY_ENV = {
+	CODEX_RULES_MODE: "dynamic",
+	CODEX_RULES_ENABLED_SOURCES: "plugin-bundled",
+	PLUGIN_ROOT: COMPONENT_ROOT,
+};
+
 afterEach(() => {
 	for (const directory of tempDirectories.splice(0)) {
 		rmSync(directory, { recursive: true, force: true });
@@ -411,6 +418,31 @@ describe("codex rules hooks", () => {
 		expect(readSessionCache(pluginData).dynamicTargetFingerprints).toEqual(cachedState.dynamicTargetFingerprints);
 	});
 
+	it("#given bundled dynamic rules already injected for gpt-5.5 #when same target switches to gpt-5.6 #then emits the gpt-5.6 rule", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		const input = postToolUseInput(root, filePath);
+		const firstOutput = await runPostToolUseHook(input, {
+			pluginDataRoot: pluginData,
+			env: DYNAMIC_BUNDLED_ONLY_ENV,
+		});
+
+		// when
+		const secondOutput = await runPostToolUseHook(
+			{ ...input, model: "gpt-5.6-codex" },
+			{ pluginDataRoot: pluginData, env: DYNAMIC_BUNDLED_ONLY_ENV },
+		);
+
+		// then
+		const firstContext = parseHookOutput(firstOutput).hookSpecificOutput?.additionalContext ?? "";
+		const secondContext = parseHookOutput(secondOutput).hookSpecificOutput?.additionalContext ?? "";
+		expect(firstContext).toContain("based on GPT-5.5");
+		expect(firstContext).not.toContain("based on GPT-5.6");
+		expect(secondContext).toContain("based on GPT-5.6");
+		expect(secondContext).not.toContain("based on GPT-5.5");
+	});
+
 	it("#given default auto sources #when excluded AGENTS.md changes #then PostToolUse fingerprint stays stable", async () => {
 		// given
 		const { root, pluginData } = makeTempProject();

package/packages/omo-codex/plugin/components/rules/test/hephaestus-model-variant.test.ts

@@ -0,0 +1,106 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { type CodexSessionStartInput, runSessionStartHook } from "../src/codex-hook.js";
+import { findPluginBundledCandidates } from "@oh-my-opencode/rules-engine/engine";
+
+const GPT_55_VARIANT_PATH = "bundled-rules/hephaestus/gpt-5.5.md";
+const GPT_56_VARIANT_PATH = "bundled-rules/hephaestus/gpt-5.6.md";
+const BUNDLED_ONLY_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: "plugin-bundled",
+};
+const tempDirectories: string[] = [];
+let originalPluginRoot: string | undefined;
+
+afterEach(() => {
+	restoreEnv("PLUGIN_ROOT", originalPluginRoot);
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function makeProject(): { readonly root: string; readonly pluginData: string } {
+	originalPluginRoot = process.env["PLUGIN_ROOT"];
+	process.env["PLUGIN_ROOT"] = process.cwd();
+	const root = mkdtempSync(join(tmpdir(), "codex-rules-hephaestus-variant-project-"));
+	const pluginData = mkdtempSync(join(tmpdir(), "codex-rules-hephaestus-variant-data-"));
+	tempDirectories.push(root, pluginData);
+	writeFileSync(join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+	return { root, pluginData };
+}
+
+function sessionStartInput(root: string, model: string): CodexSessionStartInput {
+	return {
+		session_id: "session-1",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model,
+		permission_mode: "default",
+		source: "startup",
+	};
+}
+
+function restoreEnv(name: string, value: string | undefined): void {
+	if (value === undefined) {
+		delete process.env[name];
+		return;
+	}
+	process.env[name] = value;
+}
+
+describe("Hephaestus bundled rule model variants", () => {
+	it("#given packaged bundled rules #when discovering with a gpt-5.5 model #then only the gpt-5.5 variant is included", () => {
+		const candidates = findPluginBundledCandidates({ pluginRoot: process.cwd(), model: "gpt-5.5" });
+		const paths = candidates.map((candidate) => candidate.relativePath);
+
+		expect(paths).toContain(GPT_55_VARIANT_PATH);
+		expect(paths).not.toContain(GPT_56_VARIANT_PATH);
+	});
+
+	it("#given packaged bundled rules #when discovering with a gpt-5.6 family model #then only the gpt-5.6 variant is included", () => {
+		const candidates = findPluginBundledCandidates({ pluginRoot: process.cwd(), model: "gpt-5.6-codex" });
+		const paths = candidates.map((candidate) => candidate.relativePath);
+
+		expect(paths).toContain(GPT_56_VARIANT_PATH);
+		expect(paths).not.toContain(GPT_55_VARIANT_PATH);
+	});
+
+	it("#given packaged bundled rules #when discovering without a model #then the gpt-5.5 variant is the fallback", () => {
+		const candidates = findPluginBundledCandidates({ pluginRoot: process.cwd() });
+		const paths = candidates.map((candidate) => candidate.relativePath);
+
+		expect(paths).toContain(GPT_55_VARIANT_PATH);
+		expect(paths).not.toContain(GPT_56_VARIANT_PATH);
+	});
+
+	it("#given a gpt-5.5 session #when SessionStart runs #then the gpt-5.5 identity is injected in full", async () => {
+		const { root, pluginData } = makeProject();
+
+		const output = await runSessionStartHook(sessionStartInput(root, "gpt-5.5"), {
+			pluginDataRoot: pluginData,
+			env: BUNDLED_ONLY_ENV,
+		});
+
+		expect(output).toContain(`Instructions from: ${join(process.cwd(), GPT_55_VARIANT_PATH)}`);
+		expect(output).toContain("based on GPT-5.5");
+		expect(output).not.toContain("based on GPT-5.6");
+		expect(output).not.toContain("[Truncated. Full:");
+	});
+
+	it("#given a gpt-5.6 session #when SessionStart runs #then the gpt-5.6 identity is injected in full", async () => {
+		const { root, pluginData } = makeProject();
+
+		const output = await runSessionStartHook(sessionStartInput(root, "gpt-5.6-codex"), {
+			pluginDataRoot: pluginData,
+			env: BUNDLED_ONLY_ENV,
+		});
+
+		expect(output).toContain(`Instructions from: ${join(process.cwd(), GPT_56_VARIANT_PATH)}`);
+		expect(output).toContain("based on GPT-5.6");
+		expect(output).not.toContain("based on GPT-5.5");
+		expect(output).not.toContain("[Truncated. Full:");
+	});
+});

package/packages/omo-codex/plugin/components/start-work-continuation/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/start-work-continuation/dist/cli.js\" hook stop",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.16.2) Checking Start-Work Continuation"
+						"statusMessage": "(OmO 4.17.0) Checking Start-Work Continuation"
 					}
 				]
 			}
@@ -19,7 +19,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/start-work-continuation/dist/cli.js\" hook subagent-stop",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.16.2) Checking Start-Work Continuation"
+						"statusMessage": "(OmO 4.17.0) Checking Start-Work Continuation"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/start-work-continuation/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-start-work-continuation",
-	"version": "4.16.2",
+	"version": "4.17.0",
 	"description": "Codex Stop hook continuation injector for omo-codex start-work plans.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/start-work-continuation/test/codex-hook.test.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
@@ -96,84 +96,6 @@ describe("start-work Stop hook", () => {
 		expect(output).toBe("");
 	});
 
-	it("#given active codex work #when continuation directive is emitted #then subagent guidance is reliable", () => {
-		// given
-		const workspace = createWorkspace({
-			boulderJson: createBoulderJson({ sessionIds: ["codex:sess_abc"], status: "active" }),
-			planMarkdown: ["# Plan", "", "## TODOs", "- [ ] First"].join("\n"),
-		});
-		const fs = createMemoryFs();
-
-		// when
-		const output = runStopHook(createStopInput(workspace), fs);
-
-		// then
-		const parsed = parseBlockOutput(output);
-		expect(parsed.reason).toMatch(/TASK:/);
-		expect(parsed.reason).toMatch(/fork_context:\s*false/);
-		expect(parsed.reason).toMatch(/wait_agent.*mailbox signals/);
-		expect(parsed.reason).toMatch(/TASK STILL ACTIVE/);
-		expect(parsed.reason).toMatch(/respawn.*smaller/);
-		expect(parsed.reason).toMatch(/WORKING:/);
-	});
-
-	it("#given active codex work #when continuation directive is emitted #then QA weight is tier-scoped without echo bloat", () => {
-		// given
-		const workspace = createWorkspace({
-			boulderJson: createBoulderJson({ sessionIds: ["codex:sess_abc"], status: "active" }),
-			planMarkdown: ["# Plan", "", "## TODOs", "- [ ] First"].join("\n"),
-		});
-		const fs = createMemoryFs();
-
-		// when
-		const output = runStopHook(createStopInput(workspace), fs);
-
-		// then
-		const parsed = parseBlockOutput(output);
-		expect(parsed.reason).toMatch(/LIGHT/);
-		expect(parsed.reason).toMatch(/HEAVY/);
-		expect(parsed.reason).toMatch(/When unsure[^.]{0,30}HEAVY/);
-		expect(parsed.reason).toMatch(/mirrors its implementation/);
-		expect((parsed.reason.match(/malformed input, prompt injection/g) ?? []).length).toBe(1);
-		expect(parsed.reason.split(/\s+/).filter(Boolean).length).toBeLessThanOrEqual(1135);
-	});
-
-	it("#given active codex work #when continuation directive is emitted #then PR lifecycle stays worktree-bound", () => {
-		// given
-		const workspace = createWorkspace({
-			boulderJson: createBoulderJson({
-				sessionIds: ["codex:sess_abc"],
-				status: "active",
-				worktreePath: "/tmp/worktree",
-			}),
-			planMarkdown: ["# Plan", "", "## TODOs", "- [ ] First"].join("\n"),
-		});
-		const fs = createMemoryFs();
-
-		// when
-		const output = runStopHook(createStopInput(workspace), fs);
-
-		// then
-		const parsed = parseBlockOutput(output);
-		expect(parsed.reason).toContain("PR or branch implementation/review/merge work requires a task-owned git worktree");
-		expect(parsed.reason).toContain("Treat the main worktree as read-only context");
-		expect(parsed.reason).toContain("create/update the PR, wait for CI/review/Cubic gates, merge by default");
-		expect(parsed.reason).toContain("Do not create a PR, PR handoff, branch handoff, merge");
-	});
-
-	it("#given stop hook source #when inspected #then it remains Boulder-only without planning bootstrap logic", () => {
-		// given
-		const hook = readFileSync(new URL("../src/codex-hook.ts", import.meta.url), "utf8");
-
-		// then
-		expect(hook).toMatch(/readContinuationState/);
-		expect(hook).toMatch(/START_WORK_CONTINUATION_DIRECTIVE/);
-		expect(hook).toMatch(/decision:\s*"block"/);
-		expect(hook).not.toMatch(
-			/\bulw-plan\b|\bspawn_agent\b|\brequest_user_input\b|bootstrap|selectable plan|Phase 1|Create or update Boulder state/i,
-		);
-	});
-
 	it("#given active work belongs to another harness #when hook runs #then returns empty output", () => {
 		// given
 		const workspace = createWorkspace({

package/packages/omo-codex/plugin/components/teammode/AGENTS.md

@@ -7,18 +7,19 @@
 Codex team-mode component. Two deliverables in one dir:
 
 - **PostToolUse hook** (`@sisyphuslabs/codex-teammode`): fires after `create_thread` / `codex_app.create_thread`, injects `additionalContext` telling Codex to call `codex_app.set_thread_title` NOW with the real task/role. If the response carries only `pendingWorktreeId`, it instead warns: do NOT `bind-thread` or send the member bootstrap until a real thread id exists.
-- **`teammode` skill**: script-driven orchestration of a named team of Codex threads. Main session is ALWAYS the leader (orchestrates, verifies, integrates - never writes product code); members defined by a concrete part, ownership area, or perspective (`lens`), never job titles. Durable state under `.omo/teams/{session_id}/`: `team.json` + auto-generated `guide.md` member field manual + `artifacts/` exchange dir.
+- **`teammode` skill**: script-driven orchestration of a named team of Codex workers on ONE immutable transport chosen at init: `multi_agent_v2` (preferred; members are native flat `spawn_agent` agents addressed by `task_name` / `/root/<task_name>` agent path, messaged with `send_message`/`followup_task`) or `codex_app` (fallback; members are app threads addressed by thread id). The leader inspects the active tool list and announces the selected transport to the user BEFORE `init`. Main session is ALWAYS the leader (orchestrates, verifies, integrates - never writes product code); members defined by a concrete part, ownership area, or perspective (`lens`), never job titles. Durable state under `.omo/teams/{session_id}/`: `team.json` + auto-generated `guide.md` member field manual + `artifacts/` exchange dir.
 
 ## KEY FILES
 
 - `src/codex-hook.ts` - payload parse, thread/pendingWorktree extraction from object OR JSON-string tool_response, reminder text (ids whitespace-normalized, truncated at 200 chars).
 - `src/cli.ts` - argv dispatch; only `hook post-tool-use`.
 - `hooks/hooks.json` - matcher `^(create_thread|codex_app\.create_thread)$`, runs `node ${PLUGIN_ROOT}/dist/cli.js hook post-tool-use`, timeout 10.
-- `skills/teammode/SKILL.md` - leader protocol: team-vs-subagent decision matrix, ulw-plan parallel-wave mapping, "Let members work - do not rush them" (4-reason message gate; quiet between heartbeats = working, not stalled), archive/delete/stop rules.
-- `skills/teammode/scripts/team.mjs` - controller CLI: init / add-member / bind-thread / member-prompt / set-status / worktree-add / worktree-remove / integrate / archive / delete / status / guide. Zero npm deps, node builtins only, runs under node or bun on all 3 OSes.
-- `skills/teammode/scripts/team-state.mjs` - state model + persistence: per-team `.team.lock` dir lock (`owner.json`; `OMO_TEAMMODE_LOCK_TIMEOUT_MS` / `OMO_TEAMMODE_LOCK_RETRY_MS`), atomic tmp+rename writes, symlink- and escape-guarded team dirs, schemaVersion 2, `MIN_MEMBERS = 2`, unique focus/name/threadTitle invariants.
+- `skills/teammode/SKILL.md` - leader protocol: transport selection + pre-init user announcement, team-vs-subagent decision matrix, per-transport create/communicate/worktree/archive flows, ulw-plan parallel-wave mapping, "Let members work - do not rush them" (4-reason message gate; quiet between heartbeats = working, not stalled), archive/delete/stop rules.
+- `skills/teammode/scripts/team.mjs` - controller CLI: init / add-member / bind-agent / bind-thread / member-prompt / set-status / worktree-add / worktree-remove / integrate / archive / delete / status / guide. Zero npm deps, node builtins only, runs under node or bun on all 3 OSes.
+- `skills/teammode/scripts/team-transport.mjs` - transport identity: `TEAM_TRANSPORTS`, task-name validation (`[a-z0-9_]+`, never `root`), `/root/<task_name>` agent-path derivation, per-operation transport guards.
+- `skills/teammode/scripts/team-state.mjs` - state model + persistence: per-team `.team.lock` dir lock (`owner.json`; `OMO_TEAMMODE_LOCK_TIMEOUT_MS` / `OMO_TEAMMODE_LOCK_RETRY_MS`), atomic tmp+rename writes, symlink- and escape-guarded team dirs, schemaVersion 3 (legacy 2 migrates in memory to `codex_app` and persists on the next mutation), `MIN_MEMBERS = 2`, unique focus/name invariants plus per-transport identity invariants (taskName/agentPath on V2, threadTitle on codex_app).
 - `skills/teammode/scripts/team-worktree.mjs` - git worktree provisioning + `merge --no-ff --no-edit` integration; conflict leaves the tree mid-merge for the leader to resolve and re-run.
-- `skills/teammode/scripts/team-guide.mjs` - pure string builders for `guide.md` + the short member bootstrap trigger (`codex://threads/<id>` deep links, `WORKING:` / `BLOCKED:` heartbeat rules, English-only member traffic).
+- `skills/teammode/scripts/team-guide.mjs` - pure string builders for `guide.md` + the short member bootstrap trigger, branched by transport (V2: `/root` leader target + `members[].agentPath` peers + `send_message`/`followup_task`; codex_app: `codex_app.send_message_to_thread` + `codex://threads/<id>` deep links), `WORKING:` / `BLOCKED:` heartbeat rules, English-only member traffic.
 - `test/thread-title-hook.test.ts` - hook unit tests (vitest-style imports, run via `bun test`).
 
 ## WHERE TO LOOK
@@ -26,8 +27,9 @@ Codex team-mode component. Two deliverables in one dir:
 | Task | Location |
 |------|----------|
 | Hook reminder text | `src/codex-hook.ts` `threadTitleReminder` + `test/thread-title-hook.test.ts`; `plugin/test/teammode-thread-title.test.mjs` pins the exact strings |
-| Skill protocol text | `skills/teammode/SKILL.md`; contract tests `plugin/test/teammode-{communication,worktree,safety,archive-ambiguity,thread-links}.test.mjs` pin phrases |
-| team.json shape | `team-state.mjs` (single source of the shape; `validateTeam` rejects schemaVersion != 2) |
+| Skill protocol text | `skills/teammode/SKILL.md`; contract tests `plugin/test/teammode-{transport,communication,worktree,safety,archive-ambiguity,thread-links}.test.mjs` pin phrases |
+| team.json shape | `team-state.mjs` (single source of the shape; `validateTeam` migrates schemaVersion 2 to 3 and rejects anything else) |
+| Transport rules | `team-transport.mjs` (`parseTeamTransport`, `parseTaskName`, `assertTransport`) + `plugin/test/teammode-transport.test.mjs` |
 | Branch naming, worktree paths, merge | `team-worktree.mjs` (`team/<sessionId>/<memberId>` branches, worktrees confined to `<team dir>/worktrees/<memberId>`) |
 | Hook wiring | `hooks/hooks.json` (component) + `plugin/hooks/post-tool-use-checking-thread-title-hygiene.json` (aggregate; adds `commandWindows` powershell node-dispatch) |
 
@@ -40,7 +42,8 @@ Codex team-mode component. Two deliverables in one dir:
 - All mutating subcommands serialize through `withTeamLock` and re-read committed state before writing. "team state is locked by ..." means the mutation did NOT happen; retry, or inspect `.team.lock/owner.json` after a crash.
 - Archive ambiguity: "Ambiguous Codex thread id" from `codex_app.set_thread_archived` is an app-thread archival blocker, not a team-state blocker. Record it via `archive --note`, never claim the thread was archived, never delete team state before evidence is copied or the user accepts the loss.
 - `integrate` lands member branches with merge commits only (`--no-ff`); never squash or rebase.
-- `bind-thread` refuses while the team has fewer than 2 members; a single-member team is a subagent, not a team. Member focus, name, and threadTitle must each be unique (case/whitespace-insensitive).
-- Every member is a real `codex_app.create_thread` thread bound via `bind-thread`; a spawned in-process subagent (`multi_agent_v1.spawn_agent` or flat `spawn_agent`) is never a substitute.
+- `bind-agent`/`bind-thread` refuse while the team has fewer than 2 members; a single-member team is a subagent, not a team. Member focus and name must be unique (case/whitespace-insensitive); V2 adds unique taskName/agentPath, codex_app adds unique threadTitle.
+- Binding is transport-strict and mutation-safe: `bind-thread` on a V2 team and `bind-agent` on a codex_app team fail before persisting, leaving `team.json` byte-identical; `bind-agent` also rejects any path other than the member's precomputed `/root/<task_name>`.
+- On `multi_agent_v2` teams a member IS a durable flat `spawn_agent` agent (spawned with `fork_turns: "none"`, re-tasked via `followup_task`, no title/deep-link/archive primitive - `interrupt_agent` + durable team state is the archive story). On `codex_app` teams every member is a real `codex_app.create_thread` thread bound via `bind-thread`, and a spawned in-process subagent is never a substitute there. V2 has no spawn-time cwd: create worktrees BEFORE spawn so the bootstrap carries the path.
 - The hook must stay silent (empty stdout) on unrelated tools and malformed payloads; it never blocks a Codex turn.
 - `init` with an explicit `--session <leader thread id>` makes `leader.sessionId` messageable; without it members cannot report and the leader is stuck polling. Re-running `init` is a safe no-op.

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

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.16.2) Checking Thread Title Hygiene"
+						"statusMessage": "(OmO 4.17.0) Checking Thread Title Hygiene"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-teammode",
-	"version": "4.16.2",
+	"version": "4.17.0",
 	"description": "Codex team-mode hook component that keeps background thread titles descriptive after create_thread.",
 	"type": "module",
 	"private": true,