oh-my-codex 0.18.7 → 0.18.9

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

@@ -46,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);
@@ -1280,12 +1297,16 @@ describe("codex native hook dispatch", () => {
             }, {
                 cwd,
                 reconcileHudForPromptSubmitFn: async (hookCwd, deps = {}) => {
-                    reconcileCall = { cwd: hookCwd, sessionId: deps.sessionId };
+                    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 });
+            assert.deepEqual(reconcileCall, {
+                cwd,
+                sessionId: ownerSessionId,
+                sessionIds: [ownerSessionId, nativeSessionId],
+            });
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -1315,12 +1336,16 @@ describe("codex native hook dispatch", () => {
                 }, {
                     cwd,
                     reconcileHudForPromptSubmitFn: async (hookCwd, deps = {}) => {
-                        reconcileCall = { cwd: hookCwd, sessionId: deps.sessionId };
+                        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 });
+                assert.deepEqual(reconcileCall, {
+                    cwd,
+                    sessionId: canonicalSessionId,
+                    sessionIds: [canonicalSessionId, nativeSessionId],
+                });
             }
             finally {
                 await rm(cwd, { recursive: true, force: true });
@@ -1457,6 +1482,46 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("includes repo-local .omx project-memory during SessionStart when OMX_ROOT is boxed", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-boxed-memory-"));
+        const boxedRoot = await mkdtemp(join(tmpdir(), "omx-native-hook-boxed-root-"));
+        const previousOmxRoot = process.env.OMX_ROOT;
+        try {
+            process.env.OMX_ROOT = boxedRoot;
+            await writeJson(join(cwd, ".omx", "project-memory.json"), {
+                techStack: "Repo-local CLI memory",
+                conventions: "SessionStart should load CLI-written project memory",
+                directives: [
+                    { directive: "Prefer repo-local .omx project memory over boxed runtime fallback.", priority: "high" },
+                ],
+            });
+            await writeJson(join(boxedRoot, ".omx", "project-memory.json"), {
+                techStack: "Boxed runtime memory should not win",
+                notes: [{ category: "runtime", content: "stale boxed runtime note", timestamp: new Date().toISOString() }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: "sess-boxed-memory-1",
+            }, { cwd, sessionOwnerPid: 43210 });
+            const additionalContext = String(result.outputJson?.hookSpecificOutput?.additionalContext ?? "");
+            assert.match(additionalContext, /\[Project memory\]/);
+            assert.match(additionalContext, /source: \.omx\/project-memory\.json/);
+            assert.match(additionalContext, /Repo-local CLI memory/);
+            assert.match(additionalContext, /SessionStart should load CLI-written project memory/);
+            assert.match(additionalContext, /Prefer repo-local \.omx project memory over boxed runtime fallback\./);
+            assert.doesNotMatch(additionalContext, /Boxed runtime memory should not win/);
+            assert.doesNotMatch(additionalContext, /stale boxed runtime note/);
+        }
+        finally {
+            if (previousOmxRoot === undefined)
+                delete process.env.OMX_ROOT;
+            else
+                process.env.OMX_ROOT = previousOmxRoot;
+            await rm(cwd, { recursive: true, force: true });
+            await rm(boxedRoot, { recursive: true, force: true });
+        }
+    });
     it("prefers repository project-memory.json during SessionStart while preserving legacy wiki guidance", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-root-memory-legacy-wiki-"));
         try {
@@ -2853,6 +2918,13 @@ standardMaxRounds = 15
             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 });
@@ -4172,7 +4244,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;
@@ -4219,8 +4338,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);
         }
@@ -11483,7 +11602,7 @@ exit 0
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.equal(result.outputJson?.decision, "block");
-            assert.match(String(result.outputJson?.reason ?? ""), /Ralplan is active .*implementation\/write tools are blocked/i);
+            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 {
@@ -11525,120 +11644,146 @@ exit 0
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.equal(result.outputJson?.decision, "block");
-            assert.match(String(result.outputJson?.reason ?? ""), /Ralplan is active .*implementation\/write tools are blocked/i);
+            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("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-"));
+    it("blocks implementation writes when Autopilot ralplan is visible only in skill-active phase", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-skill-ralplan-pretool-block-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
-            const sessionId = "sess-autopilot-ralplan-terminal-pretool";
+            const sessionId = "sess-autopilot-skill-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",
+                phase: "autopilot:ralplan",
                 session_id: sessionId,
-                active_skills: [{ skill: "autopilot", phase: "ralplan", active: true, session_id: sessionId }],
+                active_skills: [{ skill: "autopilot", phase: "autopilot:ralplan", active: true, session_id: sessionId }],
             });
             await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
                 active: true,
                 mode: "autopilot",
-                current_phase: "ralplan",
+                current_phase: "planning",
                 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",
+                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-terminal-pretool",
+                thread_id: "thread-autopilot-skill-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, null);
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason ?? ""), /Autopilot planning is active .*implementation\/write tools are blocked/i);
         }
         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-"));
+    it("ignores stale Autopilot ralplan skill mirrors after detail state leaves planning", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-stale-ralplan-mirror-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
-            const sessionId = "sess-autopilot-ralplan-pretool-bash-block";
+            const sessionId = "sess-autopilot-stale-ralplan-mirror";
             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",
+                phase: "autopilot:ralplan",
                 session_id: sessionId,
-                active_skills: [{ skill: "autopilot", phase: "ralplan", active: true, session_id: sessionId }],
+                active_skills: [{ skill: "autopilot", phase: "autopilot:ralplan", active: true, session_id: sessionId }],
+            });
+            for (const phase of ["ultragoal", "code-review", "completing", "complete"]) {
+                await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                    active: true,
+                    mode: "autopilot",
+                    current_phase: phase,
+                    session_id: sessionId,
+                });
+                const result = await dispatchCodexNativeHook({
+                    hook_event_name: "PreToolUse",
+                    cwd,
+                    session_id: sessionId,
+                    thread_id: "thread-autopilot-stale-ralplan-mirror",
+                    tool_name: "Edit",
+                    tool_input: { file_path: "src/runtime.ts" },
+                }, { cwd });
+                assert.equal(result.omxEventName, "pre-tool-use");
+                assert.equal(result.outputJson, null, `stale skill-active ralplan mirror must not block when Autopilot detail phase is ${phase}`);
+            }
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows explicit blank Autopilot detail phase to use a ralplan skill mirror", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-blank-phase-mirror-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-autopilot-blank-phase-mirror";
+            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: "autopilot:ralplan",
+                session_id: sessionId,
+                active_skills: [{ skill: "autopilot", phase: "autopilot:ralplan", active: true, session_id: sessionId }],
             });
             await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
                 active: true,
                 mode: "autopilot",
-                current_phase: "ralplan",
+                current_phase: "",
                 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" },
+                thread_id: "thread-autopilot-blank-phase-mirror",
+                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 is active .*implementation\/write tools are blocked/i);
+            assert.match(String(result.outputJson?.reason ?? ""), /Autopilot planning is active .*implementation\/write tools are blocked/i);
         }
         finally {
             await rm(cwd, { 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-"));
+    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-ralplan-pretool-artifact";
+            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, "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"), {
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
                 active: true,
-                mode: "ralplan",
-                current_phase: "planning",
+                mode: "autopilot",
+                current_phase: "ralplan",
                 session_id: sessionId,
             });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
                 session_id: sessionId,
-                thread_id: "thread-ralplan-pretool-artifact",
-                tool_name: "Write",
-                tool_input: { file_path: ".omx/plans/prd-issue-2603.md" },
+                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);
@@ -11647,143 +11792,677 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    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-"));
+    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-ralplan-pretool-bash-block";
+            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: "ralplan",
-                phase: "planning",
+                skill: "autopilot",
+                phase: "ralplan",
                 session_id: sessionId,
-                active_skills: [{ skill: "ralplan", phase: "planning", active: true, session_id: sessionId }],
+                active_skills: [{ skill: "autopilot", phase: "ralplan", active: true, session_id: sessionId }],
             });
-            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
                 active: true,
-                mode: "ralplan",
-                current_phase: "planning",
+                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-ralplan-pretool-bash-block",
-                tool_name: "Bash",
-                tool_input: { command: "cat <<'EOF' > src/runtime.ts\nimplementation\nEOF" },
+                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?.decision, "block");
-            assert.match(String(result.outputJson?.reason ?? ""), /Ralplan is active .*implementation\/write tools are blocked/i);
+            assert.equal(result.outputJson, null);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    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-"));
+    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-ralplan-pretool-bash-artifact";
+            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: "ralplan",
-                phase: "planning",
+                skill: "autopilot",
+                phase: "ralplan",
                 session_id: sessionId,
-                active_skills: [{ skill: "ralplan", phase: "planning", active: true, session_id: sessionId }],
+                active_skills: [{ skill: "autopilot", phase: "ralplan", active: true, session_id: sessionId }],
             });
-            await writeJson(join(stateDir, "sessions", sessionId, "ralplan-state.json"), {
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
                 active: true,
-                mode: "ralplan",
-                current_phase: "planning",
+                mode: "autopilot",
+                current_phase: "ralplan",
                 session_id: sessionId,
             });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
                 session_id: sessionId,
-                thread_id: "thread-ralplan-pretool-bash-artifact",
+                thread_id: "thread-autopilot-ralplan-pretool-bash-block",
                 tool_name: "Bash",
-                tool_input: { command: "cat <<'EOF' > .omx/plans/prd-issue-2603.md\nplanning\nEOF" },
+                tool_input: { command: "cat <<'EOF' > src/runtime.ts\nimplementation\nEOF" },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
-            assert.equal(result.outputJson, null);
+            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("allows implementation writes when an explicit execution handoff is active", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralplan-pretool-handoff-"));
+    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-pretool-handoff";
+            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: "ultragoal",
-                phase: "planning",
+                skill: "autopilot",
+                phase: "ralplan",
                 session_id: sessionId,
                 active_skills: [
                     { skill: "ralplan", phase: "planning", active: true, session_id: sessionId },
-                    { skill: "ultragoal", 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: "complete",
+                current_phase: "planning",
                 session_id: sessionId,
             });
-            await writeJson(join(stateDir, "sessions", sessionId, "ultragoal-state.json"), {
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
                 active: true,
-                mode: "ultragoal",
-                current_phase: "planning",
+                mode: "autopilot",
+                current_phase: "ralplan",
                 session_id: sessionId,
             });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
                 session_id: sessionId,
-                thread_id: "thread-ralplan-pretool-handoff",
+                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, null);
+            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 Stop from root team state without team_name when no session is known", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-team-no-session-no-name-"));
+    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");
-            await mkdir(stateDir, { recursive: true });
-            await writeJson(join(stateDir, "team-state.json"), {
+            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,
-                mode: "team",
-                current_phase: "starting",
+                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: "Stop",
+                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, "stop");
-            assert.equal(result.outputJson, null);
+            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 Stop from root team state without team_name for a foreign session", async () => {
+    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,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                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, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    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");
+            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,
+                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,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                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(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("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");
+            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,
+                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,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                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(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    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");
+            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: "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: sessionId,
+                thread_id: "thread-ralplan-pretool-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("does not block Stop from root team state without team_name when no session is known", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-team-no-session-no-name-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(stateDir, { recursive: true });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                mode: "team",
+                current_phase: "starting",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block Stop from root team state without team_name for a foreign session", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-team-foreign-no-name-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
@@ -12291,6 +12970,63 @@ 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 {