oh-my-codex 0.12.2 → 0.12.4

package/src/scripts/__tests__/codex-native-hook.test.ts

@@ -1,12 +1,16 @@
 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,
@@ -21,6 +25,31 @@ async function writeJson(path: string, value: unknown): Promise<void> {
 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",
+] as const;
+
+const priorTeamEnv = new Map<(typeof TEAM_ENV_KEYS)[number], string | undefined>();
+
+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");
@@ -42,6 +71,17 @@ describe("codex native hook config", () => {
       /codex-native-hook\.js"?$/,
     );
 
+    const postToolUse = config.hooks.PostToolUse[0] as {
+      matcher?: string;
+      hooks?: Array<Record<string, unknown>>;
+    };
+    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] as {
       hooks?: Array<Record<string, unknown>>;
     };
@@ -210,6 +250,142 @@ describe("codex native hook dispatch", () => {
     }
   });
 
+  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"),
+      ) as { mode?: string; active?: boolean; current_phase?: string };
+      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 {
@@ -288,6 +464,123 @@ describe("codex native hook dispatch", () => {
     }
   });
 
+  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 as {
+        decision?: string;
+        reason?: string;
+        hookSpecificOutput?: { additionalContext?: string };
+      } | null;
+      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 {
@@ -348,6 +641,67 @@ describe("codex native hook dispatch", () => {
     }
   });
 
+  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 as {
+        hookEventName?: string;
+        additionalContext?: string;
+      } | undefined;
+      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"),
+      ) as { current_phase?: string; transitions?: Array<{ reason?: string }> };
+      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"),
+      ) as { leader_attention_reason?: string; attention_reasons?: string[] };
+      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 {
@@ -370,6 +724,60 @@ describe("codex native hook dispatch", () => {
     }
   });
 
+  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 {
@@ -857,7 +1265,7 @@ describe("codex native hook dispatch", () => {
     }
   });
 
-  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");
@@ -868,6 +1276,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(
         {
@@ -891,6 +1303,41 @@ describe("codex native hook dispatch", () => {
     }
   });
 
+  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 {
@@ -902,6 +1349,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: {
@@ -945,7 +1396,35 @@ describe("codex native hook dispatch", () => {
     }
   });
 
-  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");
@@ -956,6 +1435,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(
         {
@@ -1043,6 +1526,35 @@ describe("codex native hook dispatch", () => {
     }
   });
 
+  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 {
@@ -1202,6 +1714,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(
         {
@@ -1260,7 +1776,7 @@ describe("codex native hook dispatch", () => {
     }
   });
 
-  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");
@@ -1275,8 +1791,6 @@ describe("codex native hook dispatch", () => {
         {
           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?",
         },
@@ -1290,6 +1804,120 @@ describe("codex native hook dispatch", () => {
     }
   });
 
+  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 {