oh-my-codex 0.15.0 → 0.15.2

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

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -12,6 +12,7 @@ import { initTeamState, readTeamLeaderAttention, readTeamPhase, writeTeamLeaderA
 import { dispatchCodexNativeHook, isCodexNativeHookMainModule, mapCodexHookEventToOmxEvent, resolveSessionOwnerPidFromAncestry, } from "../codex-native-hook.js";
 import { writeSessionStart } from "../../hooks/session.js";
 import { resetTriageConfigCache } from "../../hooks/triage-config.js";
+import { executeStateOperation } from "../../state/operations.js";
 function nativeHookScriptPath() {
     return join(process.cwd(), "dist", "scripts", "codex-native-hook.js");
 }
@@ -163,6 +164,46 @@ describe("codex native hook dispatch", () => {
         assert.equal(output.hookSpecificOutput?.hookEventName, "Unknown");
         assert.match(String(output.hookSpecificOutput?.additionalContext ?? ""), /stdin JSON parsing failed inside codex-native-hook:/);
     });
+    it("emits parseable no-op JSON stdout for inactive Stop CLI runs", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-stop-noop-json-"));
+        try {
+            const stdout = runNativeHookCli({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-cli-stop-noop-json",
+                thread_id: "thread-cli-stop-noop-json",
+                turn_id: "turn-cli-stop-noop-json",
+            }, { cwd });
+            const output = parseSingleJsonStdout(stdout);
+            assert.deepEqual(output, {});
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not crash Stop hook dispatch when the exec follow-up queue is malformed", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-stop-exec-followup-corrupt-"));
+        try {
+            const session = await writeSessionStart(cwd, "sess-exec-followup-corrupt");
+            const queuePath = join(cwd, ".omx", "state", "sessions", session.session_id, "exec-followups.json");
+            await mkdir(dirname(queuePath), { recursive: true });
+            await writeFile(queuePath, '{"version":1,"records":[', "utf-8");
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: session.session_id,
+            });
+            assert.equal(result.hookEventName, "Stop");
+            assert.equal(result.outputJson, null);
+            const queueDirEntries = await readdir(dirname(queuePath));
+            assert.ok(queueDirEntries.some((entry) => entry.startsWith("exec-followups.json.corrupt-")));
+            const auditPath = join(cwd, ".omx", "logs", `exec-followups-${new Date().toISOString().slice(0, 10)}.jsonl`);
+            assert.match(await readFile(auditPath, "utf-8"), /exec_followup_queue_corrupt_recovered/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("emits exactly one parseable JSON object for active Stop CLI continuation", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-stop-json-"));
         try {
@@ -309,6 +350,127 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("keeps subagent SessionStart from replacing the canonical leader session", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-subagent-session-start-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "omx-leader-session";
+            const leaderNativeSessionId = "codex-leader-thread";
+            const childNativeSessionId = "codex-child-thread";
+            await mkdir(join(stateDir, "sessions", canonicalSessionId), { recursive: true });
+            await writeSessionStart(cwd, canonicalSessionId, {
+                nativeSessionId: leaderNativeSessionId,
+            });
+            await writeJson(join(stateDir, "sessions", canonicalSessionId, "ralph-state.json"), {
+                active: true,
+                mode: "ralph",
+                current_phase: "executing",
+                iteration: 1,
+                max_iterations: 5,
+            });
+            const transcriptPath = join(cwd, "subagent-rollout.jsonl");
+            await writeFile(transcriptPath, `${JSON.stringify({
+                type: "session_meta",
+                payload: {
+                    id: childNativeSessionId,
+                    source: {
+                        subagent: {
+                            thread_spawn: {
+                                parent_thread_id: leaderNativeSessionId,
+                                depth: 1,
+                                agent_nickname: "Hegel",
+                                agent_role: "critic",
+                            },
+                        },
+                    },
+                    agent_nickname: "Hegel",
+                    agent_role: "critic",
+                },
+            })}\n`);
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: childNativeSessionId,
+                transcript_path: transcriptPath,
+            }, { 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, leaderNativeSessionId);
+            assert.equal(existsSync(join(stateDir, "sessions", childNativeSessionId, "ralph-state.json")), false);
+            assert.ok(result.outputJson);
+            const leaderRalph = JSON.parse(await readFile(join(stateDir, "sessions", canonicalSessionId, "ralph-state.json"), "utf-8"));
+            assert.equal(leaderRalph.active, true);
+            assert.equal(leaderRalph.current_phase, "executing");
+            const tracking = JSON.parse(await readFile(join(stateDir, "subagent-tracking.json"), "utf-8"));
+            assert.equal(tracking.sessions?.[canonicalSessionId]?.leader_thread_id, leaderNativeSessionId);
+            assert.equal(tracking.sessions?.[canonicalSessionId]?.threads?.[childNativeSessionId]?.kind, "subagent");
+            assert.equal(tracking.sessions?.[canonicalSessionId]?.threads?.[childNativeSessionId]?.mode, "critic");
+            assert.equal(tracking.sessions?.[leaderNativeSessionId]?.leader_thread_id, leaderNativeSessionId);
+            assert.equal(tracking.sessions?.[leaderNativeSessionId]?.threads?.[childNativeSessionId]?.kind, "subagent");
+            assert.equal(tracking.sessions?.[leaderNativeSessionId]?.threads?.[childNativeSessionId]?.mode, "critic");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not attach a subagent SessionStart to an unrelated canonical leader", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-subagent-session-start-mismatch-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "omx-leader-session-a";
+            const leaderNativeSessionId = "codex-leader-thread-a";
+            const unrelatedParentNativeSessionId = "codex-leader-thread-b";
+            const childNativeSessionId = "codex-child-thread-b";
+            await mkdir(join(stateDir, "sessions", canonicalSessionId), { recursive: true });
+            await writeSessionStart(cwd, canonicalSessionId, {
+                nativeSessionId: leaderNativeSessionId,
+            });
+            await writeJson(join(stateDir, "sessions", canonicalSessionId, "ralph-state.json"), {
+                active: true,
+                mode: "ralph",
+                current_phase: "executing",
+                iteration: 1,
+                max_iterations: 5,
+            });
+            const transcriptPath = join(cwd, "unrelated-subagent-rollout.jsonl");
+            await writeFile(transcriptPath, `${JSON.stringify({
+                type: "session_meta",
+                payload: {
+                    id: childNativeSessionId,
+                    source: {
+                        subagent: {
+                            thread_spawn: {
+                                parent_thread_id: unrelatedParentNativeSessionId,
+                                depth: 1,
+                                agent_nickname: "Spinoza",
+                                agent_role: "critic",
+                            },
+                        },
+                    },
+                    agent_nickname: "Spinoza",
+                    agent_role: "critic",
+                },
+            })}\n`);
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: childNativeSessionId,
+                transcript_path: transcriptPath,
+            }, { 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, leaderNativeSessionId);
+            assert.equal(existsSync(join(stateDir, "subagent-tracking.json")), false);
+            assert.equal(existsSync(join(stateDir, "sessions", childNativeSessionId)), false);
+            assert.equal(result.outputJson, null);
+            const leaderRalph = JSON.parse(await readFile(join(stateDir, "sessions", canonicalSessionId, "ralph-state.json"), "utf-8"));
+            assert.equal(leaderRalph.active, true);
+            assert.equal(leaderRalph.current_phase, "executing");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("describes attached tmux runtime in SessionStart context when TMUX is present", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-start-tmux-"));
         process.env.TMUX = "/tmp/tmux-attached";
@@ -326,7 +488,7 @@ describe("codex native hook dispatch", () => {
             assert.match(additionalContext, /\[Execution environment\]/);
             assert.match(additionalContext, /attached tmux runtime/);
             assert.match(additionalContext, /omx team, omx hud, and omx quest(?:ion) are directly usable in this session/);
-            assert.match(additionalContext, /visible renderer available from the current pane/);
+            assert.match(additionalContext, /visible temporary renderer available from the current pane; primary success JSON is answers\[\]/);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -1771,7 +1933,7 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("blocks PreToolUse git commit when the inline message is not Lore-compliant", async () => {
+    it("blocks PreToolUse git commit with supported response shape when the inline message is not Lore-compliant", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-invalid-"));
         try {
             const result = await dispatchCodexNativeHook({
@@ -1787,13 +1949,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -1803,6 +1958,9 @@ esac
                     "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
                 ].join("\n"),
             });
+            const hookSpecificOutput = result.outputJson
+                .hookSpecificOutput ?? {};
+            assert.equal("additionalContext" in hookSpecificOutput, false);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -1875,13 +2033,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -1912,13 +2063,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -1949,13 +2093,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -1986,13 +2123,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -2023,13 +2153,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -2060,13 +2183,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -2097,13 +2213,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -2134,13 +2243,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -2171,13 +2273,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add a blank line after the subject before the narrative body.",
-                        "- Add a narrative body paragraph explaining the decision context.",
-                        "- Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -2208,10 +2303,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Use inline `git commit -m ...` paragraphs for Lore-format commits in this path; file/editor/reuse/fixup message sources are not inspectable safely from pre-tool-use enforcement.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -2247,10 +2338,6 @@ esac
                 reason: "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
-                    additionalContext: [
-                        "Lore-format git commit enforcement triggered.",
-                        "- Add the required co-author trailer: `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
-                    ].join("\n"),
                 },
                 systemMessage: [
                     "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -2489,6 +2576,24 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("stays silent when Bash stdout only contains failure-like source text", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-failure-source-text-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-source-text",
+                tool_input: { command: "sed -n '1,40p' hook-source.ts" },
+                tool_response: "const text = 'bash: foo: command not found';\nconst detail = 'permission denied';",
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("stays silent for rc-zero build logs that mention missing grep paths", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-build-log-"));
         try {
@@ -2511,6 +2616,28 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not treat Bash output containing MCP transport text as MCP transport death", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-mcp-source-text-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-mcp-source-text",
+                tool_input: { command: "sed -n '580,620p' codex-native-pre-post.ts" },
+                tool_response: JSON.stringify({
+                    exit_code: 0,
+                    stdout: "reason: 'MCP transport closed before response over stdio pipe closed'",
+                    stderr: "",
+                }),
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("stays silent when successful output includes prior hook context text", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-recursive-context-"));
         try {
@@ -2533,6 +2660,46 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("stays silent when successful Bash output quotes MCP transport warnings", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-bash-mcp-quote-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-bash-mcp-quote",
+                tool_input: { command: "cat diagnostic-log.txt" },
+                tool_response: JSON.stringify({
+                    exit_code: 0,
+                    stdout: "diagnostic log quoted: MCP transport closed; stdio pipe closed before response",
+                    stderr: "",
+                }),
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("stays silent when Bash hard-failure text has no parsed exit code", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-posttool-bash-unparsed-failure-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-bash-unparsed-failure",
+                tool_input: { command: "cat captured-output.txt" },
+                tool_response: "captured transcript says: bash: foo: command not found",
+            }, { cwd });
+            assert.equal(result.omxEventName, "post-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            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 {
@@ -2979,7 +3146,17 @@ esac
         const prevLeaderCwd = process.env.OMX_TEAM_LEADER_CWD;
         try {
             await initTeamState("worker-stop-team", "worker stop fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-worker" });
+            const workerCwd = join(cwd, ".omx", "team", "worker-stop-team", "worktrees", "worker-1");
             const workerDir = join(cwd, ".omx", "state", "team", "worker-stop-team", "workers", "worker-1");
+            await mkdir(workerCwd, { recursive: true });
+            await writeJson(join(workerDir, "identity.json"), {
+                name: "worker-1",
+                index: 1,
+                role: "executor",
+                assigned_tasks: ["1"],
+                worktree_path: workerCwd,
+                team_state_root: join(cwd, ".omx", "state"),
+            });
             await writeJson(join(workerDir, "status.json"), {
                 state: "idle",
                 current_task_id: "1",
@@ -2998,9 +3175,9 @@ esac
             process.env.OMX_TEAM_LEADER_CWD = cwd;
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
-                cwd: join(cwd, ".omx", "team", "worker-stop-team", "worktrees", "worker-1"),
+                cwd: workerCwd,
                 session_id: "sess-stop-team-worker",
-            }, { cwd: join(cwd, ".omx", "team", "worker-stop-team", "worktrees", "worker-1") });
+            }, { cwd: workerCwd });
             assert.deepEqual(result.outputJson, {
                 decision: "block",
                 reason: "OMX team worker worker-1 is still assigned non-terminal task 1 (in_progress); continue the current assigned task or report a concrete blocker before stopping.",
@@ -3031,6 +3208,16 @@ esac
             const stateDir = join(cwd, ".omx", "state");
             const workerDir = join(stateDir, "team", "worker-repeat-team", "workers", "worker-1");
             const taskPath = join(stateDir, "team", "worker-repeat-team", "tasks", "task-1.json");
+            const workerCwd = join(cwd, ".omx", "team", "worker-repeat-team", "worktrees", "worker-1");
+            await mkdir(workerCwd, { recursive: true });
+            await writeJson(join(workerDir, "identity.json"), {
+                name: "worker-1",
+                index: 1,
+                role: "executor",
+                assigned_tasks: ["1"],
+                worktree_path: workerCwd,
+                team_state_root: stateDir,
+            });
             await writeJson(join(workerDir, "status.json"), {
                 state: "idle",
                 current_task_id: "1",
@@ -3047,7 +3234,6 @@ esac
             process.env.OMX_TEAM_WORKER = "worker-repeat-team/worker-1";
             process.env.OMX_TEAM_STATE_ROOT = stateDir;
             process.env.OMX_TEAM_LEADER_CWD = cwd;
-            const workerCwd = join(cwd, ".omx", "team", "worker-repeat-team", "worktrees", "worker-1");
             const basePayload = {
                 hook_event_name: "Stop",
                 cwd: workerCwd,
@@ -3207,6 +3393,38 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("honors terminal team run-state before later canonical-team Stop fallback", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-terminal-run-state-canonical-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-stop-team-terminal-run-state";
+            await initTeamState("terminal-run-state-team", "terminal team stop canonical fallback regression", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: sessionId });
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId, cwd });
+            await writeJson(join(stateDir, "sessions", sessionId, "run-state.json"), {
+                version: 1,
+                mode: "team",
+                active: false,
+                outcome: "finish",
+                lifecycle_outcome: "finished",
+                current_phase: "complete",
+                completed_at: "2026-04-27T12:00:00.000Z",
+                updated_at: "2026-04-27T12:00:00.000Z",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-stop-team-terminal-run-state",
+                turn_id: "turn-stop-team-terminal-run-state-1",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        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 {
@@ -3679,7 +3897,7 @@ esac
                 decision: "block",
                 reason: "Deep interview is still active (phase: intent-first) and has a pending structured question obligation; use `omx question` before stopping.",
                 stopReason: "deep_interview_question_required",
-                systemMessage: "OMX deep-interview is still active (phase: intent-first) and requires a structured question via omx question before stopping.",
+                systemMessage: "OMX deep-interview is still active (phase: intent-first) and requires a structured question via omx question before stopping; read the returned answers[] JSON before continuing.",
             });
         }
         finally {
@@ -3728,7 +3946,7 @@ esac
                 decision: "block",
                 reason: "Deep interview is still active (phase: intent-first) and has a pending structured question obligation; use `omx question` before stopping.",
                 stopReason: "deep_interview_question_required",
-                systemMessage: "OMX deep-interview is still active (phase: intent-first) and requires a structured question via omx question before stopping.",
+                systemMessage: "OMX deep-interview is still active (phase: intent-first) and requires a structured question via omx question before stopping; read the returned answers[] JSON before continuing.",
             });
         }
         finally {
@@ -3841,7 +4059,7 @@ esac
                 decision: "block",
                 reason: "Deep interview is still active (phase: intent-first) and has a pending structured question obligation; use `omx question` before stopping.",
                 stopReason: "deep_interview_question_required",
-                systemMessage: "OMX deep-interview is still active (phase: intent-first) and requires a structured question via omx question before stopping.",
+                systemMessage: "OMX deep-interview is still active (phase: intent-first) and requires a structured question via omx question before stopping; read the returned answers[] JSON before continuing.",
             };
             const first = await dispatchCodexNativeHook(payload, { cwd });
             const replay = await dispatchCodexNativeHook({ ...payload, stop_hook_active: true }, { cwd });
@@ -3968,7 +4186,7 @@ esac
                 decision: "block",
                 reason: "Deep interview is still active (phase: intent-first) and has a pending structured question obligation; use `omx question` before stopping.",
                 stopReason: "deep_interview_question_required",
-                systemMessage: "OMX deep-interview is still active (phase: intent-first) and requires a structured question via omx question before stopping.",
+                systemMessage: "OMX deep-interview is still active (phase: intent-first) and requires a structured question via omx question before stopping; read the returned answers[] JSON before continuing.",
             });
         }
         finally {
@@ -4114,9 +4332,9 @@ esac
             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.",
+                reason: "OMX Ralph is still active (phase: executing; state: .omx/state/ralph-state.json); 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.",
+                systemMessage: "OMX Ralph is still active (phase: executing; state: .omx/state/ralph-state.json); continue the task and gather fresh verification evidence before stopping.",
             });
         }
         finally {
@@ -4142,9 +4360,9 @@ esac
             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.",
+                reason: "OMX Ralph is still active (phase: executing; state: .omx/state/sessions/sess-live-ralph/ralph-state.json); 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.",
+                systemMessage: "OMX Ralph is still active (phase: executing; state: .omx/state/sessions/sess-live-ralph/ralph-state.json); continue the task and gather fresh verification evidence before stopping.",
             });
         }
         finally {
@@ -4219,6 +4437,74 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not hard-block Stop on stale session-scoped Ralph starting state after visible active modes are cleared", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-cleared-stale-ralph-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-cleared-ralph";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "sessions", sessionId, "ralph-state.json"), {
+                active: true,
+                mode: "ralph",
+                current_phase: "starting",
+                session_id: sessionId,
+            });
+            await writeJson(join(stateDir, "skill-active-state.json"), {
+                active: false,
+                skill: "ralph",
+                active_skills: [],
+            });
+            const listActive = await executeStateOperation("state_list_active", {
+                workingDirectory: cwd,
+            });
+            assert.deepEqual(listActive.payload, { active_modes: [] });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks Stop on visible active session-scoped Ralph starting state and reports its path", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-visible-starting-ralph-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-visible-ralph";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "sessions", sessionId, "ralph-state.json"), {
+                active: true,
+                mode: "ralph",
+                current_phase: "starting",
+                session_id: sessionId,
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+                active: true,
+                skill: "ralph",
+                phase: "starting",
+                active_skills: [{ skill: "ralph", phase: "starting", active: true, session_id: sessionId }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: "OMX Ralph is still active (phase: starting; state: .omx/state/sessions/sess-visible-ralph/ralph-state.json); continue the task and gather fresh verification evidence before stopping.",
+                stopReason: "ralph_starting",
+                systemMessage: "OMX Ralph is still active (phase: starting; state: .omx/state/sessions/sess-visible-ralph/ralph-state.json); continue the task and gather fresh verification evidence before stopping.",
+            });
+        }
+        finally {
+            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 {
@@ -4241,6 +4527,41 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("prefers canonical run-state terminal lifecycle before stale session Ralph state during Stop", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-canonical-run-state-ralph-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-canonical-run-state-ralph";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: sessionId, cwd });
+            await writeJson(join(stateDir, "sessions", sessionId, "run-state.json"), {
+                version: 1,
+                mode: "ralph",
+                active: false,
+                outcome: "finish",
+                lifecycle_outcome: "finished",
+                current_phase: "complete",
+                completed_at: "2026-04-27T12:00:00.000Z",
+                updated_at: "2026-04-27T12:00:00.000Z",
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "ralph-state.json"), {
+                active: true,
+                mode: "ralph",
+                current_phase: "verifying",
+                session_id: sessionId,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+            }, { 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 {
@@ -4334,9 +4655,9 @@ esac
             };
             const expected = {
                 decision: "block",
-                reason: "OMX Ralph is still active (phase: executing); continue the task and gather fresh verification evidence before stopping.",
+                reason: "OMX Ralph is still active (phase: executing; state: .omx/state/ralph-state.json); 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.",
+                systemMessage: "OMX Ralph is still active (phase: executing; state: .omx/state/ralph-state.json); continue the task and gather fresh verification evidence before stopping.",
             };
             const first = await dispatchCodexNativeHook(payload, { cwd });
             const replay = await dispatchCodexNativeHook({