oh-my-codex 0.12.4 → 0.12.6

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

@@ -6,13 +6,41 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import { buildManagedCodexHooksConfig } from "../../config/codex-hooks.js";
-import { initTeamState, readTeamLeaderAttention, readTeamPhase, } from "../../team/state.js";
+import { initTeamState, readTeamLeaderAttention, readTeamPhase, writeTeamLeaderAttention, } from "../../team/state.js";
 import { dispatchCodexNativeHook, mapCodexHookEventToOmxEvent, resolveSessionOwnerPidFromAncestry, } from "../codex-native-hook.js";
+import { writeSessionStart } from "../../hooks/session.js";
 async function writeJson(path, value) {
     await mkdir(dirname(path), { recursive: true }).catch(() => { });
     await writeFile(path, JSON.stringify(value, null, 2));
 }
+async function writeReleaseReadinessLeaderAttention(teamName, sessionId, cwd, options) {
+    await writeTeamLeaderAttention(teamName, {
+        team_name: teamName,
+        updated_at: "2026-04-12T17:20:00.000Z",
+        source: "notify_hook",
+        leader_decision_state: "done_waiting_on_leader",
+        leader_attention_pending: true,
+        leader_attention_reason: "leader_session_stopped",
+        attention_reasons: ["leader_session_stopped"],
+        leader_stale: true,
+        leader_session_active: false,
+        leader_session_id: sessionId,
+        leader_session_stopped_at: "2026-04-12T17:20:00.000Z",
+        unread_leader_message_count: 0,
+        work_remaining: options.workRemaining,
+        stalled_for_ms: null,
+    }, cwd);
+}
+async function writeReleaseReadinessStateMarker(sessionId, teamName, cwd) {
+    await writeJson(join(cwd, ".omx", "state", "sessions", sessionId, "release-readiness-state.json"), {
+        active: true,
+        session_id: sessionId,
+        team_name: teamName,
+        stable_final_recommendation_emitted: true,
+    });
+}
 const TEAM_STOP_COMMIT_GUIDANCE = " If system-generated worker auto-checkpoint commits exist, rewrite them into Lore-format final commits before merge/finalization.";
+const DEFAULT_AUTO_NUDGE_RESPONSE = "continue with the current task only if it is already authorized";
 const TEAM_ENV_KEYS = [
     "OMX_TEAM_WORKER",
     "OMX_TEAM_STATE_ROOT",
@@ -58,6 +86,19 @@ describe("codex native hook config", () => {
     });
 });
 describe("codex native hook dispatch", () => {
+    it("emits deterministic JSON stdout when CLI stdin is malformed", () => {
+        const stdout = execFileSync(process.execPath, [join(process.cwd(), "dist", "scripts", "codex-native-hook.js")], {
+            cwd: process.cwd(),
+            input: "{",
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const output = JSON.parse(stdout.trim());
+        assert.equal(output.decision, "block");
+        assert.equal(output.reason, "OMX native hook received malformed JSON input. Preserve runtime state and inspect the emitting hook payload before retrying.");
+        assert.equal(output.hookSpecificOutput?.hookEventName, "Unknown");
+        assert.match(String(output.hookSpecificOutput?.additionalContext ?? ""), /stdin JSON parsing failed inside codex-native-hook:/);
+    });
     it("maps Codex events onto OMX logical surfaces", () => {
         assert.equal(mapCodexHookEventToOmxEvent("SessionStart"), "session-start");
         assert.equal(mapCodexHookEventToOmxEvent("UserPromptSubmit"), "keyword-detector");
@@ -85,12 +126,55 @@ describe("codex native hook dispatch", () => {
             });
             const sessionState = JSON.parse(await readFile(join(cwd, ".omx", "state", "session.json"), "utf-8"));
             assert.equal(sessionState.session_id, "sess-start-1");
+            assert.equal(sessionState.native_session_id, "sess-start-1");
             assert.equal(sessionState.pid, 43210);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("preserves canonical OMX session scope when native SessionStart arrives with a different id", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-reconcile-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "omx-launch-1";
+            const nativeSessionId = "codex-native-1";
+            await mkdir(join(stateDir, "sessions", canonicalSessionId), { recursive: true });
+            await writeSessionStart(cwd, canonicalSessionId);
+            await writeJson(join(stateDir, "sessions", canonicalSessionId, "hud-state.json"), {
+                last_turn_at: "2026-04-10T00:00:00.000Z",
+                turn_count: 1,
+            });
+            await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: nativeSessionId,
+            }, {
+                cwd,
+                sessionOwnerPid: process.pid,
+            });
+            const sessionState = JSON.parse(await readFile(join(stateDir, "session.json"), "utf-8"));
+            assert.equal(sessionState.session_id, canonicalSessionId);
+            assert.equal(sessionState.native_session_id, nativeSessionId);
+            assert.equal(sessionState.pid, process.pid);
+            const promptResult = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-1",
+                turn_id: "turn-1",
+                prompt: "$ralplan fix hud scope drift",
+            }, { cwd });
+            assert.equal(promptResult.omxEventName, "keyword-detector");
+            assert.equal(existsSync(join(stateDir, "sessions", canonicalSessionId, "skill-active-state.json")), true);
+            assert.equal(existsSync(join(stateDir, "sessions", canonicalSessionId, "ralplan-state.json")), true);
+            assert.equal(existsSync(join(stateDir, "sessions", nativeSessionId, "skill-active-state.json")), false);
+            assert.equal(existsSync(join(stateDir, "sessions", nativeSessionId, "ralplan-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("appends .omx/ to repo-root .gitignore during SessionStart when missing", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-gitignore-"));
         try {
@@ -185,6 +269,40 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not expose submitted prompt text to keyword-detector hook plugins", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-prompt-sanitized-"));
+        try {
+            await mkdir(join(cwd, ".omx", "hooks"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "hooks", "capture-keyword-context.mjs"), `import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+export async function onHookEvent(event) {
+  if (event.event !== "keyword-detector") return;
+  const outPath = join(process.cwd(), ".omx", "captured-keyword-context.json");
+  await mkdir(dirname(outPath), { recursive: true });
+  await writeFile(outPath, JSON.stringify(event.context, null, 2));
+}
+`, "utf-8");
+            await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-sanitized-1",
+                thread_id: "thread-sanitized-1",
+                turn_id: "turn-sanitized-1",
+                prompt: "$ralplan approve this blocker-sensitive request",
+            }, { cwd });
+            const captured = JSON.parse(await readFile(join(cwd, ".omx", "captured-keyword-context.json"), "utf-8"));
+            assert.equal(captured.prompt, undefined);
+            assert.equal(captured.payload?.prompt, undefined);
+            assert.equal(captured.payload?.input, undefined);
+            assert.equal(captured.payload?.user_prompt, undefined);
+            assert.equal(captured.payload?.userPrompt, undefined);
+            assert.equal(captured.payload?.text, undefined);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("does not emit UserPromptSubmit routing context for unknown $tokens", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-unknown-token-"));
         try {
@@ -232,6 +350,95 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("returns actionable denial guidance for unsupported workflow overlaps on prompt submit", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-transition-deny-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-deny-1",
+                thread_id: "thread-deny-1",
+                turn_id: "turn-deny-1",
+                prompt: "$team ship this fix",
+            }, { cwd });
+            const denied = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-deny-1",
+                thread_id: "thread-deny-1",
+                turn_id: "turn-deny-2",
+                prompt: "$autopilot also run this",
+            }, { cwd });
+            assert.match(JSON.stringify(denied.outputJson), /denied workflow keyword/i);
+            assert.match(JSON.stringify(denied.outputJson), /Unsupported workflow overlap: team \+ autopilot\./);
+            assert.match(JSON.stringify(denied.outputJson), /`omx state clear --mode <mode>`/);
+            assert.match(JSON.stringify(denied.outputJson), /`omx_state\.\*` MCP tools/);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-deny-1", "autopilot-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("surfaces transition success output for allowlisted prompt-submit handoffs", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-transition-success-"));
+        try {
+            const sessionDir = join(cwd, ".omx", "state", "sessions", "sess-handoff-1");
+            await mkdir(sessionDir, { recursive: true });
+            await writeJson(join(sessionDir, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "intent-first",
+            });
+            await writeJson(join(sessionDir, "skill-active-state.json"), {
+                active: true,
+                skill: "deep-interview",
+                phase: "planning",
+                session_id: "sess-handoff-1",
+                active_skills: [{ skill: "deep-interview", phase: "planning", active: true, session_id: "sess-handoff-1" }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-handoff-1",
+                thread_id: "thread-handoff-1",
+                turn_id: "turn-handoff-1",
+                prompt: "$ralplan implement the approved contract",
+            }, { cwd });
+            assert.match(JSON.stringify(result.outputJson), /mode transiting: deep-interview -> ralplan/);
+            const completed = JSON.parse(await readFile(join(sessionDir, "deep-interview-state.json"), "utf-8"));
+            assert.equal(completed.active, false);
+            assert.equal(completed.current_phase, "completed");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("keeps the planning skill active when planning and execution workflows are invoked together", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-planning-precedence-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-multi-1",
+                thread_id: "thread-multi-1",
+                turn_id: "turn-multi-1",
+                prompt: "$ralplan $team $ralph ship this fix",
+            }, { cwd });
+            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || '');
+            assert.match(message, /\$ralplan" -> ralplan/);
+            assert.match(message, /\$team" -> team/);
+            assert.match(message, /\$ralph" -> ralph/);
+            assert.doesNotMatch(message, /mode transiting:/);
+            assert.match(message, /planning preserved over simultaneous execution follow-up; deferred skills: team, ralph\./);
+            assert.match(message, /skill: ralplan activated and initial state initialized at \.omx\/state\/sessions\/sess-multi-1\/ralplan-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.doesNotMatch(message, /Use the durable OMX team runtime via `omx team \.\.\.`/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("runs prompt-submit HUD reconciliation as a best-effort tmux-only side effect", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-reconcile-"));
         const originalTmux = process.env.TMUX;
@@ -436,6 +643,47 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("marks canonical team state failed when native payload session ids differ during MCP transport death", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-team-native-transport-"));
+        const previousCwd = process.cwd();
+        const canonicalSessionId = "omx-canonical-session";
+        const nativeSessionId = "codex-native-session";
+        try {
+            process.chdir(cwd);
+            await writeSessionStart(cwd, canonicalSessionId);
+            const sessionPath = join(cwd, ".omx", "state", "session.json");
+            const sessionState = JSON.parse(await readFile(sessionPath, "utf-8"));
+            await writeFile(sessionPath, JSON.stringify({
+                ...sessionState,
+                native_session_id: nativeSessionId,
+            }, null, 2));
+            await initTeamState("transport-team", "task", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: canonicalSessionId });
+            await writeJson(join(cwd, ".omx", "state", "team-state.json"), {
+                active: true,
+                team_name: "transport-team",
+                current_phase: "team-exec",
+            });
+            await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                session_id: nativeSessionId,
+                tool_name: "mcp__omx_state__state_write",
+                tool_use_id: "tool-mcp-transport-team-native",
+                tool_input: { mode: "team", active: true },
+                tool_response: "{\"error\":\"MCP transport closed\",\"details\":\"stdio pipe closed before response\"}",
+            }, { cwd });
+            const phase = await readTeamPhase("transport-team", cwd);
+            const attention = await readTeamLeaderAttention("transport-team", cwd);
+            assert.equal(phase?.current_phase, "failed");
+            assert.equal(attention?.leader_attention_reason, "mcp_transport_dead");
+            assert.equal(attention?.leader_attention_pending, true);
+            assert.equal(attention?.leader_session_id, canonicalSessionId);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("treats stderr-only informative non-zero output as reviewable instead of a generic failure", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-informative-stderr-"));
         try {
@@ -792,6 +1040,58 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("emits one concise final decision summary and auto-finalize guidance when release-readiness already has a stable final recommendation and no active worker tasks", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-release-readiness-finalize-"));
+        try {
+            await initTeamState("release-ready-team", "release readiness finalize", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-release-ready" });
+            await writeReleaseReadinessLeaderAttention("release-ready-team", "sess-stop-release-ready", cwd, { workRemaining: false });
+            await writeReleaseReadinessStateMarker("sess-stop-release-ready", "release-ready-team", cwd);
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-release-ready",
+                thread_id: "thread-stop-release-ready",
+                turn_id: "turn-stop-release-ready-1",
+                mode: "release-readiness",
+                last_assistant_message: "Launch-ready: yes",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: 'Stable final recommendation already reached with no active worker tasks. Emit exactly one concise final decision summary aligned to "Launch-ready: yes." with no filler or residual acknowledgements (for example "yes"), then stop.',
+                stopReason: "release_readiness_auto_finalize",
+                systemMessage: "OMX release-readiness detected a stable final recommendation with no active worker tasks; emit one concise final decision summary and finalize.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not auto-finalize non-release team stops that happen to contain a stable recommendation summary", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-non-release-readiness-control-"));
+        try {
+            await initTeamState("general-review-team", "general team stop control", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-general-review" });
+            await writeReleaseReadinessLeaderAttention("general-review-team", "sess-stop-general-review", cwd, { workRemaining: false });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-general-review",
+                thread_id: "thread-stop-general-review",
+                turn_id: "turn-stop-general-review-1",
+                last_assistant_message: "Launch-ready: yes",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (general-review-team) at phase team-exec; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                stopReason: "team_team-exec",
+                systemMessage: "OMX team pipeline is still active at phase team-exec.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("re-fires canonical-team Stop output for a later fresh Stop reply when coarse mode state is missing", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-canonical-refire-"));
         try {
@@ -936,6 +1236,42 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("blocks Stop from session-scoped team mode when session.json points to another session", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-session-mismatch-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-live-team"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-other-team" });
+            await writeJson(join(stateDir, "sessions", "sess-live-team", "team-state.json"), {
+                active: true,
+                mode: "team",
+                current_phase: "team-exec",
+                team_name: "session-live-team",
+            });
+            await writeJson(join(stateDir, "team", "session-live-team", "phase.json"), {
+                current_phase: "team-exec",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-live-team",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (session-live-team) at phase team-exec; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                stopReason: "team_team-exec",
+                systemMessage: "OMX team pipeline is still active at phase team-exec.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("returns Stop continuation output for active ralplan skill with matching active mode state and without active subagents", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-skill-"));
         try {
@@ -1074,7 +1410,7 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("returns Stop continuation output for active deep-interview skill with matching active mode state and without active subagents", async () => {
+    it("does not block Stop solely because deep-interview is active", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-deep-interview-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
@@ -1094,12 +1430,7 @@ esac
                 cwd,
                 session_id: "sess-stop-deep-interview",
             }, { cwd });
-            assert.deepEqual(result.outputJson, {
-                decision: "block",
-                reason: "OMX skill deep-interview is still active (phase: planning); continue until the current deep-interview workflow reaches a terminal state.",
-                stopReason: "skill_deep-interview_planning",
-                systemMessage: "OMX skill deep-interview is still active (phase: planning).",
-            });
+            assert.equal(result.outputJson, null);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -1129,7 +1460,7 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("returns Stop continuation output while Ralph is active", async () => {
+    it("returns Stop continuation output while Ralph is active without an explicit session pin", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
@@ -1141,7 +1472,34 @@ esac
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
-                session_id: "sess-stop",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: "OMX Ralph is still active (phase: executing); continue the task and gather fresh verification evidence before stopping.",
+                stopReason: "ralph_executing",
+                systemMessage: "OMX Ralph is still active (phase: executing); continue the task and gather fresh verification evidence before stopping.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks Stop from session-scoped Ralph state when session.json points to another session", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-ralph-session-mismatch-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-live-ralph"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-other-ralph" });
+            await writeJson(join(stateDir, "sessions", "sess-live-ralph", "ralph-state.json"), {
+                active: true,
+                current_phase: "executing",
+                session_id: "sess-live-ralph",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-live-ralph",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
             assert.deepEqual(result.outputJson, {
@@ -1179,6 +1537,103 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not block Stop from another session-scoped Ralph state when an explicit session_id has no active Ralph state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-explicit-session-ralph-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-other"), { recursive: true });
+            await writeJson(join(stateDir, "sessions", "sess-other", "ralph-state.json"), {
+                active: true,
+                current_phase: "starting",
+                session_id: "sess-other",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+            }, { 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 Ralph fallback when the current session has no scoped Ralph state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-fallback-ralph-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current", cwd });
+            await writeJson(join(stateDir, "ralph-state.json"), {
+                active: true,
+                current_phase: "executing",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block Stop when the current session Ralph state is cancelled even if stale root fallback remains", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-cancelled-session-ralph-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current", cwd });
+            await writeJson(join(stateDir, "sessions", "sess-current", "ralph-state.json"), {
+                active: false,
+                current_phase: "cancelled",
+                completed_at: "2026-04-10T23:30:38.000Z",
+                session_id: "sess-current",
+            });
+            await writeJson(join(stateDir, "ralph-state.json"), {
+                active: true,
+                current_phase: "starting",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+            }, { 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 Ralph fallback when an explicit session_id is present and session.json points to another worktree", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-fallback-cwd-mismatch-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(stateDir, { recursive: true });
+            await writeJson(join(stateDir, "session.json"), {
+                session_id: "sess-elsewhere",
+                cwd: join(cwd, "..", "different-worktree"),
+            });
+            await writeJson(join(stateDir, "ralph-state.json"), {
+                active: true,
+                current_phase: "executing",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("does not re-block Ralph when Stop already continued once", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-ralph-once-"));
         try {
@@ -1210,12 +1665,12 @@ esac
                 hook_event_name: "Stop",
                 cwd,
                 session_id: "sess-stop-auto",
-                last_assistant_message: "Would you like me to keep going and finish the cleanup?",
+                last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
             assert.deepEqual(result.outputJson, {
                 decision: "block",
-                reason: "yes, proceed",
+                reason: DEFAULT_AUTO_NUDGE_RESPONSE,
                 stopReason: "auto_nudge",
                 systemMessage: "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
             });
@@ -1235,7 +1690,7 @@ esac
                 session_id: "sess-stop-auto-once",
                 thread_id: "thread-stop-auto",
                 turn_id: "turn-stop-auto-1",
-                last_assistant_message: "Would you like me to continue?",
+                last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
@@ -1244,7 +1699,7 @@ esac
                 thread_id: "thread-stop-auto",
                 turn_id: "turn-stop-auto-1",
                 stop_hook_active: true,
-                last_assistant_message: "Would you like me to continue?",
+                last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
             assert.equal(result.outputJson, null);
@@ -1264,7 +1719,7 @@ esac
                 session_id: "sess-stop-auto-refire",
                 thread_id: "thread-stop-auto-refire",
                 turn_id: "turn-stop-auto-refire-1",
-                last_assistant_message: "Would you like me to continue?",
+                last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
@@ -1273,12 +1728,12 @@ esac
                 thread_id: "thread-stop-auto-refire",
                 turn_id: "turn-stop-auto-refire-2",
                 stop_hook_active: true,
-                last_assistant_message: "If you want, I can keep going and finish the cleanup.",
+                last_assistant_message: "Continue with the cleanup from here.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
             assert.deepEqual(result.outputJson, {
                 decision: "block",
-                reason: "yes, proceed",
+                reason: DEFAULT_AUTO_NUDGE_RESPONSE,
                 stopReason: "auto_nudge",
                 systemMessage: "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
             });
@@ -1287,17 +1742,36 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("suppresses native auto-nudge when only the deep-interview input lock is active", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-deep-interview-lock-"));
+    it("does not auto-continue native Stop on permission-seeking prompts", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-permission-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-auto-permission",
+                last_assistant_message: "Would you like me to continue with the cleanup?",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not auto-continue native Stop while deep-interview is waiting on an intent-first question", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-deep-interview-question-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
-            await mkdir(join(stateDir, "sessions", "sess-stop-auto-lock"), { recursive: true });
-            await writeJson(join(stateDir, "session.json"), { session_id: "sess-stop-auto-lock" });
-            await writeJson(join(stateDir, "sessions", "sess-stop-auto-lock", "skill-active-state.json"), {
+            await mkdir(join(stateDir, "sessions", "sess-stop-auto-question"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-stop-auto-question" });
+            await writeJson(join(stateDir, "sessions", "sess-stop-auto-question", "skill-active-state.json"), {
                 version: 1,
                 active: true,
                 skill: "deep-interview",
                 phase: "planning",
+                session_id: "sess-stop-auto-question",
+                thread_id: "thread-stop-auto-question",
                 input_lock: {
                     active: true,
                     scope: "deep-interview-auto-approval",
@@ -1305,25 +1779,26 @@ esac
                     message: "Deep interview is active; auto-approval shortcuts are blocked until the interview finishes.",
                 },
             });
-            await writeJson(join(stateDir, "sessions", "sess-stop-auto-lock", "deep-interview-state.json"), {
+            await writeJson(join(stateDir, "sessions", "sess-stop-auto-question", "deep-interview-state.json"), {
                 active: true,
-                current_phase: "planning",
+                mode: "deep-interview",
+                current_phase: "intent-first",
             });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
-                session_id: "sess-stop-auto-lock",
-                thread_id: "thread-stop-auto-lock",
-                turn_id: "turn-stop-auto-lock-1",
-                last_assistant_message: "Would you like me to continue with the next step?",
+                session_id: "sess-stop-auto-question",
+                thread_id: "thread-stop-auto-question",
+                turn_id: "turn-stop-auto-question-1",
+                last_assistant_message: [
+                    "Round 2 | Target: Decision boundary | Ambiguity: 24%",
+                    "",
+                    "If an existing project spider still declares session_mode = \"owned\", should ZenX fail loudly so the stale attribute is removed, or should it ignore the attribute and initialize the session pool anyway?",
+                    "Keep going once I have your answer.",
+                ].join("\n"),
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
-            assert.deepEqual(result.outputJson, {
-                decision: "block",
-                reason: "OMX skill deep-interview is still active (phase: planning); continue until the current deep-interview workflow reaches a terminal state.",
-                stopReason: "skill_deep-interview_planning",
-                systemMessage: "OMX skill deep-interview is still active (phase: planning).",
-            });
+            assert.equal(result.outputJson, null);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -1395,12 +1870,12 @@ esac
                 session_id: "sess-stop-auto-stale-root-mode",
                 thread_id: "thread-stop-auto-stale-root-mode",
                 turn_id: "turn-stop-auto-stale-root-mode-1",
-                last_assistant_message: "Would you like me to continue with the next step?",
+                last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
             assert.deepEqual(result.outputJson, {
                 decision: "block",
-                reason: "yes, proceed",
+                reason: DEFAULT_AUTO_NUDGE_RESPONSE,
                 stopReason: "auto_nudge",
                 systemMessage: "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
             });
@@ -1425,12 +1900,12 @@ esac
                 session_id: "sess-stop-auto-stale-root-skill",
                 thread_id: "thread-stop-auto-stale-root-skill",
                 turn_id: "turn-stop-auto-stale-root-skill-1",
-                last_assistant_message: "Would you like me to continue with the next step?",
+                last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
             assert.deepEqual(result.outputJson, {
                 decision: "block",
-                reason: "yes, proceed",
+                reason: DEFAULT_AUTO_NUDGE_RESPONSE,
                 stopReason: "auto_nudge",
                 systemMessage: "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
             });
@@ -1461,12 +1936,48 @@ esac
                 session_id: "sess-stop-auto-stale-root-lock",
                 thread_id: "thread-stop-auto-stale-root-lock",
                 turn_id: "turn-stop-auto-stale-root-lock-1",
-                last_assistant_message: "Would you like me to continue with the next step?",
+                last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
             assert.deepEqual(result.outputJson, {
                 decision: "block",
-                reason: "yes, proceed",
+                reason: DEFAULT_AUTO_NUDGE_RESPONSE,
+                stopReason: "auto_nudge",
+                systemMessage: "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not suppress native auto-nudge from active root deep-interview state when the current scoped mode state is explicitly inactive", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-inactive-scoped-mode-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-stop-auto-inactive-mode"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-stop-auto-inactive-mode" });
+            await writeJson(join(stateDir, "sessions", "sess-stop-auto-inactive-mode", "deep-interview-state.json"), {
+                active: false,
+                mode: "deep-interview",
+                current_phase: "completed",
+            });
+            await writeJson(join(stateDir, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "intent-first",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-auto-inactive-mode",
+                thread_id: "thread-stop-auto-inactive-mode",
+                turn_id: "turn-stop-auto-inactive-mode-1",
+                last_assistant_message: "Keep going and finish the cleanup.",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: DEFAULT_AUTO_NUDGE_RESPONSE,
                 stopReason: "auto_nudge",
                 systemMessage: "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
             });
@@ -1519,5 +2030,146 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not block Stop from another session's stale root team state when no scoped team state exists", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-stale-root-team-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "stale-root-team",
+                session_id: "sess-other",
+            });
+            await writeJson(join(stateDir, "team", "stale-root-team", "phase.json"), {
+                current_phase: "team-exec",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+            }, { 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 orphaned team mode state after cleanup removed canonical team artifacts", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-orphaned-team-state-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "cleaned-team",
+                session_id: "sess-current",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("prefers the current session team state over a stale root team fallback during Stop", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-current-session-team-preferred-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "sessions", "sess-current", "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "current-team",
+                session_id: "sess-current",
+            });
+            await writeJson(join(stateDir, "team", "current-team", "phase.json"), {
+                current_phase: "team-verify",
+                max_fix_attempts: 3,
+                current_fix_attempt: 1,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "stale-root-team",
+                session_id: "sess-other",
+            });
+            await writeJson(join(stateDir, "team", "stale-root-team", "phase.json"), {
+                current_phase: "team-exec",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (current-team) at phase team-verify; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                stopReason: "team_team-verify",
+                systemMessage: "OMX team pipeline is still active at phase team-verify.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not fall back to active root team state when the current scoped team state is inactive", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-inactive-scoped-team-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "sessions", "sess-current", "team-state.json"), {
+                active: false,
+                current_phase: "complete",
+                team_name: "scoped-finished-team",
+                session_id: "sess-current",
+            });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "root-fallback-team",
+                session_id: "sess-current",
+            });
+            await writeJson(join(stateDir, "team", "root-fallback-team", "phase.json"), {
+                current_phase: "team-exec",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
 });
 //# sourceMappingURL=codex-native-hook.test.js.map