oh-my-codex 0.18.7 → 0.18.8

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 });
@@ -2853,6 +2878,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 +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;
@@ -4219,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);
         }
@@ -11483,7 +11562,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,7 +11604,35 @@ 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("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 });
@@ -11606,12 +11713,430 @@ 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("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 {
@@ -11677,7 +12202,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);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -12291,6 +12816,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 {