oh-my-codex 0.18.6 → 0.18.8

package/dist/scripts/__tests__/codex-native-hook.test.js

@@ -22,6 +22,8 @@ import { getLegacyWikiDir, serializePage, writePage } from "../../wiki/storage.j
 import { WIKI_SCHEMA_VERSION } from "../../wiki/types.js";
 import { createUltragoalPlan, readUltragoalPlan } from "../../ultragoal/artifacts.js";
 import { getBaseStateDir } from "../../state/paths.js";
+import { maybeNudgeLeaderForAllowedWorkerStop } from "../notify-hook/team-worker-stop.js";
+import { MAX_NATIVE_STDIN_JSON_BYTES } from "../hook-payload-guard.js";
 function nativeHookScriptPath() {
     return join(process.cwd(), "dist", "scripts", "codex-native-hook.js");
 }
@@ -44,6 +46,23 @@ async function writeJson(path, value) {
     await mkdir(dirname(path), { recursive: true }).catch(() => { });
     await writeFile(path, JSON.stringify(value, null, 2));
 }
+async function writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId) {
+    await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+    await writeJson(join(stateDir, "session.json"), {
+        session_id: sessionId,
+        native_session_id: nativeSessionId,
+        cwd,
+    });
+}
+async function writeSessionSkillActiveState(stateDir, sessionId, skill, phase) {
+    await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+        active: true,
+        skill,
+        phase,
+        session_id: sessionId,
+        active_skills: [{ skill, phase, active: true, session_id: sessionId }],
+    });
+}
 async function setTeamPaneIds(cwd, teamName, paneIds) {
     for (const fileName of ["config.json", "manifest.v2.json"]) {
         const filePath = join(cwd, ".omx", "state", "team", teamName, fileName);
@@ -104,6 +123,12 @@ async function withLoreGuardConfig(value, prefix, run) {
     }
 }
 function buildWorkerStopFakeTmux(tmuxLogPath, options = {}) {
+    const rawCaptureText = options.captureText ?? (options.busyLeader ? "• Working… (esc to interrupt)" : "› ready");
+    const captureText = `'${rawCaptureText.replace(/'/g, "'\"'\"'")}'`;
+    const currentCommand = `'${(options.currentCommand ?? "codex").replace(/'/g, "'\"'\"'")}'`;
+    const sendDelaySeconds = Math.max(0, options.sendDelayMs ?? 0) / 1000;
+    const removePathOnSend = options.removePathOnSend ? `'${options.removePathOnSend.replace(/'/g, "'\"'\"'")}'` : "";
+    const removePathOnCapture = options.removePathOnCapture ? `'${options.removePathOnCapture.replace(/'/g, "'\"'\"'")}'` : "";
     return `#!/usr/bin/env bash
 set -eu
 echo "$@" >> "${tmuxLogPath}"
@@ -124,17 +149,20 @@ if [[ "$cmd" == "display-message" ]]; then
     "#{pane_id}") echo "%42" ;;
     "#{pane_current_path}") pwd ;;
     "#{pane_start_command}") echo "codex" ;;
-    "#{pane_current_command}") echo "codex" ;;
+    "#{pane_current_command}") printf '%s\\n' ${currentCommand} ;;
     "#S") echo "omx-team-worker-stop" ;;
     *) ;;
   esac
   exit 0
 fi
 if [[ "$cmd" == "capture-pane" ]]; then
-  ${options.busyLeader ? 'echo "• Working… (esc to interrupt)"' : 'echo "› ready"'}
+  ${removePathOnCapture ? `rm -rf ${removePathOnCapture}` : ""}
+  printf '%s\\n' ${captureText}
   exit 0
 fi
 if [[ "$cmd" == "send-keys" ]]; then
+  ${sendDelaySeconds > 0 ? `sleep ${sendDelaySeconds}` : ""}
+  ${removePathOnSend ? `rm -rf ${removePathOnSend}` : ""}
   ${options.failSend ? "exit 1" : "exit 0"}
 fi
 exit 0
@@ -281,13 +309,78 @@ describe("codex native hook dispatch", () => {
     it("does not treat a different module url as the main module", () => {
         assert.equal(isCodexNativeHookMainModule(pathToFileURL("/tmp/omx native/other-script.js").href, "/tmp/omx native/codex-native-hook.js"), false);
     });
-    it("emits deterministic JSON stdout when CLI stdin is malformed", () => {
+    it("emits schema-safe JSON stdout when CLI stdin is malformed", () => {
         const stdout = runNativeHookCli("{");
         const output = parseSingleJsonStdout(stdout);
+        assert.equal(output.continue, false);
+        assert.equal(output.stopReason, "native_hook_stdin_parse_error");
+        assert.equal(output.hookSpecificOutput, undefined);
+        assert.match(String(output.systemMessage ?? ""), /stdin JSON parsing failed inside codex-native-hook:/);
+    });
+    it("redacts unterminated prompt-like malformed stdin fields", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-malformed-unterminated-"));
+        try {
+            const privatePrompt = "PRIVATE_UNTERMINATED_PROMPT";
+            const malformed = `{hook_event_name:"PostToolUse", prompt:"${privatePrompt}`;
+            const result = spawnSync(process.execPath, [nativeHookScriptPath()], {
+                cwd,
+                input: malformed,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.equal(result.stderr, "");
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.stopReason, "native_hook_stdin_parse_error");
+            const log = await readFile(join(cwd, ".omx", "logs", `native-hook-${new Date().toISOString().split("T")[0]}.jsonl`), "utf-8");
+            const entry = JSON.parse(log.trim());
+            const prefix = String(entry.raw_input_prefix ?? "");
+            assert.doesNotMatch(prefix, new RegExp(privatePrompt));
+            assert.match(prefix, /prompt:"\[REDACTED\]"/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("logs a bounded redacted raw stdin prefix when CLI stdin is malformed", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-malformed-log-prefix-"));
+        try {
+            const secret = "sk-test-secret123456";
+            const promptText = "summarize private launch notes";
+            const malformed = `{hook_event_name:"PostToolUse", access_token:"${secret}", prompt:"${promptText}", text:"${promptText}", bad:"${"x".repeat(400)}"}${String.fromCharCode(10, 0, 7)}`;
+            const result = spawnSync(process.execPath, [nativeHookScriptPath()], {
+                cwd,
+                input: malformed,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.equal(result.stderr, "");
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.stopReason, "native_hook_stdin_parse_error");
+            const log = await readFile(join(cwd, ".omx", "logs", `native-hook-${new Date().toISOString().split("T")[0]}.jsonl`), "utf-8");
+            const entry = JSON.parse(log.trim());
+            const prefix = String(entry.raw_input_prefix ?? "");
+            assert.equal(entry.type, "native_hook_stdin_parse_error");
+            assert.equal(entry.raw_input_length, Buffer.byteLength(malformed, "utf-8"));
+            assert.ok(prefix.length <= 240, `prefix should be bounded, got ${prefix.length}`);
+            assert.doesNotMatch(prefix, /[\u0000-\u001f\u007f-\u009f]/);
+            assert.doesNotMatch(prefix, new RegExp(secret));
+            assert.doesNotMatch(prefix, new RegExp(promptText));
+            assert.match(prefix, /\[REDACTED\]/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("emits Stop-schema-safe block JSON when malformed stdin still identifies Stop", () => {
+        const stdout = runNativeHookCli('{hook_event_name:"Stop",');
+        const output = parseSingleJsonStdout(stdout);
         assert.equal(output.decision, "block");
         assert.equal(output.reason, "OMX native hook received malformed JSON input. Preserve runtime state, inspect the emitting hook payload yourself, and retry with valid JSON.");
-        assert.equal(output.hookSpecificOutput?.hookEventName, "Unknown");
-        assert.match(String(output.hookSpecificOutput?.additionalContext ?? ""), /stdin JSON parsing failed inside codex-native-hook:/);
+        assert.equal(output.stopReason, "native_hook_stdin_parse_error");
+        assert.equal(output.hookSpecificOutput, undefined);
+        assert.match(String(output.systemMessage ?? ""), /stdin JSON parsing failed inside codex-native-hook:/);
     });
     it("emits parseable no-op JSON stdout for inactive Stop CLI runs", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-stop-noop-json-"));
@@ -301,6 +394,112 @@ describe("codex native hook dispatch", () => {
             }, { cwd });
             const output = parseSingleJsonStdout(stdout);
             assert.deepEqual(output, {});
+            assert.equal(existsSync(join(cwd, ".omx", "state")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("returns empty JSON for oversized Stop stdin without parsing or creating inactive state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-stop-oversized-"));
+        try {
+            const oversizedStop = JSON.stringify({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-cli-stop-oversized",
+                transcript: "x".repeat(MAX_NATIVE_STDIN_JSON_BYTES + 1),
+            });
+            const stdout = runNativeHookCli(oversizedStop, { cwd });
+            assert.deepEqual(parseSingleJsonStdout(stdout), {});
+            assert.equal(existsSync(join(cwd, ".omx", "state")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks oversized Stop stdin when current session autopilot is active", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-stop-oversized-active-"));
+        try {
+            await writeActiveAutopilotSession(cwd, "sess-cli-stop-oversized-active");
+            const oversizedStop = JSON.stringify({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "native-session-hidden-by-oversized-payload",
+                transcript: "x".repeat(MAX_NATIVE_STDIN_JSON_BYTES + 1),
+            });
+            const output = parseSingleJsonStdout(runNativeHookCli(oversizedStop, { cwd }));
+            assert.equal(output.decision, "block");
+            assert.equal(output.stopReason, "native_stop_stdin_oversized_active_workflow");
+            assert.match(String(output.systemMessage ?? ""), /active current-session workflow state/);
+            assert.equal(existsSync(join(cwd, ".omx", "logs")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block oversized Stop stdin for unrelated root autopilot state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-stop-oversized-stale-root-"));
+        try {
+            await writeJson(join(cwd, ".omx", "state", "session.json"), {
+                session_id: "sess-current-without-active-autopilot",
+                cwd,
+            });
+            await writeJson(join(cwd, ".omx", "state", "autopilot-state.json"), {
+                active: true,
+                current_phase: "execution",
+            });
+            const oversizedStop = JSON.stringify({
+                hook_event_name: "Stop",
+                cwd,
+                transcript: "x".repeat(MAX_NATIVE_STDIN_JSON_BYTES + 1),
+            });
+            assert.deepEqual(parseSingleJsonStdout(runNativeHookCli(oversizedStop, { cwd })), {});
+            assert.equal(existsSync(join(cwd, ".omx", "logs")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block oversized Stop stdin when terminal run-state shadows stale autopilot state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-stop-oversized-terminal-run-"));
+        try {
+            const sessionId = "sess-cli-stop-oversized-terminal-run";
+            await writeActiveAutopilotSession(cwd, sessionId);
+            await writeJson(join(cwd, ".omx", "state", "sessions", sessionId, "run-state.json"), {
+                version: 1,
+                active: false,
+                mode: "autopilot",
+                outcome: "finish",
+                lifecycle_outcome: "finished",
+                current_phase: "complete",
+                completed_at: "2026-05-20T11:00:00.000Z",
+                updated_at: "2026-05-20T11:00:00.000Z",
+            });
+            const oversizedStop = JSON.stringify({
+                hook_event_name: "Stop",
+                cwd,
+                transcript: "x".repeat(MAX_NATIVE_STDIN_JSON_BYTES + 1),
+            });
+            assert.deepEqual(parseSingleJsonStdout(runNativeHookCli(oversizedStop, { cwd })), {});
+            assert.equal(existsSync(join(cwd, ".omx", "logs")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("fails closed for oversized non-Stop stdin before parsing", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-nonstop-oversized-"));
+        try {
+            const oversizedPrompt = JSON.stringify({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-cli-prompt-oversized",
+                prompt: "x".repeat(MAX_NATIVE_STDIN_JSON_BYTES + 1),
+            });
+            const output = parseSingleJsonStdout(runNativeHookCli(oversizedPrompt, { cwd }));
+            assert.equal(output.continue, false);
+            assert.equal(output.stopReason, "native_hook_stdin_oversized");
+            assert.match(String(output.systemMessage ?? ""), /rejected oversized stdin JSON before parsing/);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -915,6 +1114,50 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("keeps a self-parented native role thread as subagent evidence", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-self-parented-subagent-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "omx-autopilot-session";
+            const nativeRoleThreadId = "codex-architect-thread";
+            await mkdir(join(stateDir, "sessions", canonicalSessionId), { recursive: true });
+            await writeSessionStart(cwd, canonicalSessionId, {
+                nativeSessionId: nativeRoleThreadId,
+            });
+            const transcriptPath = join(cwd, "architect-subagent-rollout.jsonl");
+            await writeFile(transcriptPath, `${JSON.stringify({
+                type: "session_meta",
+                payload: {
+                    id: nativeRoleThreadId,
+                    source: {
+                        subagent: {
+                            thread_spawn: {
+                                parent_thread_id: nativeRoleThreadId,
+                                depth: 1,
+                                agent_nickname: "Architect",
+                                agent_role: "architect",
+                            },
+                        },
+                    },
+                    agent_nickname: "Architect",
+                    agent_role: "architect",
+                },
+            })}\n`);
+            await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: nativeRoleThreadId,
+                transcript_path: transcriptPath,
+            }, { cwd, sessionOwnerPid: process.pid });
+            const tracking = JSON.parse(await readFile(join(stateDir, "subagent-tracking.json"), "utf-8"));
+            assert.equal(tracking.sessions?.[canonicalSessionId]?.leader_thread_id, undefined);
+            assert.equal(tracking.sessions?.[canonicalSessionId]?.threads?.[nativeRoleThreadId]?.kind, "subagent");
+            assert.equal(tracking.sessions?.[canonicalSessionId]?.threads?.[nativeRoleThreadId]?.mode, "architect");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("does not attach a subagent SessionStart to an unrelated canonical leader", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-subagent-session-start-mismatch-"));
         try {
@@ -1018,6 +1261,97 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("prefers the OMX owner session id when a native new session revives HUD", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-owner-session-revive-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const ownerSessionId = "omx-launch-owner-hud";
+            const oldNativeSessionId = "codex-native-hud-old";
+            const nativeSessionId = "codex-native-hud-new";
+            await mkdir(stateDir, { recursive: true });
+            await writeSessionStart(cwd, ownerSessionId, {
+                nativeSessionId: oldNativeSessionId,
+                pid: process.pid,
+            });
+            await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: nativeSessionId,
+            }, {
+                cwd,
+                sessionOwnerPid: process.pid,
+            });
+            const sessionState = JSON.parse(await readFile(join(stateDir, "session.json"), "utf-8"));
+            assert.equal(sessionState.session_id, nativeSessionId);
+            assert.equal(sessionState.native_session_id, nativeSessionId);
+            assert.equal(sessionState.previous_native_session_id, oldNativeSessionId);
+            assert.equal(sessionState.owner_omx_session_id, ownerSessionId);
+            let reconcileCall = null;
+            const promptResult = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-hud-owner",
+                turn_id: "turn-hud-owner",
+                prompt: "$ralplan fix native new hud owner handoff",
+            }, {
+                cwd,
+                reconcileHudForPromptSubmitFn: async (hookCwd, deps = {}) => {
+                    reconcileCall = { cwd: hookCwd, sessionId: deps.sessionId, sessionIds: deps.sessionIds };
+                    return { status: "recreated", paneId: "%9", desiredHeight: 3, duplicateCount: 0 };
+                },
+            });
+            assert.equal(promptResult.omxEventName, "keyword-detector");
+            assert.deepEqual(reconcileCall, {
+                cwd,
+                sessionId: ownerSessionId,
+                sessionIds: [ownerSessionId, nativeSessionId],
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("falls back to the canonical session id for malformed HUD owner ids", async () => {
+        for (const [index, invalidOwnerSessionId] of ["codex-native-hud-owner", "omx-../../stale"].entries()) {
+            const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-invalid-owner-revive-"));
+            try {
+                const stateDir = join(cwd, ".omx", "state");
+                const canonicalSessionId = "omx-launch-hud-safe";
+                const nativeSessionId = "codex-native-hud-safe";
+                await mkdir(join(stateDir, "sessions", canonicalSessionId), { recursive: true });
+                await writeSessionStart(cwd, canonicalSessionId);
+                const sessionStatePath = join(stateDir, "session.json");
+                const sessionState = JSON.parse(await readFile(sessionStatePath, "utf-8"));
+                sessionState.owner_omx_session_id = invalidOwnerSessionId;
+                await writeJson(sessionStatePath, sessionState);
+                let reconcileCall = null;
+                const promptResult = await dispatchCodexNativeHook({
+                    hook_event_name: "UserPromptSubmit",
+                    cwd,
+                    session_id: nativeSessionId,
+                    thread_id: `thread-hud-invalid-owner-${index}`,
+                    turn_id: "turn-hud-invalid-owner",
+                    prompt: "$ralplan fix malformed hud owner handoff",
+                }, {
+                    cwd,
+                    reconcileHudForPromptSubmitFn: async (hookCwd, deps = {}) => {
+                        reconcileCall = { cwd: hookCwd, sessionId: deps.sessionId, sessionIds: deps.sessionIds };
+                        return { status: "recreated", paneId: "%9", desiredHeight: 3, duplicateCount: 0 };
+                    },
+                });
+                assert.equal(promptResult.omxEventName, "keyword-detector");
+                assert.deepEqual(reconcileCall, {
+                    cwd,
+                    sessionId: canonicalSessionId,
+                    sessionIds: [canonicalSessionId, nativeSessionId],
+                });
+            }
+            finally {
+                await rm(cwd, { recursive: true, force: true });
+            }
+        }
+    });
     it("passes the canonical OMX session id when UserPromptSubmit revives HUD", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-session-revive-"));
         try {
@@ -2208,75 +2542,376 @@ standardMaxRounds = 15
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("records plugin-prefixed keyword activation from UserPromptSubmit payloads", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-plugin-prefixed-"));
-        try {
-            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
-            const result = await dispatchCodexNativeHook({
-                hook_event_name: "UserPromptSubmit",
-                cwd,
-                session_id: "sess-plugin-1",
-                thread_id: "thread-plugin-1",
-                turn_id: "turn-plugin-1",
-                prompt: "$oh-my-codex:ralplan implement issue #1307",
-            }, { cwd });
-            assert.equal(result.omxEventName, "keyword-detector");
-            assert.equal(result.skillState?.skill, "ralplan");
-            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
-            assert.match(message, /\$oh-my-codex:ralplan" -> ralplan/);
-            assert.match(message, /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
-            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-plugin-1", "ralplan-state.json")), true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it("injects autopilot ralplan consensus gate guidance on prompt activation", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-gate-"));
+    it("does not treat a corrupt leader kind=subagent tracker entry as native subagent prompt scope", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-corrupt-leader-subagent-"));
         try {
-            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "sess-corrupt-leader";
+            const leaderNativeSessionId = "native-corrupt-leader";
+            const nowIso = new Date().toISOString();
+            await writeJson(join(stateDir, "session.json"), {
+                session_id: canonicalSessionId,
+                native_session_id: leaderNativeSessionId,
+            });
+            await writeJson(join(stateDir, "subagent-tracking.json"), {
+                schemaVersion: 1,
+                sessions: {
+                    [canonicalSessionId]: {
+                        session_id: canonicalSessionId,
+                        leader_thread_id: leaderNativeSessionId,
+                        updated_at: nowIso,
+                        threads: {
+                            [leaderNativeSessionId]: {
+                                thread_id: leaderNativeSessionId,
+                                kind: "subagent",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 2,
+                            },
+                        },
+                    },
+                },
+            });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "UserPromptSubmit",
                 cwd,
-                session_id: "sess-autopilot-ralplan-gate",
-                thread_id: "thread-autopilot-ralplan-gate",
-                turn_id: "turn-autopilot-ralplan-gate",
-                prompt: "$autopilot implement issue #2430",
+                session_id: leaderNativeSessionId,
+                thread_id: leaderNativeSessionId,
+                turn_id: "turn-corrupt-leader",
+                prompt: "$autopilot continue this review blocker fix",
             }, { cwd });
             assert.equal(result.omxEventName, "keyword-detector");
             assert.equal(result.skillState?.skill, "autopilot");
-            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
-            assert.match(message, /Autopilot protocol:/);
-            assert.match(message, /deep-interview -> ralplan -> ultragoal -> code-review -> ultraqa/);
-            assert.match(message, /Planner output has been reviewed sequentially by Architect and then Critic/);
-            assert.match(message, /do not hand off to Ultragoal or implementation until .*ralplan_architect_review.*ralplan_critic_review/);
+            assert.equal(existsSync(join(stateDir, "sessions", canonicalSessionId, "autopilot-state.json")), true);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("records ultragoal prompt skill activation with goal-tool handoff guidance", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-"));
+    it("lets the current canonical leader boundary beat stale global subagent tracking with a distinct prompt thread id", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-current-leader-stale-global-"));
         try {
-            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
-            const result = await dispatchCodexNativeHook({
-                hook_event_name: "UserPromptSubmit",
-                cwd,
-                session_id: "sess-ultragoal-1",
-                thread_id: "thread-ultragoal-1",
-                turn_id: "turn-ultragoal-1",
-                prompt: "$ultragoal split this launch into durable goals",
-            }, { cwd });
-            assert.equal(result.omxEventName, "keyword-detector");
-            assert.equal(result.skillState?.skill, "ultragoal");
-            assert.equal(result.skillState?.initialized_mode, "ultragoal");
-            assert.equal(result.skillState?.initialized_state_path, ".omx/state/sessions/sess-ultragoal-1/ultragoal-state.json");
-            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
-            assert.match(message, /"\$ultragoal" -> ultragoal/);
-            assert.match(message, /Ultragoal protocol:/);
-            assert.match(message, /get_goal/);
-            assert.match(message, /create_goal/);
-            assert.match(message, /update_goal/);
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "sess-current-leader";
+            const leaderNativeSessionId = "native-current-leader";
+            const staleSessionId = "sess-stale-subagent";
+            const staleLeaderNativeSessionId = "native-stale-leader";
+            const nowIso = new Date().toISOString();
+            await writeJson(join(stateDir, "session.json"), {
+                session_id: canonicalSessionId,
+                native_session_id: leaderNativeSessionId,
+            });
+            await writeJson(join(stateDir, "subagent-tracking.json"), {
+                schemaVersion: 1,
+                sessions: {
+                    [canonicalSessionId]: {
+                        session_id: canonicalSessionId,
+                        leader_thread_id: leaderNativeSessionId,
+                        updated_at: nowIso,
+                        threads: {
+                            [leaderNativeSessionId]: {
+                                thread_id: leaderNativeSessionId,
+                                kind: "leader",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                            },
+                        },
+                    },
+                    [staleSessionId]: {
+                        session_id: staleSessionId,
+                        leader_thread_id: staleLeaderNativeSessionId,
+                        updated_at: nowIso,
+                        threads: {
+                            [staleLeaderNativeSessionId]: {
+                                thread_id: staleLeaderNativeSessionId,
+                                kind: "leader",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                            },
+                            [leaderNativeSessionId]: {
+                                thread_id: leaderNativeSessionId,
+                                kind: "subagent",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                                mode: "architect",
+                            },
+                        },
+                    },
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: leaderNativeSessionId,
+                thread_id: "thread-current-turn-not-native-session",
+                turn_id: "turn-current-leader",
+                prompt: "$autopilot continue",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "autopilot");
+            assert.equal(existsSync(join(stateDir, "sessions", canonicalSessionId, "autopilot-state.json")), true);
+            assert.equal(existsSync(join(stateDir, "sessions", staleSessionId, "autopilot-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("lets the current session native leader beat stale global subagent tracking without a canonical summary and with a distinct prompt thread id", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-current-native-leader-stale-global-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "sess-current-native-leader";
+            const leaderNativeSessionId = "native-current-leader-no-summary";
+            const staleSessionId = "sess-stale-native-subagent";
+            const staleLeaderNativeSessionId = "native-stale-parent";
+            const nowIso = new Date().toISOString();
+            await writeJson(join(stateDir, "session.json"), {
+                session_id: canonicalSessionId,
+                native_session_id: leaderNativeSessionId,
+            });
+            await writeJson(join(stateDir, "subagent-tracking.json"), {
+                schemaVersion: 1,
+                sessions: {
+                    [staleSessionId]: {
+                        session_id: staleSessionId,
+                        leader_thread_id: staleLeaderNativeSessionId,
+                        updated_at: nowIso,
+                        threads: {
+                            [staleLeaderNativeSessionId]: {
+                                thread_id: staleLeaderNativeSessionId,
+                                kind: "leader",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                            },
+                            [leaderNativeSessionId]: {
+                                thread_id: leaderNativeSessionId,
+                                kind: "subagent",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                                mode: "critic",
+                            },
+                        },
+                    },
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: leaderNativeSessionId,
+                thread_id: "thread-current-turn-not-native-session",
+                turn_id: "turn-current-native-leader",
+                prompt: "$autopilot continue",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "autopilot");
+            assert.equal(existsSync(join(stateDir, "sessions", canonicalSessionId, "autopilot-state.json")), true);
+            assert.equal(existsSync(join(stateDir, "sessions", staleSessionId, "autopilot-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("lets the current session native leader beat a malformed canonical subagent entry", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-current-native-leader-malformed-canonical-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "sess-current-native-leader-malformed";
+            const leaderNativeSessionId = "native-current-leader-malformed";
+            const nowIso = new Date().toISOString();
+            await writeJson(join(stateDir, "session.json"), {
+                session_id: canonicalSessionId,
+                native_session_id: leaderNativeSessionId,
+            });
+            await writeJson(join(stateDir, "subagent-tracking.json"), {
+                schemaVersion: 1,
+                sessions: {
+                    [canonicalSessionId]: {
+                        session_id: canonicalSessionId,
+                        updated_at: nowIso,
+                        threads: {
+                            [leaderNativeSessionId]: {
+                                thread_id: leaderNativeSessionId,
+                                kind: "subagent",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                                mode: "architect",
+                            },
+                        },
+                    },
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: leaderNativeSessionId,
+                thread_id: leaderNativeSessionId,
+                turn_id: "turn-current-native-leader-malformed",
+                prompt: "$autopilot continue",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "autopilot");
+            assert.equal(existsSync(join(stateDir, "sessions", canonicalSessionId, "autopilot-state.json")), true);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("still treats mixed child and leader payload identities as native subagent scope", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-mixed-child-leader-identity-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "sess-mixed-child-leader";
+            const leaderNativeSessionId = "native-mixed-leader";
+            const childNativeSessionId = "native-mixed-child";
+            const nowIso = new Date().toISOString();
+            await writeJson(join(stateDir, "session.json"), {
+                session_id: canonicalSessionId,
+                native_session_id: leaderNativeSessionId,
+            });
+            await writeJson(join(stateDir, "subagent-tracking.json"), {
+                schemaVersion: 1,
+                sessions: {
+                    [canonicalSessionId]: {
+                        session_id: canonicalSessionId,
+                        leader_thread_id: leaderNativeSessionId,
+                        updated_at: nowIso,
+                        threads: {
+                            [leaderNativeSessionId]: {
+                                thread_id: leaderNativeSessionId,
+                                kind: "leader",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                            },
+                            [childNativeSessionId]: {
+                                thread_id: childNativeSessionId,
+                                kind: "subagent",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                                mode: "critic",
+                            },
+                        },
+                    },
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: childNativeSessionId,
+                thread_id: leaderNativeSessionId,
+                turn_id: "turn-mixed-child-leader",
+                prompt: "$ralplan review this as delegated text",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState, null);
+            assert.equal(result.outputJson, null);
+            assert.equal(existsSync(join(stateDir, "sessions", canonicalSessionId, "ralplan-state.json")), false);
+            assert.equal(existsSync(join(stateDir, "sessions", childNativeSessionId, "ralplan-state.json")), false);
+            const reversedResult = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: leaderNativeSessionId,
+                thread_id: childNativeSessionId,
+                turn_id: "turn-mixed-leader-child",
+                prompt: "$autopilot review this as delegated text",
+            }, { cwd });
+            assert.equal(reversedResult.omxEventName, "keyword-detector");
+            assert.equal(reversedResult.skillState, null);
+            assert.equal(reversedResult.outputJson, null);
+            assert.equal(existsSync(join(stateDir, "sessions", canonicalSessionId, "autopilot-state.json")), false);
+            assert.equal(existsSync(join(stateDir, "sessions", childNativeSessionId, "autopilot-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("records plugin-prefixed keyword activation from UserPromptSubmit payloads", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-plugin-prefixed-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-plugin-1",
+                thread_id: "thread-plugin-1",
+                turn_id: "turn-plugin-1",
+                prompt: "$oh-my-codex:ralplan implement issue #1307",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "ralplan");
+            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
+            assert.match(message, /\$oh-my-codex:ralplan" -> ralplan/);
+            assert.match(message, /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-plugin-1", "ralplan-state.json")), true);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("injects autopilot ralplan consensus gate guidance on prompt activation", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-gate-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-autopilot-ralplan-gate",
+                thread_id: "thread-autopilot-ralplan-gate",
+                turn_id: "turn-autopilot-ralplan-gate",
+                prompt: "$autopilot implement issue #2430",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "autopilot");
+            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
+            assert.match(message, /Autopilot protocol:/);
+            assert.match(message, /deep-interview -> ralplan -> ultragoal -> code-review -> ultraqa/);
+            assert.match(message, /structured question chain, not a one-question gate/);
+            assert.match(message, /re-score ambiguity against the active threshold/);
+            assert.match(message, /max_rounds as a cap/);
+            assert.match(message, /Do not advance from deep-interview to ralplan merely because the first question was answered/);
+            assert.match(message, /Planner output has been reviewed sequentially by Architect and then Critic/);
+            assert.match(message, /do not hand off to Ultragoal or implementation until .*ralplan_architect_review.*ralplan_critic_review/);
+            const autopilotState = JSON.parse(await readFile(join(cwd, ".omx", "state", "sessions", "sess-autopilot-ralplan-gate", "autopilot-state.json"), "utf-8"));
+            const snapshotPath = autopilotState.state?.handoff_artifacts?.context_snapshot_path ?? "";
+            assert.match(snapshotPath, /^\.omx\/context\/implement-issue-2430-\d{8}T\d{6}Z\.md$/);
+            const snapshot = await readFile(join(cwd, snapshotPath), "utf-8");
+            assert.match(snapshot, /activation prompt \/ task seed: \$autopilot implement issue #2430/);
+            assert.match(snapshot, /scope note: this seed captures the Autopilot activation prompt/);
+            assert.match(snapshot, /constraints: follow deep-interview -> ralplan -> ultragoal -> code-review -> ultraqa/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("records ultragoal prompt skill activation with goal-tool handoff guidance", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-ultragoal-1",
+                thread_id: "thread-ultragoal-1",
+                turn_id: "turn-ultragoal-1",
+                prompt: "$ultragoal split this launch into durable goals",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "ultragoal");
+            assert.equal(result.skillState?.initialized_mode, "ultragoal");
+            assert.equal(result.skillState?.initialized_state_path, ".omx/state/sessions/sess-ultragoal-1/ultragoal-state.json");
+            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
+            assert.match(message, /"\$ultragoal" -> ultragoal/);
+            assert.match(message, /Ultragoal protocol:/);
+            assert.match(message, /get_goal/);
+            assert.match(message, /create_goal/);
+            assert.match(message, /update_goal/);
             assert.match(message, /does not call `\/goal clear`/);
             assert.match(message, /multiple sequential ultragoal runs/);
             assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-ultragoal-1", "ultragoal-state.json")), true);
@@ -2705,6 +3340,11 @@ ${JSON.stringify({
             assert.equal(result.skillState?.skill, "autopilot");
             const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
             assert.match(message, /"keep going" -> ralph/);
+            assert.match(message, /Autopilot protocol:/);
+            assert.match(message, /structured question chain, not a one-question gate/);
+            assert.match(message, /re-score ambiguity against the active threshold/);
+            assert.match(message, /max_rounds as a cap/);
+            assert.match(message, /Do not advance from deep-interview to ralplan merely because the first question was answered/);
             assert.doesNotMatch(message, /denied workflow keyword/i);
             assert.doesNotMatch(message, /Unsupported workflow overlap: autopilot \+ ralph\./);
             assert.doesNotMatch(message, /Prompt-side `\$ralph` activation/);
@@ -2714,6 +3354,107 @@ ${JSON.stringify({
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("keeps omx question answers on the active autopilot skill so the interview chain guidance is injected", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-question-answer-continuation-"));
+        try {
+            const sessionId = "sess-autopilot-question-answer";
+            const sessionDir = join(cwd, ".omx", "state", "sessions", sessionId);
+            await mkdir(sessionDir, { recursive: true });
+            await writeJson(join(sessionDir, "skill-active-state.json"), {
+                version: 1,
+                active: true,
+                skill: "autopilot",
+                keyword: "$autopilot",
+                phase: "deep-interview",
+                initialized_mode: "autopilot",
+                initialized_state_path: `.omx/state/sessions/${sessionId}/autopilot-state.json`,
+                session_id: sessionId,
+                active_skills: [
+                    { skill: "autopilot", phase: "deep-interview", active: true, session_id: sessionId },
+                ],
+            });
+            await writeJson(join(sessionDir, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "deep-interview",
+                started_at: "2026-04-19T00:00:00.000Z",
+                updated_at: "2026-04-19T00:10:00.000Z",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-autopilot-question-answer",
+                turn_id: "turn-autopilot-question-answer",
+                prompt: "[omx question answered] semantic_marker_expansion $ralplan",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "autopilot");
+            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
+            assert.match(message, /continued active workflow skill "autopilot"/);
+            assert.match(message, /Autopilot protocol:/);
+            assert.match(message, /structured question chain, not a one-question gate/);
+            assert.match(message, /This turn is a marked omx question answer/);
+            assert.match(message, /then re-score/);
+            assert.match(message, /write interview_complete evidence and hand off/);
+            assert.match(message, /readiness gate remains unresolved and the answer would materially change execution/);
+            assert.match(message, /Do not advance from deep-interview to ralplan merely because the first question was answered/);
+            assert.doesNotMatch(message, /denied workflow keyword/i);
+            assert.equal(existsSync(join(sessionDir, "ralplan-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("keeps deep-interview bridge guidance on marked question answers with workflow-like tokens", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-question-answer-continuation-"));
+        try {
+            const sessionId = "sess-deep-interview-question-answer";
+            const sessionDir = join(cwd, ".omx", "state", "sessions", sessionId);
+            await mkdir(sessionDir, { recursive: true });
+            await writeJson(join(sessionDir, "skill-active-state.json"), {
+                version: 1,
+                active: true,
+                skill: "deep-interview",
+                keyword: "$deep-interview",
+                phase: "planning",
+                initialized_mode: "deep-interview",
+                initialized_state_path: `.omx/state/sessions/${sessionId}/deep-interview-state.json`,
+                session_id: sessionId,
+                active_skills: [
+                    { skill: "deep-interview", phase: "planning", active: true, session_id: sessionId },
+                ],
+            });
+            await writeJson(join(sessionDir, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "intent-first",
+                started_at: "2026-04-21T10:00:00.000Z",
+                updated_at: "2026-04-21T10:00:00.000Z",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-deep-interview-question-answer",
+                turn_id: "turn-deep-interview-question-answer",
+                prompt: "[omx question answered] answer text $ralplan",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "deep-interview");
+            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
+            assert.match(message, /continued active workflow skill "deep-interview"/);
+            assert.match(message, /workflow-like tokens inside the marked omx question answer are treated as answer text/);
+            assert.match(message, /Deep-interview is active, but this session is not attached to tmux/);
+            assert.match(message, /native structured question tool when available/);
+            assert.doesNotMatch(message, /detected workflow keyword "\$ralplan" -> ralplan/);
+            assert.equal(existsSync(join(sessionDir, "ralplan-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("clarifies outside-tmux prompt-side deep-interview activation without pretending omx question is directly available", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-routing-"));
         try {
@@ -3140,6 +3881,10 @@ export async function onHookEvent(event) {
                 active: true,
                 mode: "deep-interview",
                 current_phase: "intent-first",
+                deep_interview_gate: {
+                    status: "complete",
+                    rationale: "Requirements are clarified and ready for ralplan consensus.",
+                },
             });
             await writeJson(join(sessionDir, "skill-active-state.json"), {
                 active: true,
@@ -3459,7 +4204,54 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("reuses an existing owner-tagged HUD pane when UserPromptSubmit revives with the canonical session id", async () => {
+    it("skips prompt-submit HUD reconciliation during doctor smoke validation", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-doctor-smoke-hud-"));
+        const originalTmux = process.env.TMUX;
+        const originalTmuxPane = process.env.TMUX_PANE;
+        const originalHudOwner = process.env[OMX_TMUX_HUD_OWNER_ENV];
+        const originalDoctorSmoke = process.env.OMX_NATIVE_HOOK_DOCTOR_SMOKE;
+        try {
+            process.env.TMUX = "1";
+            process.env.TMUX_PANE = "%1";
+            process.env[OMX_TMUX_HUD_OWNER_ENV] = "1";
+            process.env.OMX_NATIVE_HOOK_DOCTOR_SMOKE = "1";
+            let reconcileCalled = false;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "omx-doctor-plugin-hook-smoke",
+                prompt: "$ralplan doctor plugin hook smoke test",
+            }, {
+                cwd,
+                reconcileHudForPromptSubmitFn: async () => {
+                    reconcileCalled = true;
+                    return { status: "recreated", paneId: "%9", desiredHeight: 3, duplicateCount: 0 };
+                },
+            });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(reconcileCalled, false);
+        }
+        finally {
+            if (originalTmux === undefined)
+                delete process.env.TMUX;
+            else
+                process.env.TMUX = originalTmux;
+            if (originalTmuxPane === undefined)
+                delete process.env.TMUX_PANE;
+            else
+                process.env.TMUX_PANE = originalTmuxPane;
+            if (originalHudOwner === undefined)
+                delete process.env[OMX_TMUX_HUD_OWNER_ENV];
+            else
+                process.env[OMX_TMUX_HUD_OWNER_ENV] = originalHudOwner;
+            if (originalDoctorSmoke === undefined)
+                delete process.env.OMX_NATIVE_HOOK_DOCTOR_SMOKE;
+            else
+                process.env.OMX_NATIVE_HOOK_DOCTOR_SMOKE = originalDoctorSmoke;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("recreates a leader-only HUD pane when UserPromptSubmit revives with the canonical session id", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-reuse-"));
         const originalTmux = process.env.TMUX;
         const originalTmuxPane = process.env.TMUX_PANE;
@@ -3506,8 +4298,8 @@ esac
             assert.equal(result.omxEventName, "keyword-detector");
             const tmuxCalls = await readFile(tmuxLog, "utf-8");
             assert.match(tmuxCalls, /list-panes -t %1 -F/);
-            assert.match(tmuxCalls, new RegExp(`resize-pane -t %2 -y ${HUD_TMUX_HEIGHT_LINES}`));
-            assert.doesNotMatch(tmuxCalls, /split-window/);
+            assert.match(tmuxCalls, /split-window/);
+            assert.match(tmuxCalls, new RegExp(`resize-pane -t %9 -y ${HUD_TMUX_HEIGHT_LINES}`));
             assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", canonicalSessionId, "ralplan-state.json")), true);
             assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", nativeSessionId, "ralplan-state.json")), false);
         }
@@ -5758,6 +6550,42 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not block ordinary non-zero grep output in PostToolUse", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-grep-nonzero-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-grep-nonzero",
+                tool_input: { command: "grep -R missing-pattern src | head -20" },
+                tool_response: "{\"exit_code\":1,\"stdout\":\"src/example.ts:TODO\",\"stderr\":\"\"}",
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block ordinary non-zero diagnostic output in PostToolUse", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-diagnostic-nonzero-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-diagnostic-nonzero",
+                tool_input: { command: "find src -name nope -print" },
+                tool_response: "{\"exit_code\":1,\"stdout\":\"searched 10 files\",\"stderr\":\"\"}",
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("treats stderr-only informative non-zero output as reviewable instead of a generic failure", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-informative-stderr-"));
         try {
@@ -5808,6 +6636,72 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("treats wrapped gh pr checks output as reviewable", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-gh-wrapped-"));
+        try {
+            for (const command of [
+                "GH_PAGER=cat gh pr checks",
+                "env GH_TOKEN=ghp_testtoken gh pr checks",
+                "/usr/bin/env gh pr checks",
+                "env -- gh pr checks",
+                "env -C repo gh pr checks",
+                "/usr/bin/gh pr checks",
+                "gh --repo owner/repo pr checks",
+                "echo a; gh pr checks",
+                "cd repo && gh pr checks",
+            ]) {
+                const result = await dispatchCodexNativeHook({
+                    hook_event_name: "PostToolUse",
+                    cwd,
+                    tool_name: "Bash",
+                    tool_use_id: `tool-useful-${command}`,
+                    tool_input: { command },
+                    tool_response: "{\"exit_code\":8,\"stdout\":\"build pending\",\"stderr\":\"\"}",
+                }, { cwd });
+                assert.equal(result.omxEventName, "post-tool-use");
+                assert.equal(result.outputJson?.decision, "block", command);
+            }
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not treat heredoc gh pr checks text as a reviewable command", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-gh-heredoc-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-heredoc-gh-checks",
+                tool_input: { command: "cat <<'EOF'\ngh pr checks\nEOF\nfalse" },
+                tool_response: "{\"exit_code\":1,\"stdout\":\"gh pr checks\",\"stderr\":\"\"}",
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not treat echoed gh pr checks text as a reviewable command", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-gh-echo-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-echo-gh-checks",
+                tool_input: { command: "echo gh pr checks" },
+                tool_response: "{\"exit_code\":1,\"stdout\":\"gh pr checks\",\"stderr\":\"\"}",
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("returns MCP transport-death guidance and preserves failed team state", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-mcp-dead-"));
         try {
@@ -6649,63 +7543,49 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("allows worker Stop when the Stop nudge helper cannot deliver", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-helper-fail-"));
-        const prevTeamWorker = process.env.OMX_TEAM_WORKER;
-        const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+    it("dedupes allowed worker Stop leader nudges across workers in the same team window", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-team-dedupe-"));
         const prevPath = process.env.PATH;
         try {
-            await initTeamState("worker-stop-helper-fail", "worker stop helper failure", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-worker-helper-fail" });
+            const stateDir = join(cwd, ".omx", "state");
+            const logsDir = join(cwd, ".omx", "logs");
+            const teamName = "worker-stop-team-dedupe";
+            const teamDir = join(stateDir, "team", teamName);
             const fakeBinDir = join(cwd, "fake-bin");
+            const tmuxLogPath = join(cwd, "tmux.log");
             await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(join(cwd, "tmux.log"), { failSend: true }));
+            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(tmuxLogPath));
             await chmod(join(fakeBinDir, "tmux"), 0o755);
-            const stateDir = join(cwd, ".omx", "state");
-            const workerDir = join(stateDir, "team", "worker-stop-helper-fail", "workers", "worker-1");
-            await writeJson(join(stateDir, "team", "worker-stop-helper-fail", "config.json"), {
-                name: "worker-stop-helper-fail",
-                tmux_session: "omx-team-worker-stop",
-                leader_pane_id: "%42",
-                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
-            });
-            await writeJson(join(stateDir, "team", "worker-stop-helper-fail", "manifest.v2.json"), {
-                name: "worker-stop-helper-fail",
+            await writeJson(join(teamDir, "manifest.v2.json"), {
+                name: teamName,
                 tmux_session: "omx-team-worker-stop",
                 leader_pane_id: "%42",
-                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
-            });
-            await writeJson(join(workerDir, "identity.json"), {
-                name: "worker-1",
-                assigned_tasks: ["1"],
-                team_state_root: stateDir,
-            });
-            await writeJson(join(workerDir, "status.json"), {
-                state: "done",
-                current_task_id: "1",
-                updated_at: new Date().toISOString(),
-            });
-            await writeJson(join(stateDir, "team", "worker-stop-helper-fail", "tasks", "task-1.json"), {
-                id: "1",
-                status: "completed",
-                owner: "worker-1",
+                workers: [
+                    { name: "worker-1", index: 1, pane_id: "%10" },
+                    { name: "worker-2", index: 2, pane_id: "%11" },
+                ],
             });
-            process.env.OMX_TEAM_WORKER = "worker-stop-helper-fail/worker-1";
-            process.env.OMX_TEAM_STATE_ROOT = stateDir;
             process.env.PATH = `${fakeBinDir}:${prevPath || ""}`;
-            const result = await dispatchCodexNativeHook({ hook_event_name: "Stop", cwd, session_id: "sess-stop-team-worker-helper-fail" }, { cwd });
-            assert.equal(result.outputJson, null);
-            const nudgeState = JSON.parse(await readFile(join(workerDir, "worker-stop-nudge.json"), "utf-8"));
-            assert.equal(nudgeState.delivery, "deferred");
+            const first = await maybeNudgeLeaderForAllowedWorkerStop({
+                stateDir,
+                logsDir,
+                workerContext: { teamName, workerName: "worker-1" },
+            });
+            const second = await maybeNudgeLeaderForAllowedWorkerStop({
+                stateDir,
+                logsDir,
+                workerContext: { teamName, workerName: "worker-2" },
+            });
+            assert.equal(first.result, "sent");
+            assert.equal(second.result, "suppressed_team_cooldown");
+            const tmuxLog = await readFile(tmuxLogPath, "utf-8");
+            const stopNudges = tmuxLog.match(/send-keys -t %42 -l \[OMX\] worker-\d+ native Stop allowed/g) || [];
+            assert.equal(stopNudges.length, 1, "same-team workers should share one leader nudge cooldown window");
+            const teamNudgeState = JSON.parse(await readFile(join(teamDir, "worker-stop-nudge.json"), "utf-8"));
+            assert.equal(teamNudgeState.worker, "worker-1");
+            assert.equal(teamNudgeState.delivery, "sent");
         }
         finally {
-            if (typeof prevTeamWorker === "string")
-                process.env.OMX_TEAM_WORKER = prevTeamWorker;
-            else
-                delete process.env.OMX_TEAM_WORKER;
-            if (typeof prevTeamStateRoot === "string")
-                process.env.OMX_TEAM_STATE_ROOT = prevTeamStateRoot;
-            else
-                delete process.env.OMX_TEAM_STATE_ROOT;
             if (typeof prevPath === "string")
                 process.env.PATH = prevPath;
             else
@@ -6713,45 +7593,360 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("does not treat failed or ambiguous worker task state as completed Stop evidence", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-failed-"));
-        const prevTeamWorker = process.env.OMX_TEAM_WORKER;
-        const prevInternalTeamWorker = process.env.OMX_TEAM_INTERNAL_WORKER;
-        const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+    it("serializes concurrent allowed worker Stop leader nudges with a team lock", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-concurrent-dedupe-"));
         const prevPath = process.env.PATH;
         try {
-            await initTeamState("worker-stop-failed-task", "worker stop failed task", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-worker-failed" });
+            const stateDir = join(cwd, ".omx", "state");
+            const logsDir = join(cwd, ".omx", "logs");
+            const teamName = "worker-stop-concurrent";
+            const teamDir = join(stateDir, "team", teamName);
             const fakeBinDir = join(cwd, "fake-bin");
             const tmuxLogPath = join(cwd, "tmux.log");
             await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(tmuxLogPath));
+            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(tmuxLogPath, { sendDelayMs: 100 }));
             await chmod(join(fakeBinDir, "tmux"), 0o755);
-            const stateDir = join(cwd, ".omx", "state");
-            const workerDir = join(stateDir, "team", "worker-stop-failed-task", "workers", "worker-1");
-            await writeJson(join(stateDir, "team", "worker-stop-failed-task", "config.json"), {
-                name: "worker-stop-failed-task",
+            await writeJson(join(teamDir, "manifest.v2.json"), {
+                name: teamName,
                 tmux_session: "omx-team-worker-stop",
                 leader_pane_id: "%42",
-                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
-            });
-            await writeJson(join(workerDir, "identity.json"), {
-                name: "worker-1",
-                assigned_tasks: ["1"],
-                team_state_root: stateDir,
-            });
-            await writeJson(join(workerDir, "status.json"), {
-                state: "failed",
-                current_task_id: "1",
-                updated_at: new Date().toISOString(),
-            });
-            await writeJson(join(stateDir, "team", "worker-stop-failed-task", "tasks", "task-1.json"), {
-                id: "1",
-                status: "failed",
-                owner: "worker-1",
+                workers: [
+                    { name: "worker-1", index: 1, pane_id: "%10" },
+                    { name: "worker-2", index: 2, pane_id: "%11" },
+                ],
             });
-            process.env.OMX_TEAM_WORKER = "worker-stop-failed-task/worker-1";
-            delete process.env.OMX_TEAM_INTERNAL_WORKER;
-            process.env.OMX_TEAM_STATE_ROOT = stateDir;
+            process.env.PATH = `${fakeBinDir}:${prevPath || ""}`;
+            const results = await Promise.all([
+                maybeNudgeLeaderForAllowedWorkerStop({
+                    stateDir,
+                    logsDir,
+                    workerContext: { teamName, workerName: "worker-1" },
+                }),
+                maybeNudgeLeaderForAllowedWorkerStop({
+                    stateDir,
+                    logsDir,
+                    workerContext: { teamName, workerName: "worker-2" },
+                }),
+            ]);
+            assert.equal(results.filter((result) => result.result === "sent").length, 1);
+            assert.equal(results.filter((result) => result.result === "suppressed_team_lock_held").length, 1);
+            const tmuxLog = await readFile(tmuxLogPath, "utf-8");
+            const stopNudges = tmuxLog.match(/send-keys -t %42 -l \[OMX\] worker-\d+ native Stop allowed/g) || [];
+            assert.equal(stopNudges.length, 1, "concurrent same-team workers should emit only one leader nudge");
+            assert.equal(existsSync(join(teamDir, "worker-stop-nudge.lock")), false);
+        }
+        finally {
+            if (typeof prevPath === "string")
+                process.env.PATH = prevPath;
+            else
+                delete process.env.PATH;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("skips worker Stop leader nudge when team state is missing or shut down", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-missing-team-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const logsDir = join(cwd, ".omx", "logs");
+            const result = await maybeNudgeLeaderForAllowedWorkerStop({
+                stateDir,
+                logsDir,
+                workerContext: { teamName: "removed-team", workerName: "worker-1" },
+            });
+            assert.equal(result.result, "team_state_gone_or_shutdown");
+            assert.equal(existsSync(join(stateDir, "team", "removed-team", "worker-stop-nudge.json")), false);
+            await writeJson(join(stateDir, "team", "shutdown-team", "shutdown.json"), {
+                started_at: new Date().toISOString(),
+            });
+            const shutdownResult = await maybeNudgeLeaderForAllowedWorkerStop({
+                stateDir,
+                logsDir,
+                workerContext: { teamName: "shutdown-team", workerName: "worker-1" },
+            });
+            assert.equal(shutdownResult.result, "team_state_gone_or_shutdown");
+            assert.equal(existsSync(join(stateDir, "team", "shutdown-team", "worker-stop-nudge.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not treat old visible worker Stop transcript as pending queue state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-queue-dedupe-"));
+        const prevPath = process.env.PATH;
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const logsDir = join(cwd, ".omx", "logs");
+            const teamName = "queued-stop-dedupe";
+            const teamDir = join(stateDir, "team", teamName);
+            const fakeBinDir = join(cwd, "fake-bin");
+            const tmuxLogPath = join(cwd, "tmux.log");
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(tmuxLogPath, {
+                busyLeader: true,
+                captureText: `[OMX] worker-1 native Stop allowed. Run \`omx team status ${teamName}\`, read worker messages/results, then assign next task, reconcile completion, or shut down. [OMX_TMUX_INJECT]\n`
+                    + "• Working… (esc to interrupt)",
+            }));
+            await chmod(join(fakeBinDir, "tmux"), 0o755);
+            await writeJson(join(teamDir, "manifest.v2.json"), {
+                name: teamName,
+                tmux_session: "omx-team-worker-stop",
+                leader_pane_id: "%42",
+                workers: [{ name: "worker-2", index: 2, pane_id: "%11" }],
+            });
+            process.env.PATH = `${fakeBinDir}:${prevPath || ""}`;
+            const result = await maybeNudgeLeaderForAllowedWorkerStop({
+                stateDir,
+                logsDir,
+                workerContext: { teamName, workerName: "worker-2" },
+            });
+            assert.equal(result.result, "queued");
+            const tmuxLog = await readFile(tmuxLogPath, "utf-8");
+            assert.match(tmuxLog, /send-keys -t %42 -l \[OMX\] worker-2 native Stop allowed/);
+            assert.match(tmuxLog, /send-keys -t %42 Tab/);
+            const teamNudgeState = JSON.parse(await readFile(join(teamDir, "worker-stop-nudge.json"), "utf-8"));
+            assert.equal(teamNudgeState.worker, "worker-2");
+            assert.equal(teamNudgeState.delivery, "queued");
+        }
+        finally {
+            if (typeof prevPath === "string")
+                process.env.PATH = prevPath;
+            else
+                delete process.env.PATH;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("reports deferred when non-teardown persistence failure prevents worker Stop nudge cooldown state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-persist-fail-"));
+        const prevPath = process.env.PATH;
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const logsDir = join(cwd, ".omx", "logs");
+            const teamName = "worker-stop-persist-fail";
+            const teamDir = join(stateDir, "team", teamName);
+            const fakeBinDir = join(cwd, "fake-bin");
+            const tmuxLogPath = join(cwd, "tmux.log");
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(teamDir, "manifest.v2.json"), {
+                name: teamName,
+                tmux_session: "omx-team-worker-stop",
+                leader_pane_id: "%42",
+                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
+            });
+            await writeFile(join(teamDir, "workers"), "not a directory");
+            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, "tmux"), 0o755);
+            process.env.PATH = `${fakeBinDir}:${prevPath || ""}`;
+            const result = await maybeNudgeLeaderForAllowedWorkerStop({
+                stateDir,
+                logsDir,
+                workerContext: { teamName, workerName: "worker-1" },
+            });
+            assert.equal(result.result, "deferred");
+            assert.equal(existsSync(join(teamDir, "worker-stop-nudge.json")), false);
+            assert.equal(existsSync(join(teamDir, "workers", "worker-1", "worker-stop-nudge.json")), false);
+            const tmuxLog = await readFile(tmuxLogPath, "utf-8");
+            assert.match(tmuxLog, /send-keys -t %42 -l \[OMX\] worker-1 native Stop allowed/);
+            const deliveryLogPath = join(logsDir, `team-delivery-${new Date().toISOString().split("T")[0]}.jsonl`);
+            const deliveryEvents = (await readFile(deliveryLogPath, "utf-8"))
+                .trim()
+                .split("\n")
+                .map((line) => JSON.parse(line));
+            const deferredEvent = deliveryEvents.find((event) => event.event === "nudge_triggered" && event.result === "deferred");
+            assert.equal(deferredEvent?.team, teamName);
+            assert.equal(deferredEvent?.from_worker, "worker-1");
+            assert.match(String(deferredEvent?.reason || ""), /EEXIST|ENOTDIR|not a directory|file already exists/);
+        }
+        finally {
+            if (typeof prevPath === "string")
+                process.env.PATH = prevPath;
+            else
+                delete process.env.PATH;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not recreate team state when teardown removes it during worker Stop delivery", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-teardown-race-"));
+        const prevPath = process.env.PATH;
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const logsDir = join(cwd, ".omx", "logs");
+            const teamName = "worker-stop-teardown-race";
+            const teamDir = join(stateDir, "team", teamName);
+            const fakeBinDir = join(cwd, "fake-bin");
+            const tmuxLogPath = join(cwd, "tmux.log");
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(teamDir, "manifest.v2.json"), {
+                name: teamName,
+                tmux_session: "omx-team-worker-stop",
+                leader_pane_id: "%42",
+                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
+            });
+            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(tmuxLogPath, { removePathOnSend: teamDir }));
+            await chmod(join(fakeBinDir, "tmux"), 0o755);
+            process.env.PATH = `${fakeBinDir}:${prevPath || ""}`;
+            const result = await maybeNudgeLeaderForAllowedWorkerStop({
+                stateDir,
+                logsDir,
+                workerContext: { teamName, workerName: "worker-1" },
+            });
+            assert.equal(result.result, "sent");
+            assert.equal(existsSync(teamDir), false, "worker Stop delivery must not recreate removed team state");
+            const tmuxLog = await readFile(tmuxLogPath, "utf-8");
+            assert.match(tmuxLog, /send-keys -t %42 -l \[OMX\] worker-1 native Stop allowed/);
+        }
+        finally {
+            if (typeof prevPath === "string")
+                process.env.PATH = prevPath;
+            else
+                delete process.env.PATH;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not recreate team state when teardown removes it before deferred worker Stop recording", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-deferred-teardown-"));
+        const prevPath = process.env.PATH;
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const logsDir = join(cwd, ".omx", "logs");
+            const teamName = "worker-stop-deferred-teardown";
+            const teamDir = join(stateDir, "team", teamName);
+            const fakeBinDir = join(cwd, "fake-bin");
+            const tmuxLogPath = join(cwd, "tmux.log");
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(teamDir, "manifest.v2.json"), {
+                name: teamName,
+                tmux_session: "omx-team-worker-stop",
+                leader_pane_id: "%42",
+                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
+            });
+            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(tmuxLogPath, {
+                currentCommand: "bash",
+                captureText: "$ ",
+                removePathOnCapture: teamDir,
+            }));
+            await chmod(join(fakeBinDir, "tmux"), 0o755);
+            process.env.PATH = `${fakeBinDir}:${prevPath || ""}`;
+            const result = await maybeNudgeLeaderForAllowedWorkerStop({
+                stateDir,
+                logsDir,
+                workerContext: { teamName, workerName: "worker-1" },
+            });
+            assert.equal(result.result, "team_state_gone_or_shutdown");
+            assert.equal(existsSync(teamDir), false, "deferred worker Stop recording must not recreate removed team state");
+            const tmuxLog = await readFile(tmuxLogPath, "utf-8");
+            assert.doesNotMatch(tmuxLog, /send-keys -t %42 -l \[OMX\] worker-1 native Stop allowed/);
+        }
+        finally {
+            if (typeof prevPath === "string")
+                process.env.PATH = prevPath;
+            else
+                delete process.env.PATH;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows worker Stop when the Stop nudge helper cannot deliver", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-helper-fail-"));
+        const prevTeamWorker = process.env.OMX_TEAM_WORKER;
+        const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        const prevPath = process.env.PATH;
+        try {
+            await initTeamState("worker-stop-helper-fail", "worker stop helper failure", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-worker-helper-fail" });
+            const fakeBinDir = join(cwd, "fake-bin");
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(join(cwd, "tmux.log"), { failSend: true }));
+            await chmod(join(fakeBinDir, "tmux"), 0o755);
+            const stateDir = join(cwd, ".omx", "state");
+            const workerDir = join(stateDir, "team", "worker-stop-helper-fail", "workers", "worker-1");
+            await writeJson(join(stateDir, "team", "worker-stop-helper-fail", "config.json"), {
+                name: "worker-stop-helper-fail",
+                tmux_session: "omx-team-worker-stop",
+                leader_pane_id: "%42",
+                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
+            });
+            await writeJson(join(stateDir, "team", "worker-stop-helper-fail", "manifest.v2.json"), {
+                name: "worker-stop-helper-fail",
+                tmux_session: "omx-team-worker-stop",
+                leader_pane_id: "%42",
+                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
+            });
+            await writeJson(join(workerDir, "identity.json"), {
+                name: "worker-1",
+                assigned_tasks: ["1"],
+                team_state_root: stateDir,
+            });
+            await writeJson(join(workerDir, "status.json"), {
+                state: "done",
+                current_task_id: "1",
+                updated_at: new Date().toISOString(),
+            });
+            await writeJson(join(stateDir, "team", "worker-stop-helper-fail", "tasks", "task-1.json"), {
+                id: "1",
+                status: "completed",
+                owner: "worker-1",
+            });
+            process.env.OMX_TEAM_WORKER = "worker-stop-helper-fail/worker-1";
+            process.env.OMX_TEAM_STATE_ROOT = stateDir;
+            process.env.PATH = `${fakeBinDir}:${prevPath || ""}`;
+            const result = await dispatchCodexNativeHook({ hook_event_name: "Stop", cwd, session_id: "sess-stop-team-worker-helper-fail" }, { cwd });
+            assert.equal(result.outputJson, null);
+            const nudgeState = JSON.parse(await readFile(join(workerDir, "worker-stop-nudge.json"), "utf-8"));
+            assert.equal(nudgeState.delivery, "deferred");
+        }
+        finally {
+            if (typeof prevTeamWorker === "string")
+                process.env.OMX_TEAM_WORKER = prevTeamWorker;
+            else
+                delete process.env.OMX_TEAM_WORKER;
+            if (typeof prevTeamStateRoot === "string")
+                process.env.OMX_TEAM_STATE_ROOT = prevTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            if (typeof prevPath === "string")
+                process.env.PATH = prevPath;
+            else
+                delete process.env.PATH;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not treat failed or ambiguous worker task state as completed Stop evidence", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-failed-"));
+        const prevTeamWorker = process.env.OMX_TEAM_WORKER;
+        const prevInternalTeamWorker = process.env.OMX_TEAM_INTERNAL_WORKER;
+        const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        const prevPath = process.env.PATH;
+        try {
+            await initTeamState("worker-stop-failed-task", "worker stop failed task", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-worker-failed" });
+            const fakeBinDir = join(cwd, "fake-bin");
+            const tmuxLogPath = join(cwd, "tmux.log");
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeFile(join(fakeBinDir, "tmux"), buildWorkerStopFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, "tmux"), 0o755);
+            const stateDir = join(cwd, ".omx", "state");
+            const workerDir = join(stateDir, "team", "worker-stop-failed-task", "workers", "worker-1");
+            await writeJson(join(stateDir, "team", "worker-stop-failed-task", "config.json"), {
+                name: "worker-stop-failed-task",
+                tmux_session: "omx-team-worker-stop",
+                leader_pane_id: "%42",
+                workers: [{ name: "worker-1", index: 1, pane_id: "%10" }],
+            });
+            await writeJson(join(workerDir, "identity.json"), {
+                name: "worker-1",
+                assigned_tasks: ["1"],
+                team_state_root: stateDir,
+            });
+            await writeJson(join(workerDir, "status.json"), {
+                state: "failed",
+                current_task_id: "1",
+                updated_at: new Date().toISOString(),
+            });
+            await writeJson(join(stateDir, "team", "worker-stop-failed-task", "tasks", "task-1.json"), {
+                id: "1",
+                status: "failed",
+                owner: "worker-1",
+            });
+            process.env.OMX_TEAM_WORKER = "worker-stop-failed-task/worker-1";
+            delete process.env.OMX_TEAM_INTERNAL_WORKER;
+            process.env.OMX_TEAM_STATE_ROOT = stateDir;
             process.env.PATH = `${fakeBinDir}:${prevPath || ""}`;
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
@@ -10150,188 +11345,943 @@ exit 0
                 session_id: "sess-stop-team-refire",
                 thread_id: "thread-stop-team-refire",
             });
-            await writeJson(join(stateDir, "team", "review-team", "phase.json"), {
-                current_phase: "team-verify",
-                max_fix_attempts: 3,
-                current_fix_attempt: 0,
-                transitions: [],
-                updated_at: new Date().toISOString(),
+            await writeJson(join(stateDir, "team", "review-team", "phase.json"), {
+                current_phase: "team-verify",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-team-refire",
+                thread_id: "thread-stop-team-refire",
+                turn_id: "turn-stop-team-refire-1",
+            }, { cwd });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-team-refire",
+                thread_id: "thread-stop-team-refire",
+                turn_id: "turn-stop-team-refire-2",
+                stop_hook_active: true,
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (review-team) at phase team-verify; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                stopReason: "team_team-verify",
+                systemMessage: "OMX team pipeline is still active at phase team-verify.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("suppresses duplicate team Stop replays across native/canonical session-id drift", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-session-drift-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "omx-canonical"), { recursive: true });
+            process.env.OMX_SESSION_ID = "omx-canonical";
+            await writeJson(join(stateDir, "session.json"), {
+                session_id: "omx-canonical",
+                native_session_id: "codex-native",
+            });
+            await writeJson(join(stateDir, "sessions", "omx-canonical", "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "current-team",
+                session_id: "omx-canonical",
+            });
+            await writeJson(join(stateDir, "team", "current-team", "phase.json"), {
+                current_phase: "team-verify",
+                max_fix_attempts: 3,
+                current_fix_attempt: 1,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "codex-native",
+                thread_id: "thread-stop-team-drift",
+                turn_id: "turn-stop-team-drift-1",
+            }, { cwd });
+            const duplicate = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "omx-canonical",
+                thread_id: "thread-stop-team-drift",
+                turn_id: "turn-stop-team-drift-1",
+                stop_hook_active: true,
+            }, { cwd });
+            assert.equal(duplicate.omxEventName, "stop");
+            assert.deepEqual(duplicate.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (current-team) at phase team-verify; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                stopReason: "team_team-verify",
+                systemMessage: "OMX team pipeline is still active at phase team-verify.",
+            });
+            const fresh = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "omx-canonical",
+                thread_id: "thread-stop-team-drift",
+                turn_id: "turn-stop-team-drift-2",
+                stop_hook_active: true,
+            }, { cwd });
+            assert.equal(fresh.omxEventName, "stop");
+            assert.deepEqual(fresh.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (current-team) at phase team-verify; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                stopReason: "team_team-verify",
+                systemMessage: "OMX team pipeline is still active at phase team-verify.",
+            });
+            const persisted = JSON.parse(await readFile(join(stateDir, "native-stop-state.json"), "utf-8"));
+            assert.deepEqual(Object.keys(persisted.sessions ?? {}), ["omx-canonical"]);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("suppresses duplicate ultrawork Stop replays while stop_hook_active stays true", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-ultrawork-repeat-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-stop-ultrawork-repeat"), { recursive: true });
+            await writeJson(join(stateDir, "sessions", "sess-stop-ultrawork-repeat", "ultrawork-state.json"), {
+                active: true,
+                current_phase: "executing",
+            });
+            const first = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-ultrawork-repeat",
+                thread_id: "thread-stop-ultrawork-repeat",
+                turn_id: "turn-stop-ultrawork-repeat-1",
+            }, { cwd });
+            const repeated = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-ultrawork-repeat",
+                thread_id: "thread-stop-ultrawork-repeat",
+                turn_id: "turn-stop-ultrawork-repeat-1",
+                stop_hook_active: true,
+            }, { cwd });
+            const fresh = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-ultrawork-repeat",
+                thread_id: "thread-stop-ultrawork-repeat",
+                turn_id: "turn-stop-ultrawork-repeat-2",
+                stop_hook_active: true,
+            }, { cwd });
+            assert.equal(first.omxEventName, "stop");
+            assert.deepEqual(repeated.outputJson, null);
+            assert.equal(fresh.omxEventName, "stop");
+            assert.deepEqual(fresh.outputJson, {
+                decision: "block",
+                reason: "OMX ultrawork is still active (phase: executing); continue the task and gather fresh verification evidence before stopping.",
+                stopReason: "ultrawork_executing",
+                systemMessage: "OMX ultrawork is still active (phase: executing).",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("re-blocks active ralplan skill state on repeated Stop hooks", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-skill-repeat-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-stop-skill-repeat"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-stop-skill-repeat" });
+            await writeJson(join(stateDir, "sessions", "sess-stop-skill-repeat", "skill-active-state.json"), {
+                active: true,
+                skill: "ralplan",
+                phase: "planning",
+            });
+            await writeJson(join(stateDir, "sessions", "sess-stop-skill-repeat", "ralplan-state.json"), {
+                active: true,
+                current_phase: "planning",
+            });
+            await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-skill-repeat",
+                thread_id: "thread-stop-skill-repeat",
+                turn_id: "turn-stop-skill-repeat-1",
+            }, { cwd });
+            const repeated = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-skill-repeat",
+                thread_id: "thread-stop-skill-repeat",
+                turn_id: "turn-stop-skill-repeat-1",
+                stop_hook_active: true,
+            }, { cwd });
+            assert.equal(repeated.omxEventName, "stop");
+            assert.equal(repeated.outputJson?.decision, "block");
+            assert.match(String(repeated.outputJson?.reason ?? ""), /Status: continue_from_artifact/);
+            assert.match(String(repeated.outputJson?.reason ?? ""), /continue from the current ralplan artifact/i);
+            assert.equal(repeated.outputJson?.stopReason, "skill_ralplan_planning_continue_artifact");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks implementation writes while ralplan is active without execution handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-pretool-block-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-ralplan-pretool-block";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "ralplan",
+                phase: "planning",
+                session_id: sessionId,
+                active_skills: [{ skill: "ralplan", phase: "planning", active: true, session_id: sessionId }],
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "critic-review",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-ralplan-pretool-block",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+            assert.match(String(result.outputJson?.hookSpecificOutput?.additionalContext ?? ""), /\$ultragoal.*\$team.*\$ralph/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks implementation writes while Autopilot is supervising ralplan without handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-pretool-block-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-ralplan-pretool-block";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "autopilot",
+                phase: "ralplan",
+                session_id: sessionId,
+                active_skills: [{ skill: "autopilot", phase: "ralplan", active: true, session_id: sessionId }],
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+                state: {
+                    handoff_artifacts: {
+                        ralplan_consensus_gate: { required: true, complete: false },
+                    },
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-autopilot-ralplan-pretool-block",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block implementation writes from Autopilot ralplan detail state without canonical skill state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-no-canonical-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-ralplan-no-canonical";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-autopilot-ralplan-no-canonical",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows implementation writes when terminal Autopilot run-state shadows stale supervised ralplan state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-terminal-pretool-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-ralplan-terminal-pretool";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "autopilot",
+                phase: "ralplan",
+                session_id: sessionId,
+                active_skills: [{ skill: "autopilot", phase: "ralplan", active: true, session_id: sessionId }],
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "run-state.json"), {
+                version: 1,
+                active: false,
+                mode: "autopilot",
+                outcome: "finish",
+                lifecycle_outcome: "finished",
+                current_phase: "complete",
+                completed_at: "2026-05-30T00:00:00.000Z",
+                updated_at: "2026-05-30T00:00:00.000Z",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-autopilot-ralplan-terminal-pretool",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks bash implementation writes while Autopilot is supervising ralplan without handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-pretool-bash-block-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-ralplan-pretool-bash-block";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "autopilot",
+                phase: "ralplan",
+                session_id: sessionId,
+                active_skills: [{ skill: "autopilot", phase: "ralplan", active: true, session_id: sessionId }],
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-autopilot-ralplan-pretool-bash-block",
+                tool_name: "Bash",
+                tool_input: { command: "cat <<'EOF' > src/runtime.ts\nimplementation\nEOF" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks implementation writes when ralplan and Autopilot ralplan are both active", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-autopilot-mixed-planning-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-ralplan-autopilot-mixed-planning";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "autopilot",
+                phase: "ralplan",
+                session_id: sessionId,
+                active_skills: [
+                    { skill: "ralplan", phase: "planning", active: true, session_id: sessionId },
+                    { skill: "autopilot", phase: "ralplan", active: true, session_id: sessionId },
+                ],
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "planning",
+                session_id: sessionId,
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-ralplan-autopilot-mixed-planning",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks implementation writes while Autopilot is supervising replan without handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-replan-pretool-block-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-replan-pretool-block";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "autopilot",
+                phase: "replan",
+                session_id: sessionId,
+                active_skills: [{ skill: "autopilot", phase: "replan", active: true, session_id: sessionId }],
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "replan",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-autopilot-replan-pretool-block",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks implementation writes when native Codex id maps to OMX Autopilot ralplan state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-native-map-block-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-ralplan-native-map-block";
+            const nativeSessionId = "019e-autopilot-ralplan-native";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "autopilot", "ralplan");
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-autopilot-ralplan-native-map-block",
+                tool_name: "apply_patch",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks bash implementation writes when native Codex id maps to OMX Autopilot ralplan state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-native-map-bash-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-ralplan-native-map-bash";
+            const nativeSessionId = "019e-autopilot-ralplan-native-bash";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "autopilot", "ralplan");
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-autopilot-ralplan-native-map-bash",
+                tool_name: "Bash",
+                tool_input: { command: "cat <<'EOF' > src/runtime.ts\nimplementation\nEOF" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks standalone ralplan writes when native Codex id maps to OMX session state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-native-map-block-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-ralplan-native-map-block";
+            const nativeSessionId = "019e-ralplan-native-map";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "ralplan", "planning");
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "planning",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-ralplan-native-map-block",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks deep-interview writes when native Codex id maps to OMX session state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-native-map-block-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-deep-interview-native-map-block";
+            const nativeSessionId = "019e-deep-interview-native-map";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "deep-interview", "interview");
+            await writeJson(join(stateDir, "sessions", sessionId, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "interview",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-deep-interview-native-map-block",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /Deep-interview is active .*implementation\/write tools are blocked/i);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows mapped ralplan planning artifact writes without execution handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-native-map-artifact-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-ralplan-native-map-artifact";
+            const nativeSessionId = "019e-ralplan-native-map-artifact";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "ralplan", "planning");
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "planning",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-ralplan-native-map-artifact",
+                tool_name: "Bash",
+                tool_input: { command: "cat <<'EOF' > .omx/plans/prd-native-map.md\nplanning\nEOF" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows mapped implementation writes when explicit execution handoff is active", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-native-map-handoff-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-ralplan-native-map-handoff";
+            const nativeSessionId = "019e-ralplan-native-map-handoff";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "ultragoal",
+                phase: "planning",
+                session_id: sessionId,
+                active_skills: [
+                    { skill: "ralplan", phase: "planning", active: true, session_id: sessionId },
+                    { skill: "ultragoal", phase: "planning", active: true, session_id: sessionId },
+                ],
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "complete",
+                session_id: sessionId,
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "ultragoal-state.json"), {
+                active: true,
+                mode: "ultragoal",
+                current_phase: "planning",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-ralplan-native-map-handoff",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows mapped implementation writes when terminal Autopilot run-state shadows stale supervised ralplan state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-native-map-terminal-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-ralplan-native-map-terminal";
+            const nativeSessionId = "019e-autopilot-ralplan-native-terminal";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "autopilot", "ralplan");
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "run-state.json"), {
+                version: 1,
+                active: false,
+                mode: "autopilot",
+                outcome: "finish",
+                lifecycle_outcome: "finished",
+                current_phase: "complete",
+                completed_at: "2026-05-30T00:00:00.000Z",
+                updated_at: "2026-05-30T00:00:00.000Z",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-autopilot-ralplan-native-map-terminal",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block unrelated native Codex ids when current OMX session mapping does not match", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-native-map-unrelated-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-ralplan-native-map-owner";
+            const ownerNativeSessionId = "019e-ralplan-native-owner";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, ownerNativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "ralplan", "planning");
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "planning",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: "019e-unrelated-native-session",
+                thread_id: "thread-ralplan-native-map-unrelated",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks mapped Autopilot ralplan writes from the authoritative team state root", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-team-root-"));
+        const teamStateRoot = await mkdtemp(join(tmpdir(), "omx-native-hook-team-root-"));
+        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        try {
+            process.env.OMX_TEAM_STATE_ROOT = teamStateRoot;
+            const stateDir = teamStateRoot;
+            const sessionId = "sess-autopilot-ralplan-team-root";
+            const nativeSessionId = "019e-autopilot-ralplan-team-root";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "autopilot", "ralplan");
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-autopilot-ralplan-team-root",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "session.json")), false);
+        }
+        finally {
+            if (typeof previousTeamStateRoot === "string")
+                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            await rm(cwd, { recursive: true, force: true });
+            await rm(teamStateRoot, { recursive: true, force: true });
+        }
+    });
+    it("does not block unrelated native Codex ids from the authoritative team state root", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-team-root-unrelated-"));
+        const teamStateRoot = await mkdtemp(join(tmpdir(), "omx-native-hook-team-root-unrelated-"));
+        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        try {
+            process.env.OMX_TEAM_STATE_ROOT = teamStateRoot;
+            const stateDir = teamStateRoot;
+            const sessionId = "sess-ralplan-team-root-owner";
+            const nativeSessionId = "019e-ralplan-team-root-owner";
+            await writeNativeMappedSessionState(cwd, stateDir, sessionId, nativeSessionId);
+            await writeSessionSkillActiveState(stateDir, sessionId, "ralplan", "planning");
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "planning",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: "019e-unrelated-team-root-native",
+                thread_id: "thread-ralplan-team-root-unrelated",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            if (typeof previousTeamStateRoot === "string")
+                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            await rm(cwd, { recursive: true, force: true });
+            await rm(teamStateRoot, { recursive: true, force: true });
+        }
+    });
+    it("allows ralplan planning artifact writes without execution handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-pretool-artifact-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-ralplan-pretool-artifact";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "ralplan",
+                phase: "planning",
+                session_id: sessionId,
+                active_skills: [{ skill: "ralplan", phase: "planning", active: true, session_id: sessionId }],
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "planning",
+                session_id: sessionId,
             });
-            await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
-                cwd,
-                session_id: "sess-stop-team-refire",
-                thread_id: "thread-stop-team-refire",
-                turn_id: "turn-stop-team-refire-1",
-            }, { cwd });
             const result = await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
+                hook_event_name: "PreToolUse",
                 cwd,
-                session_id: "sess-stop-team-refire",
-                thread_id: "thread-stop-team-refire",
-                turn_id: "turn-stop-team-refire-2",
-                stop_hook_active: true,
+                session_id: sessionId,
+                thread_id: "thread-ralplan-pretool-artifact",
+                tool_name: "Write",
+                tool_input: { file_path: ".omx/plans/prd-issue-2603.md" },
             }, { cwd });
-            assert.equal(result.omxEventName, "stop");
-            assert.deepEqual(result.outputJson, {
-                decision: "block",
-                reason: `OMX team pipeline is still active (review-team) at phase team-verify; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
-                stopReason: "team_team-verify",
-                systemMessage: "OMX team pipeline is still active at phase team-verify.",
-            });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("suppresses duplicate team Stop replays across native/canonical session-id drift", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-session-drift-"));
+    it("blocks bash implementation writes while ralplan is active without execution handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-pretool-bash-block-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
-            await mkdir(join(stateDir, "sessions", "omx-canonical"), { recursive: true });
-            process.env.OMX_SESSION_ID = "omx-canonical";
-            await writeJson(join(stateDir, "session.json"), {
-                session_id: "omx-canonical",
-                native_session_id: "codex-native",
-            });
-            await writeJson(join(stateDir, "sessions", "omx-canonical", "team-state.json"), {
+            const sessionId = "sess-ralplan-pretool-bash-block";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
                 active: true,
-                current_phase: "starting",
-                team_name: "current-team",
-                session_id: "omx-canonical",
-            });
-            await writeJson(join(stateDir, "team", "current-team", "phase.json"), {
-                current_phase: "team-verify",
-                max_fix_attempts: 3,
-                current_fix_attempt: 1,
-                transitions: [],
-                updated_at: new Date().toISOString(),
+                skill: "ralplan",
+                phase: "planning",
+                session_id: sessionId,
+                active_skills: [{ skill: "ralplan", phase: "planning", active: true, session_id: sessionId }],
             });
-            await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
-                cwd,
-                session_id: "codex-native",
-                thread_id: "thread-stop-team-drift",
-                turn_id: "turn-stop-team-drift-1",
-            }, { cwd });
-            const duplicate = await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
-                cwd,
-                session_id: "omx-canonical",
-                thread_id: "thread-stop-team-drift",
-                turn_id: "turn-stop-team-drift-1",
-                stop_hook_active: true,
-            }, { cwd });
-            assert.equal(duplicate.omxEventName, "stop");
-            assert.deepEqual(duplicate.outputJson, {
-                decision: "block",
-                reason: `OMX team pipeline is still active (current-team) at phase team-verify; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
-                stopReason: "team_team-verify",
-                systemMessage: "OMX team pipeline is still active at phase team-verify.",
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "planning",
+                session_id: sessionId,
             });
-            const fresh = await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
                 cwd,
-                session_id: "omx-canonical",
-                thread_id: "thread-stop-team-drift",
-                turn_id: "turn-stop-team-drift-2",
-                stop_hook_active: true,
+                session_id: sessionId,
+                thread_id: "thread-ralplan-pretool-bash-block",
+                tool_name: "Bash",
+                tool_input: { command: "cat <<'EOF' > src/runtime.ts\nimplementation\nEOF" },
             }, { cwd });
-            assert.equal(fresh.omxEventName, "stop");
-            assert.deepEqual(fresh.outputJson, {
-                decision: "block",
-                reason: `OMX team pipeline is still active (current-team) at phase team-verify; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
-                stopReason: "team_team-verify",
-                systemMessage: "OMX team pipeline is still active at phase team-verify.",
-            });
-            const persisted = JSON.parse(await readFile(join(stateDir, "native-stop-state.json"), "utf-8"));
-            assert.deepEqual(Object.keys(persisted.sessions ?? {}), ["omx-canonical"]);
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /(?:Ralplan|Autopilot planning) is active .*implementation\/write tools are blocked/i);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("suppresses duplicate ultrawork Stop replays while stop_hook_active stays true", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-ultrawork-repeat-"));
+    it("allows bash planning artifact writes while ralplan is active without execution handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-pretool-bash-artifact-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
-            await mkdir(join(stateDir, "sessions", "sess-stop-ultrawork-repeat"), { recursive: true });
-            await writeJson(join(stateDir, "sessions", "sess-stop-ultrawork-repeat", "ultrawork-state.json"), {
+            const sessionId = "sess-ralplan-pretool-bash-artifact";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
                 active: true,
-                current_phase: "executing",
+                skill: "ralplan",
+                phase: "planning",
+                session_id: sessionId,
+                active_skills: [{ skill: "ralplan", phase: "planning", active: true, session_id: sessionId }],
             });
-            const first = await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
-                cwd,
-                session_id: "sess-stop-ultrawork-repeat",
-                thread_id: "thread-stop-ultrawork-repeat",
-                turn_id: "turn-stop-ultrawork-repeat-1",
-            }, { cwd });
-            const repeated = await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
-                cwd,
-                session_id: "sess-stop-ultrawork-repeat",
-                thread_id: "thread-stop-ultrawork-repeat",
-                turn_id: "turn-stop-ultrawork-repeat-1",
-                stop_hook_active: true,
-            }, { cwd });
-            const fresh = await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+                active: true,
+                mode: "ralplan",
+                current_phase: "planning",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
                 cwd,
-                session_id: "sess-stop-ultrawork-repeat",
-                thread_id: "thread-stop-ultrawork-repeat",
-                turn_id: "turn-stop-ultrawork-repeat-2",
-                stop_hook_active: true,
+                session_id: sessionId,
+                thread_id: "thread-ralplan-pretool-bash-artifact",
+                tool_name: "Bash",
+                tool_input: { command: "cat <<'EOF' > .omx/plans/prd-issue-2603.md\nplanning\nEOF" },
             }, { cwd });
-            assert.equal(first.omxEventName, "stop");
-            assert.deepEqual(repeated.outputJson, null);
-            assert.equal(fresh.omxEventName, "stop");
-            assert.deepEqual(fresh.outputJson, {
-                decision: "block",
-                reason: "OMX ultrawork is still active (phase: executing); continue the task and gather fresh verification evidence before stopping.",
-                stopReason: "ultrawork_executing",
-                systemMessage: "OMX ultrawork is still active (phase: executing).",
-            });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("re-blocks active ralplan skill state on repeated Stop hooks", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-skill-repeat-"));
+    it("allows implementation writes when an explicit execution handoff is active", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-pretool-handoff-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
-            await mkdir(join(stateDir, "sessions", "sess-stop-skill-repeat"), { recursive: true });
-            await writeJson(join(stateDir, "session.json"), { session_id: "sess-stop-skill-repeat" });
-            await writeJson(join(stateDir, "sessions", "sess-stop-skill-repeat", "skill-active-state.json"), {
+            const sessionId = "sess-ralplan-pretool-handoff";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
                 active: true,
-                skill: "ralplan",
+                skill: "ultragoal",
                 phase: "planning",
+                session_id: sessionId,
+                active_skills: [
+                    { skill: "ralplan", phase: "planning", active: true, session_id: sessionId },
+                    { skill: "ultragoal", phase: "planning", active: true, session_id: sessionId },
+                ],
             });
-            await writeJson(join(stateDir, "sessions", "sess-stop-skill-repeat", "ralplan-state.json"), {
+            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
                 active: true,
+                mode: "ralplan",
+                current_phase: "complete",
+                session_id: sessionId,
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "ultragoal-state.json"), {
+                active: true,
+                mode: "ultragoal",
                 current_phase: "planning",
+                session_id: sessionId,
             });
-            await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
-                cwd,
-                session_id: "sess-stop-skill-repeat",
-                thread_id: "thread-stop-skill-repeat",
-                turn_id: "turn-stop-skill-repeat-1",
-            }, { cwd });
-            const repeated = await dispatchCodexNativeHook({
-                hook_event_name: "Stop",
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
                 cwd,
-                session_id: "sess-stop-skill-repeat",
-                thread_id: "thread-stop-skill-repeat",
-                turn_id: "turn-stop-skill-repeat-1",
-                stop_hook_active: true,
+                session_id: sessionId,
+                thread_id: "thread-ralplan-pretool-handoff",
+                tool_name: "Edit",
+                tool_input: { file_path: "src/runtime.ts" },
             }, { cwd });
-            assert.equal(repeated.omxEventName, "stop");
-            assert.equal(repeated.outputJson?.decision, "block");
-            assert.match(String(repeated.outputJson?.reason ?? ""), /Status: continue_from_artifact/);
-            assert.match(String(repeated.outputJson?.reason ?? ""), /continue from the current ralplan artifact/i);
-            assert.equal(repeated.outputJson?.stopReason, "skill_ralplan_planning_continue_artifact");
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -10866,6 +12816,91 @@ describe("codex native hook triage integration", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("omits Team handoff guidance from autopilot prompt context when Team mode is disabled", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-autopilot-observable-no-team-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeJson(join(cwd, ".omx", "setup-scope.json"), {
+                scope: "project",
+                teamMode: "disabled",
+            });
+            await writeSessionStart(cwd, "sess-autopilot-observable-no-team");
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-autopilot-observable-no-team",
+                thread_id: "thread-autopilot-observable-no-team",
+                turn_id: "turn-autopilot-observable-no-team",
+                prompt: "$autopilot implement issue #2430",
+            }, { cwd });
+            assert.equal(result.skillState?.skill, "autopilot");
+            const additionalContext = String(result.outputJson?.hookSpecificOutput?.additionalContext ?? "");
+            assert.match(additionalContext, /detected workflow keyword "\$autopilot" -> autopilot/);
+            assert.match(additionalContext, /\$deep-interview -> \$ralplan -> \$ultragoal -> \$code-review -> \$ultraqa/);
+            assert.doesNotMatch(additionalContext, /\$team/);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "team-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("ignores disabled $team before outside-tmux Team blocking so later workflows can activate", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-disabled-team-primary-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeJson(join(cwd, ".omx", "setup-scope.json"), {
+                scope: "project",
+                teamMode: "disabled",
+            });
+            await writeSessionStart(cwd, "sess-disabled-team-primary");
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-disabled-team-primary",
+                thread_id: "thread-disabled-team-primary",
+                turn_id: "turn-disabled-team-primary",
+                prompt: "$team $ralph fix this",
+            }, { cwd });
+            assert.equal(result.skillState?.skill, "ralph");
+            assert.equal(result.skillState?.transition_error, undefined);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "team-state.json")), false);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-disabled-team-primary", "ralph-state.json")), true);
+            const additionalContext = String(result.outputJson?.hookSpecificOutput?.additionalContext ?? "");
+            assert.match(additionalContext, /detected workflow keyword "\$ralph" -> ralph/);
+            assert.doesNotMatch(additionalContext, /Codex App\/native outside-tmux sessions cannot activate/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("makes bare autopilot command activation observable in state and prompt guidance", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-autopilot-bare-observable-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeSessionStart(cwd, "sess-autopilot-bare-observable");
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-autopilot-bare-observable",
+                thread_id: "thread-autopilot-bare-observable",
+                turn_id: "turn-autopilot-bare-observable",
+                prompt: "run autopilot",
+            }, { cwd });
+            assert.equal(result.skillState?.skill, "autopilot");
+            assert.equal(result.skillState?.phase, "deep-interview");
+            assert.equal(result.skillState?.initialized_state_path, ".omx/state/sessions/sess-autopilot-bare-observable/autopilot-state.json");
+            const additionalContext = String(result.outputJson?.hookSpecificOutput?.additionalContext ?? "");
+            assert.match(additionalContext, /detected workflow keyword "autopilot" -> autopilot/);
+            assert.doesNotMatch(additionalContext, /multi-step goal with no workflow keyword/);
+            const statePath = join(cwd, ".omx", "state", "sessions", "sess-autopilot-bare-observable", "autopilot-state.json");
+            const modeState = JSON.parse(await readFile(statePath, "utf-8"));
+            assert.equal(modeState.active, true);
+            assert.equal(modeState.current_phase, "deep-interview");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     // ── Group 2: HEAVY injection ─────────────────────────────────────────────
     it("injects HEAVY advisory and writes prompt-routing-state for a multi-step goal prompt", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-triage-heavy-"));