oh-my-codex 0.12.2 → 0.12.4

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

@@ -1,18 +1,41 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import { describe, it } from "node:test";
+import { afterEach, beforeEach, describe, it } from "node:test";
 import { buildManagedCodexHooksConfig } from "../../config/codex-hooks.js";
-import { initTeamState } from "../../team/state.js";
+import { initTeamState, readTeamLeaderAttention, readTeamPhase, } from "../../team/state.js";
 import { dispatchCodexNativeHook, mapCodexHookEventToOmxEvent, resolveSessionOwnerPidFromAncestry, } from "../codex-native-hook.js";
 async function writeJson(path, value) {
     await mkdir(dirname(path), { recursive: true }).catch(() => { });
     await writeFile(path, JSON.stringify(value, null, 2));
 }
 const TEAM_STOP_COMMIT_GUIDANCE = " If system-generated worker auto-checkpoint commits exist, rewrite them into Lore-format final commits before merge/finalization.";
+const TEAM_ENV_KEYS = [
+    "OMX_TEAM_WORKER",
+    "OMX_TEAM_STATE_ROOT",
+    "OMX_TEAM_LEADER_CWD",
+];
+const priorTeamEnv = new Map();
+beforeEach(() => {
+    priorTeamEnv.clear();
+    for (const key of TEAM_ENV_KEYS) {
+        priorTeamEnv.set(key, process.env[key]);
+        delete process.env[key];
+    }
+});
+afterEach(() => {
+    for (const key of TEAM_ENV_KEYS) {
+        const value = priorTeamEnv.get(key);
+        if (typeof value === "string")
+            process.env[key] = value;
+        else
+            delete process.env[key];
+    }
+    priorTeamEnv.clear();
+});
 describe("codex native hook config", () => {
     it("builds the expected managed hooks.json shape", () => {
         const config = buildManagedCodexHooksConfig("/tmp/omx");
@@ -26,6 +49,10 @@ describe("codex native hook config", () => {
         const preToolUse = config.hooks.PreToolUse[0];
         assert.equal(preToolUse.matcher, "Bash");
         assert.match(String(preToolUse.hooks?.[0]?.command || ""), /codex-native-hook\.js"?$/);
+        const postToolUse = config.hooks.PostToolUse[0];
+        assert.equal(postToolUse.matcher, undefined);
+        assert.match(String(postToolUse.hooks?.[0]?.command || ""), /codex-native-hook\.js"?$/);
+        assert.equal(postToolUse.hooks?.[0]?.statusMessage, "Running OMX tool review");
         const stop = config.hooks.Stop[0];
         assert.equal(stop.hooks?.[0]?.timeout, 30);
     });
@@ -158,6 +185,118 @@ describe("codex native hook dispatch", () => {
             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 {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-unknown-1",
+                thread_id: "thread-unknown-1",
+                turn_id: "turn-unknown-1",
+                prompt: "$maer-thinking 다시 설명해봐",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState, null);
+            assert.equal(result.outputJson, null);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "skill-active-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("nudges $team prompt-submit routing toward omx team runtime usage", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-team-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-team-1",
+                thread_id: "thread-team-1",
+                turn_id: "turn-team-1",
+                prompt: "$team ship this fix with verification",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "team");
+            assert.match(JSON.stringify(result.outputJson), /skill: team activated and initial state initialized at \.omx\/state\/team-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.match(JSON.stringify(result.outputJson), /Use the durable OMX team runtime via `omx team \.\.\.`/);
+            assert.match(JSON.stringify(result.outputJson), /If you need help, run `omx team --help`\./);
+            const state = JSON.parse(await readFile(join(cwd, ".omx", "state", "team-state.json"), "utf-8"));
+            assert.equal(state.mode, "team");
+            assert.equal(state.active, true);
+            assert.equal(state.current_phase, "starting");
+        }
+        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;
+        const originalTmuxPane = process.env.TMUX_PANE;
+        const originalPath = process.env.PATH;
+        const originalArgv = process.argv;
+        try {
+            process.env.TMUX = "1";
+            process.env.TMUX_PANE = "%1";
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "hud-config.json"), JSON.stringify({ preset: "focused", git: { display: "branch" } }, null, 2));
+            const binDir = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-reconcile-bin-"));
+            const tmuxLog = join(cwd, "tmux.log");
+            await writeFile(join(binDir, "tmux"), `#!/usr/bin/env bash
+set -euo pipefail
+printf '%s\\n' "$*" >> ${JSON.stringify(tmuxLog)}
+case "$1" in
+  list-panes)
+    printf '%%1\\tcodex\\tcodex\\n'
+    ;;
+  display-message)
+    printf '80\\t24\\n'
+    ;;
+  split-window)
+    printf '%%9\\n'
+    ;;
+  resize-pane)
+    ;;
+esac
+`);
+            await chmod(join(binDir, "tmux"), 0o755);
+            process.env.PATH = `${binDir}:${originalPath}`;
+            process.argv = [originalArgv[0] || 'node', '/tmp/codex-host-binary'];
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-hud-1",
+                prompt: "$ralplan prepare plan",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            const tmuxCalls = await readFile(tmuxLog, "utf-8");
+            assert.match(tmuxCalls, /list-panes/);
+            assert.match(tmuxCalls, /split-window/);
+            assert.match(tmuxCalls, /resize-pane -t %9 -y 3/);
+            assert.match(tmuxCalls, /dist\/cli\/omx\.js' hud --watch --preset=focused/);
+            assert.doesNotMatch(tmuxCalls, /\/tmp\/codex-host-binary' hud --watch/);
+        }
+        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;
+            }
+            process.env.PATH = originalPath;
+            process.argv = originalArgv;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("returns a destructive-command caution on PreToolUse for rm -rf dist", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-danger-"));
         try {
@@ -222,6 +361,81 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("returns PostToolUse MCP transport fallback guidance for clear MCP transport death", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-mcp-transport-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "mcp__omx_state__state_write",
+                tool_use_id: "tool-mcp-transport",
+                tool_input: { mode: "team", active: true },
+                tool_response: "{\"error\":\"MCP transport closed\",\"details\":\"stdio pipe closed before response\"}",
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            const output = result.outputJson;
+            assert.equal(output?.decision, "block");
+            assert.equal(output?.reason, "The MCP tool appears to have lost its transport/server connection. Preserve state, debug the transport failure, and use OMX CLI/file-backed fallbacks instead of retrying blindly.");
+            const additionalContext = String(output?.hookSpecificOutput?.additionalContext ?? "");
+            assert.match(additionalContext, /omx state state_write --input/);
+            assert.match(additionalContext, /plain Node stdio processes/i);
+            assert.match(additionalContext, /read-stall-state/);
+            assert.match(additionalContext, /OMX_MCP_TRANSPORT_DEBUG=1/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not classify non-transport MCP failures as transport death", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-mcp-nontransport-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "mcp__omx_state__state_write",
+                tool_use_id: "tool-mcp-nontransport",
+                tool_input: { active: true },
+                tool_response: "{\"error\":\"validation failed\",\"details\":\"mode is required\"}",
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("marks active team state failed on MCP transport death without deleting team state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-team-mcp-transport-"));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(cwd);
+            await initTeamState("transport-team", "task", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-transport" });
+            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: "sess-transport",
+                tool_name: "mcp__omx_state__state_write",
+                tool_use_id: "tool-mcp-transport-team",
+                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(existsSync(join(cwd, ".omx", "state", "team", "transport-team")), true);
+        }
+        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 {
@@ -272,6 +486,39 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("returns MCP transport-death guidance and preserves failed team state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-mcp-dead-"));
+        try {
+            await initTeamState("mcp-transport-dead-team", "transport failure fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-mcp-dead" });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                session_id: "sess-mcp-dead",
+                tool_name: "mcp__omx_state__state_write",
+                tool_use_id: "tool-mcp-dead",
+                tool_response: JSON.stringify({
+                    error: "transport closed",
+                    message: "MCP server disconnected",
+                }),
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.reason || ""), /lost its transport\/server connection/);
+            const hookSpecificOutput = result.outputJson?.hookSpecificOutput;
+            assert.equal(hookSpecificOutput?.hookEventName, "PostToolUse");
+            assert.match(String(hookSpecificOutput?.additionalContext || ""), /Retry via CLI parity with `omx state state_write --input '\{\}' --json`\./);
+            assert.match(String(hookSpecificOutput?.additionalContext || ""), /omx team api read-stall-state/);
+            const phase = JSON.parse(await readFile(join(cwd, ".omx", "state", "team", "mcp-transport-dead-team", "phase.json"), "utf-8"));
+            assert.equal(phase.current_phase, "failed");
+            assert.equal(phase.transitions?.at(-1)?.reason, "mcp_transport_dead");
+            const attention = JSON.parse(await readFile(join(cwd, ".omx", "state", "team", "mcp-transport-dead-team", "leader-attention.json"), "utf-8"));
+            assert.equal(attention.leader_attention_reason, "mcp_transport_dead");
+            assert.ok(attention.attention_reasons?.includes("mcp_transport_dead"));
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("stays silent on neutral successful PostToolUse output", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-neutral-"));
         try {
@@ -290,6 +537,45 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("returns CLI fallback guidance and preserves failed team state on clear MCP transport death", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-mcp-transport-"));
+        try {
+            await initTeamState("transport-team", "transport failure fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-mcp-transport" });
+            await writeJson(join(cwd, ".omx", "state", "team-state.json"), {
+                active: true,
+                team_name: "transport-team",
+                current_phase: "team-exec",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                session_id: "sess-stop-mcp-transport",
+                tool_name: "mcp__omx_state__state_write",
+                tool_use_id: "tool-mcp-fail",
+                tool_input: { mode: "team", active: true },
+                tool_response: JSON.stringify({
+                    error: "MCP transport closed unexpectedly",
+                    exit_code: 1,
+                }),
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: "The MCP tool appears to have lost its transport/server connection. Preserve state, debug the transport failure, and use OMX CLI/file-backed fallbacks instead of retrying blindly.",
+                hookSpecificOutput: {
+                    hookEventName: "PostToolUse",
+                    additionalContext: "Clear MCP transport-death signal detected. Preserve current team/runtime state. Retry via CLI parity with `omx state state_write --input '{\"mode\":\"team\",\"active\":true}' --json`. OMX MCP servers are plain Node stdio processes, so they still shut down when stdin/transport closes. If this happened during team runtime, inspect first with `omx team status <team>` or `omx team api read-stall-state --input '{\"team_name\":\"<team>\"}' --json`, and only force cleanup after capturing needed state. For root-cause debugging, rerun with `OMX_MCP_TRANSPORT_DEBUG=1` to log why the stdio transport closed.",
+                },
+            });
+            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");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("returns Stop continuation output while Autopilot is active", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-autopilot-"));
         try {
@@ -650,7 +936,7 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("returns Stop continuation output for active ralplan skill without active subagents", async () => {
+    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 {
             const stateDir = join(cwd, ".omx", "state");
@@ -661,6 +947,10 @@ describe("codex native hook dispatch", () => {
                 skill: "ralplan",
                 phase: "planning",
             });
+            await writeJson(join(stateDir, "sessions", "sess-stop-skill", "ralplan-state.json"), {
+                active: true,
+                current_phase: "planning",
+            });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
@@ -678,6 +968,36 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not block on stale ralplan skill-active state when the matching mode state is absent", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-stale-skill-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-stop-stale-skill"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-stop-stale-skill" });
+            await writeJson(join(stateDir, "sessions", "sess-stop-stale-skill", "skill-active-state.json"), {
+                active: true,
+                skill: "ralplan",
+                phase: "planning",
+                session_id: "sess-stop-stale-skill",
+                active_skills: [{
+                        skill: "ralplan",
+                        phase: "planning",
+                        active: true,
+                        session_id: "sess-stop-stale-skill",
+                    }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-stale-skill",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("does not block on active ralplan skill when subagents are still active", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-skill-subagent-"));
         try {
@@ -689,6 +1009,10 @@ describe("codex native hook dispatch", () => {
                 skill: "ralplan",
                 phase: "planning",
             });
+            await writeJson(join(stateDir, "sessions", "sess-stop-skill-subagent", "ralplan-state.json"), {
+                active: true,
+                current_phase: "planning",
+            });
             await writeJson(join(stateDir, "subagent-tracking.json"), {
                 schemaVersion: 1,
                 sessions: {
@@ -727,7 +1051,30 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("returns Stop continuation output for active deep-interview skill without active subagents", async () => {
+    it("does not block on stale root ralplan skill when the explicit session-scoped canonical skill state is absent", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-stale-root-skill-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(stateDir, { recursive: true });
+            await writeJson(join(stateDir, "skill-active-state.json"), {
+                active: true,
+                skill: "ralplan",
+                phase: "planning",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-stale-root-skill",
+                thread_id: "thread-stop-stale-root-skill",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            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 () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-deep-interview-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
@@ -738,6 +1085,10 @@ describe("codex native hook dispatch", () => {
                 skill: "deep-interview",
                 phase: "planning",
             });
+            await writeJson(join(stateDir, "sessions", "sess-stop-deep-interview", "deep-interview-state.json"), {
+                active: true,
+                current_phase: "planning",
+            });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
@@ -804,6 +1155,30 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not block Stop from stale session-scoped Ralph state that belongs to another session", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-stale-session-ralph-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await mkdir(join(stateDir, "sessions", "sess-stale"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "sessions", "sess-stale", "ralph-state.json"), {
+                active: true,
+                current_phase: "starting",
+                session_id: "sess-stale",
+            });
+            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 {
@@ -930,6 +1305,10 @@ describe("codex native hook dispatch", () => {
                     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"), {
+                active: true,
+                current_phase: "planning",
+            });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
@@ -977,7 +1356,7 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("suppresses native auto-nudge when deep-interview mode state is active without a scoped skill state", async () => {
+    it("suppresses native auto-nudge when root deep-interview mode state is active without an explicit session", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-deep-interview-mode-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
@@ -990,8 +1369,6 @@ describe("codex native hook dispatch", () => {
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
-                session_id: "sess-stop-auto-mode",
-                thread_id: "thread-stop-auto-mode",
                 turn_id: "turn-stop-auto-mode-1",
                 last_assistant_message: "Would you like me to continue with the next step?",
             }, { cwd });
@@ -1002,6 +1379,102 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not suppress native auto-nudge from stale root deep-interview mode state when the explicit session-scoped mode state is absent", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-stale-root-mode-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(stateDir, { recursive: true });
+            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-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?",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: "yes, proceed",
+                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 stale root deep-interview skill state when the explicit session-scoped canonical skill state is absent", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-stale-root-skill-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(stateDir, { recursive: true });
+            await writeJson(join(stateDir, "skill-active-state.json"), {
+                active: true,
+                skill: "deep-interview",
+                phase: "planning",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                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?",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: "yes, proceed",
+                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 stale root deep-interview input lock when the explicit session-scoped canonical skill state is absent", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-stale-root-lock-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(stateDir, { recursive: true });
+            await writeJson(join(stateDir, "skill-active-state.json"), {
+                active: true,
+                skill: "deep-interview",
+                phase: "planning",
+                input_lock: {
+                    active: true,
+                    scope: "deep-interview-auto-approval",
+                    blocked_inputs: ["yes", "proceed"],
+                    message: "Deep interview is active; auto-approval shortcuts are blocked until the interview finishes.",
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                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?",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: "yes, proceed",
+                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("re-fires team Stop output for a later fresh Stop reply while the team is still active", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-refire-"));
         try {