oh-my-codex 0.13.1 → 0.13.2

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

@@ -338,6 +338,29 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not activate Ralph workflow state from a plain conversational mention", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralph-plain-text-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-ralph-plain-text",
+                thread_id: "thread-ralph-plain-text",
+                turn_id: "turn-ralph-plain-text",
+                prompt: "why does ralph keep blocking stop?",
+            }, { 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);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-ralph-plain-text", "skill-active-state.json")), false);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-ralph-plain-text", "ralph-state.json")), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("clarifies that prompt-side $ralph activation does not invoke the PRD-gated CLI path", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralph-routing-"));
         try {
@@ -1649,7 +1672,12 @@ esac
                 cwd,
                 session_id: "sess-stop-team-worker-terminal",
             }, { cwd });
-            assert.equal(result.outputJson, null);
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (worker-stop-team-terminal) 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 {
             if (typeof prevTeamWorker === "string")
@@ -2278,8 +2306,9 @@ esac
             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-"));
+    it("keeps blocking Ralph Stop replays until the active task advances", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-ralph-replay-"));
+        const previousOmxSessionId = process.env.OMX_SESSION_ID;
         try {
             const stateDir = join(cwd, ".omx", "state");
             await mkdir(stateDir, { recursive: true });
@@ -2287,16 +2316,33 @@ esac
                 active: true,
                 current_phase: "executing",
             }));
-            const result = await dispatchCodexNativeHook({
+            process.env.OMX_SESSION_ID = "sess-stop-ralph-replay";
+            const payload = {
                 hook_event_name: "Stop",
                 cwd,
-                session_id: "sess-stop-ralph-once",
+                last_assistant_message: "Next active targets:\n\n1. scheduler integration\n\nI am continuing.",
+            };
+            const expected = {
+                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.",
+            };
+            const first = await dispatchCodexNativeHook(payload, { cwd });
+            const replay = await dispatchCodexNativeHook({
+                ...payload,
                 stop_hook_active: true,
             }, { cwd });
-            assert.equal(result.omxEventName, "stop");
-            assert.equal(result.outputJson, null);
+            assert.equal(first.omxEventName, "stop");
+            assert.deepEqual(first.outputJson, expected);
+            assert.equal(replay.omxEventName, "stop");
+            assert.deepEqual(replay.outputJson, expected);
         }
         finally {
+            if (typeof previousOmxSessionId === "string")
+                process.env.OMX_SESSION_ID = previousOmxSessionId;
+            else
+                delete process.env.OMX_SESSION_ID;
             await rm(cwd, { recursive: true, force: true });
         }
     });
@@ -2324,7 +2370,7 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("suppresses duplicate native auto-nudge replays for the same Stop reply", async () => {
+    it("re-blocks duplicate native auto-nudge replays for the same Stop reply", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-once-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
@@ -2348,13 +2394,18 @@ esac
                 last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
-            assert.equal(result.outputJson, null);
+            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.",
+            });
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("suppresses duplicate native auto-nudge replays across native/canonical session-id drift", async () => {
+    it("re-blocks duplicate native auto-nudge replays across native/canonical session-id drift", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-session-drift-"));
         try {
             const stateDir = join(cwd, ".omx", "state");
@@ -2382,7 +2433,12 @@ esac
                 last_assistant_message: "Keep going and finish the cleanup.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
-            assert.equal(result.outputJson, null);
+            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.",
+            });
             const persisted = JSON.parse(await readFile(join(stateDir, "native-stop-state.json"), "utf-8"));
             assert.deepEqual(Object.keys(persisted.sessions ?? {}), ["omx-canonical"]);
         }
@@ -2705,7 +2761,7 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("does not auto-continue native Stop for a plain Codex session started outside OMX runtime", async () => {
+    it("auto-continues native Stop for permission-seeking prompts even outside OMX runtime", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-auto-nudge-plain-session-"));
         try {
             await dispatchCodexNativeHook({
@@ -2722,10 +2778,15 @@ esac
                 session_id: "plain-stop-session",
                 thread_id: "plain-thread",
                 turn_id: "plain-turn-1",
-                last_assistant_message: "Keep going and finish the cleanup.",
+                last_assistant_message: "If you want, I can continue with the cleanup from here.",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
-            assert.equal(result.outputJson, null);
+            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.",
+            });
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -2814,7 +2875,12 @@ esac
                 stop_hook_active: true,
             }, { cwd });
             assert.equal(duplicate.omxEventName, "stop");
-            assert.equal(duplicate.outputJson, null);
+            assert.deepEqual(duplicate.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.",
+            });
             const fresh = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
@@ -2837,6 +2903,103 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("re-blocks active execution modes on repeated Stop hooks", async () => {
+        const cases = [
+            {
+                mode: "autopilot",
+                phase: "execution",
+                reason: "OMX autopilot is still active (phase: execution); continue the task and gather fresh verification evidence before stopping.",
+            },
+            {
+                mode: "ultrawork",
+                phase: "executing",
+                reason: "OMX ultrawork is still active (phase: executing); continue the task and gather fresh verification evidence before stopping.",
+            },
+            {
+                mode: "ultraqa",
+                phase: "diagnose",
+                reason: "OMX ultraqa is still active (phase: diagnose); continue the task and gather fresh verification evidence before stopping.",
+            },
+        ];
+        for (const testCase of cases) {
+            const cwd = await mkdtemp(join(tmpdir(), `omx-native-hook-stop-${testCase.mode}-repeat-`));
+            try {
+                const stateDir = join(cwd, ".omx", "state");
+                await mkdir(stateDir, { recursive: true });
+                await writeJson(join(stateDir, `${testCase.mode}-state.json`), {
+                    active: true,
+                    current_phase: testCase.phase,
+                });
+                await dispatchCodexNativeHook({
+                    hook_event_name: "Stop",
+                    cwd,
+                    session_id: `sess-stop-${testCase.mode}-repeat`,
+                    thread_id: `thread-stop-${testCase.mode}-repeat`,
+                    turn_id: `turn-stop-${testCase.mode}-repeat-1`,
+                }, { cwd });
+                const repeated = await dispatchCodexNativeHook({
+                    hook_event_name: "Stop",
+                    cwd,
+                    session_id: `sess-stop-${testCase.mode}-repeat`,
+                    thread_id: `thread-stop-${testCase.mode}-repeat`,
+                    turn_id: `turn-stop-${testCase.mode}-repeat-1`,
+                    stop_hook_active: true,
+                }, { cwd });
+                assert.equal(repeated.omxEventName, "stop");
+                assert.deepEqual(repeated.outputJson, {
+                    decision: "block",
+                    reason: testCase.reason,
+                    stopReason: `${testCase.mode}_${testCase.phase}`,
+                    systemMessage: `OMX ${testCase.mode} is still active (phase: ${testCase.phase}).`,
+                });
+            }
+            finally {
+                await rm(cwd, { recursive: true, force: true });
+            }
+        }
+    });
+    it("re-blocks active ralplan skill state on repeated Stop hooks", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-skill-repeat-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-stop-skill-repeat"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-stop-skill-repeat" });
+            await writeJson(join(stateDir, "sessions", "sess-stop-skill-repeat", "skill-active-state.json"), {
+                active: true,
+                skill: "ralplan",
+                phase: "planning",
+            });
+            await writeJson(join(stateDir, "sessions", "sess-stop-skill-repeat", "ralplan-state.json"), {
+                active: true,
+                current_phase: "planning",
+            });
+            await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-skill-repeat",
+                thread_id: "thread-stop-skill-repeat",
+                turn_id: "turn-stop-skill-repeat-1",
+            }, { cwd });
+            const repeated = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-skill-repeat",
+                thread_id: "thread-stop-skill-repeat",
+                turn_id: "turn-stop-skill-repeat-1",
+                stop_hook_active: true,
+            }, { cwd });
+            assert.equal(repeated.omxEventName, "stop");
+            assert.deepEqual(repeated.outputJson, {
+                decision: "block",
+                reason: "OMX skill ralplan is still active (phase: planning); continue until the current ralplan workflow reaches a terminal state.",
+                stopReason: "skill_ralplan_planning",
+                systemMessage: "OMX skill ralplan is still active (phase: planning).",
+            });
+        }
+        finally {
+            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 {