oh-my-codex 0.16.2 → 0.16.4

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

@@ -14,6 +14,7 @@ import { writeSessionStart } from "../../hooks/session.js";
 import { resetTriageConfigCache } from "../../hooks/triage-config.js";
 import { executeStateOperation } from "../../state/operations.js";
 import { OMX_TMUX_HUD_OWNER_ENV } from "../../hud/reconcile.js";
+import { readAllState } from "../../hud/state.js";
 import { writePage } from "../../wiki/storage.js";
 import { WIKI_SCHEMA_VERSION } from "../../wiki/types.js";
 function nativeHookScriptPath() {
@@ -183,7 +184,7 @@ describe("codex native hook config", () => {
             "Stop",
         ]);
         const sessionStart = config.hooks.SessionStart[0];
-        assert.equal(sessionStart.matcher, "startup|resume");
+        assert.equal(sessionStart.matcher, "startup|resume|clear");
         assert.equal(sessionStart.hooks?.[0]?.statusMessage, undefined);
         const preToolUse = config.hooks.PreToolUse[0];
         assert.equal(preToolUse.matcher, "Bash");
@@ -199,6 +200,10 @@ describe("codex native hook config", () => {
         assert.equal(userPromptSubmit.hooks?.[0]?.statusMessage, undefined);
         const stop = config.hooks.Stop[0];
         assert.equal(stop.hooks?.[0]?.timeout, 30);
+        const postCompact = config.hooks.PostCompact[0];
+        assert.equal(postCompact.matcher, undefined);
+        assert.match(String(postCompact.hooks?.[0]?.command || ""), /codex-native-hook\.js"?$/);
+        assert.doesNotMatch(String(postCompact.hooks?.[0]?.command || ""), /PostCompact Nudge|additionalContext|printf/);
     });
 });
 describe("codex native hook dispatch", () => {
@@ -400,7 +405,7 @@ describe("codex native hook dispatch", () => {
         assert.equal(mapCodexHookEventToOmxEvent("PostCompact"), "post-compact");
         assert.equal(mapCodexHookEventToOmxEvent("Stop"), "stop");
     });
-    it("returns bounded wiki context for PreCompact", async () => {
+    it("does not write PreCompact stdout that Codex rejects as hook JSON", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-precompact-"));
         try {
             writePage(cwd, {
@@ -425,16 +430,42 @@ describe("codex native hook dispatch", () => {
             });
             assert.equal(result.hookEventName, "PreCompact");
             assert.equal(result.omxEventName, "pre-compact");
-            const additionalContext = result.outputJson
-                ?.hookSpecificOutput?.additionalContext ?? "";
-            assert.match(additionalContext, /Wiki: 1 pages/);
-            assert.match(additionalContext, /architecture/);
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("emits no CLI stdout for PreCompact when no Codex action is needed", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-precompact-cli-"));
+        try {
+            writePage(cwd, {
+                filename: "architecture.md",
+                frontmatter: {
+                    title: "Architecture",
+                    tags: ["architecture"],
+                    created: "2026-05-08T00:00:00.000Z",
+                    updated: "2026-05-08T00:00:00.000Z",
+                    sources: [],
+                    links: [],
+                    category: "architecture",
+                    confidence: "high",
+                    schemaVersion: WIKI_SCHEMA_VERSION,
+                },
+                content: "\n# Architecture\n\nCompaction-relevant architecture note.\n",
+            });
+            const stdout = runNativeHookCli({
+                hook_event_name: "PreCompact",
+                cwd,
+                session_id: "sess-precompact-cli",
+            });
+            assert.equal(stdout, "");
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("returns a PostCompact nudge to write compaction artifacts to omx_wiki", async () => {
+    it("does not write PostCompact stdout that Codex rejects as hook JSON", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-postcompact-"));
         try {
             const result = await dispatchCodexNativeHook({
@@ -444,11 +475,21 @@ describe("codex native hook dispatch", () => {
             });
             assert.equal(result.hookEventName, "PostCompact");
             assert.equal(result.omxEventName, "post-compact");
-            const additionalContext = result.outputJson
-                ?.hookSpecificOutput?.additionalContext ?? "";
-            assert.match(additionalContext, /PostCompact Nudge/);
-            assert.match(additionalContext, /omx_wiki/);
-            assert.match(additionalContext, /compaction artifacts/);
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("emits no CLI stdout for PostCompact when no Codex action is needed", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-postcompact-cli-"));
+        try {
+            const stdout = runNativeHookCli({
+                hook_event_name: "PostCompact",
+                cwd,
+                session_id: "sess-postcompact-cli",
+            });
+            assert.equal(stdout, "");
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -922,7 +963,7 @@ describe("codex native hook dispatch", () => {
             assert.equal(result.omxEventName, "keyword-detector");
             assert.equal(result.skillState?.skill, "ralplan");
             assert.ok(result.outputJson, "UserPromptSubmit should emit developer context");
-            assert.match(JSON.stringify(result.outputJson), /skill: ralplan activated and initial state initialized at \.omx\/state\/sessions\/sess-1\/ralplan-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.match(JSON.stringify(result.outputJson), /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
             assert.equal(existsSync(join(cwd, ".omx", "state", "skill-active-state.json")), false, "session-scoped keyword activation should not write root skill-active-state.json");
             const statePath = join(cwd, ".omx", "state", "sessions", "sess-1", "skill-active-state.json");
             assert.equal(existsSync(statePath), true);
@@ -936,6 +977,114 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("records boxed keyword activation mode detail and skill state under OMX_ROOT", async () => {
+        const root = await mkdtemp(join(tmpdir(), "omx-native-hook-boxed-"));
+        const cwd = join(root, "source");
+        const omxRoot = join(root, "box");
+        const sessionId = "sess-boxed-ralplan";
+        const previousOmxRoot = process.env.OMX_ROOT;
+        const previousOmxStateRoot = process.env.OMX_STATE_ROOT;
+        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        const previousOmxSessionId = process.env.OMX_SESSION_ID;
+        try {
+            await mkdir(cwd, { recursive: true });
+            process.env.OMX_ROOT = omxRoot;
+            delete process.env.OMX_STATE_ROOT;
+            delete process.env.OMX_TEAM_STATE_ROOT;
+            process.env.OMX_SESSION_ID = sessionId;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-boxed",
+                turn_id: "turn-boxed",
+                prompt: "$ralplan implement issue #1307",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "ralplan");
+            const boxedSessionDir = join(omxRoot, ".omx", "state", "sessions", sessionId);
+            assert.equal(existsSync(join(boxedSessionDir, "skill-active-state.json")), true);
+            assert.equal(existsSync(join(boxedSessionDir, "ralplan-state.json")), true);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", sessionId, "skill-active-state.json")), false);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", sessionId, "ralplan-state.json")), false);
+            const hudState = await readAllState(cwd);
+            assert.equal(hudState.ralplan?.active, true);
+            assert.equal(hudState.ralplan?.current_phase, "planning");
+        }
+        finally {
+            if (typeof previousOmxRoot === "string")
+                process.env.OMX_ROOT = previousOmxRoot;
+            else
+                delete process.env.OMX_ROOT;
+            if (typeof previousOmxStateRoot === "string")
+                process.env.OMX_STATE_ROOT = previousOmxStateRoot;
+            else
+                delete process.env.OMX_STATE_ROOT;
+            if (typeof previousTeamStateRoot === "string")
+                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            if (typeof previousOmxSessionId === "string")
+                process.env.OMX_SESSION_ID = previousOmxSessionId;
+            else
+                delete process.env.OMX_SESSION_ID;
+            await rm(root, { recursive: true, force: true });
+        }
+    });
+    it("records native keyword activation mode detail and skill state under OMX_TEAM_STATE_ROOT", async () => {
+        const root = await mkdtemp(join(tmpdir(), "omx-native-hook-team-root-"));
+        const cwd = join(root, "source");
+        const teamStateRoot = join(root, "team-state");
+        const sessionId = "sess-team-root-ralplan";
+        const previousOmxRoot = process.env.OMX_ROOT;
+        const previousOmxStateRoot = process.env.OMX_STATE_ROOT;
+        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        const previousOmxSessionId = process.env.OMX_SESSION_ID;
+        try {
+            await mkdir(cwd, { recursive: true });
+            delete process.env.OMX_ROOT;
+            delete process.env.OMX_STATE_ROOT;
+            process.env.OMX_TEAM_STATE_ROOT = teamStateRoot;
+            process.env.OMX_SESSION_ID = sessionId;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-team-root",
+                turn_id: "turn-team-root",
+                prompt: "$ralplan implement issue #1307",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "ralplan");
+            const teamSessionDir = join(teamStateRoot, "sessions", sessionId);
+            assert.equal(existsSync(join(teamSessionDir, "skill-active-state.json")), true);
+            assert.equal(existsSync(join(teamSessionDir, "ralplan-state.json")), true);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", sessionId, "skill-active-state.json")), false);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", sessionId, "ralplan-state.json")), false);
+            const hudState = await readAllState(cwd);
+            assert.equal(hudState.ralplan?.active, true);
+            assert.equal(hudState.ralplan?.current_phase, "planning");
+        }
+        finally {
+            if (typeof previousOmxRoot === "string")
+                process.env.OMX_ROOT = previousOmxRoot;
+            else
+                delete process.env.OMX_ROOT;
+            if (typeof previousOmxStateRoot === "string")
+                process.env.OMX_STATE_ROOT = previousOmxStateRoot;
+            else
+                delete process.env.OMX_STATE_ROOT;
+            if (typeof previousTeamStateRoot === "string")
+                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            if (typeof previousOmxSessionId === "string")
+                process.env.OMX_SESSION_ID = previousOmxSessionId;
+            else
+                delete process.env.OMX_SESSION_ID;
+            await rm(root, { recursive: true, force: true });
+        }
+    });
     it("warns completion-like prompts when active goal workflows need Codex snapshot reconciliation", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-goal-warning-"));
         try {
@@ -985,6 +1134,94 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not block Stop for non-passing autoresearch-goal professor-critic verdicts", async () => {
+        for (const verdict of ["blocked", "fail", "failed"]) {
+            const cwd = await mkdtemp(join(tmpdir(), `omx-native-hook-autoresearch-${verdict}-stop-`));
+            const slug = `${verdict}-mission`;
+            try {
+                await writeJson(join(cwd, ".omx", "goals", "autoresearch", slug, "mission.json"), {
+                    version: 1,
+                    workflow: "autoresearch-goal",
+                    slug,
+                    topic: "Blocked research",
+                    status: verdict === "blocked" ? "blocked" : "failed",
+                });
+                await writeJson(join(cwd, ".omx", "goals", "autoresearch", slug, "completion.json"), {
+                    verdict,
+                    passed: false,
+                });
+                const result = await dispatchCodexNativeHook({
+                    hook_event_name: "Stop",
+                    cwd,
+                    session_id: `sess-autoresearch-${verdict}-stop`,
+                    thread_id: `thread-autoresearch-${verdict}-stop`,
+                    last_assistant_message: "Autoresearch goal complete; next call update_goal({status: \"complete\"}).",
+                }, { cwd });
+                assert.notEqual(result.outputJson?.decision, "block");
+                assert.doesNotMatch(JSON.stringify(result.outputJson), new RegExp(`autoresearch-goal complete --slug ${slug}`));
+                assert.doesNotMatch(JSON.stringify(result.outputJson), /get_goal snapshot reconciliation/);
+            }
+            finally {
+                await rm(cwd, { recursive: true, force: true });
+            }
+        }
+    });
+    it("blocks Stop for passing autoresearch-goal professor-critic verdicts that need reconciliation", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autoresearch-pass-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "goals", "autoresearch", "passing-mission", "mission.json"), {
+                version: 1,
+                workflow: "autoresearch-goal",
+                slug: "passing-mission",
+                topic: "Passing research",
+                status: "validation_passed",
+            });
+            await writeJson(join(cwd, ".omx", "goals", "autoresearch", "passing-mission", "completion.json"), {
+                verdict: "fail",
+                passed: true,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-autoresearch-pass-stop",
+                thread_id: "thread-autoresearch-pass-stop",
+                last_assistant_message: "Autoresearch goal complete; next call update_goal({status: \"complete\"}).",
+            }, { cwd });
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(JSON.stringify(result.outputJson), /get_goal snapshot reconciliation/);
+            assert.match(JSON.stringify(result.outputJson), /omx autoresearch-goal complete --slug passing-mission/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks Stop for autoresearch-goal verdict=pass even when passed is omitted", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autoresearch-verdict-pass-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "goals", "autoresearch", "verdict-pass-mission", "mission.json"), {
+                version: 1,
+                workflow: "autoresearch-goal",
+                slug: "verdict-pass-mission",
+                topic: "Passing research",
+                status: "validation_passed",
+            });
+            await writeJson(join(cwd, ".omx", "goals", "autoresearch", "verdict-pass-mission", "completion.json"), {
+                verdict: "pass",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-autoresearch-verdict-pass-stop",
+                thread_id: "thread-autoresearch-verdict-pass-stop",
+                last_assistant_message: "Autoresearch goal complete; next call update_goal({status: \"complete\"}).",
+            }, { cwd });
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(JSON.stringify(result.outputJson), /omx autoresearch-goal complete --slug verdict-pass-mission/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("treats workflow keywords in native subagent prompt text as literal delegation text", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-subagent-keyword-literal-"));
         try {
@@ -1060,7 +1297,7 @@ describe("codex native hook dispatch", () => {
             assert.equal(result.skillState?.skill, "ralplan");
             const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
             assert.match(message, /\$oh-my-codex:ralplan" -> ralplan/);
-            assert.match(message, /skill: ralplan activated and initial state initialized at \.omx\/state\/sessions\/sess-plugin-1\/ralplan-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.match(message, /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
             assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-plugin-1", "ralplan-state.json")), true);
         }
         finally {
@@ -1234,7 +1471,7 @@ describe("codex native hook dispatch", () => {
             assert.equal(result.skillState?.skill, "ralph");
             const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
             assert.match(message, /\$ralph" -> ralph/);
-            assert.match(message, /skill: ralph activated and initial state initialized at \.omx\/state\/sessions\/sess-ralph-msg\/ralph-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.match(message, /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
             assert.match(message, /Prompt-side `\$ralph` activation seeds Ralph workflow state only; it does not invoke `omx ralph`\./);
             assert.match(message, /Use `omx ralph --prd \.\.\.` only when you explicitly want the PRD-gated CLI startup path\./);
         }
@@ -1258,7 +1495,7 @@ describe("codex native hook dispatch", () => {
             assert.equal(result.skillState?.skill, "ralph");
             const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
             assert.match(message, /\$oh-my-codex:ralph" -> ralph/);
-            assert.match(message, /skill: ralph activated and initial state initialized at \.omx\/state\/sessions\/sess-plugin-ralph-msg\/ralph-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.match(message, /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
             assert.match(message, /Prompt-side `\$ralph` activation seeds Ralph workflow state only; it does not invoke `omx ralph`\./);
         }
         finally {
@@ -1327,7 +1564,7 @@ describe("codex native hook dispatch", () => {
             assert.equal(result.skillState?.skill, "deep-interview");
             const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
             assert.match(message, /\$deep-interview" -> deep-interview/);
-            assert.match(message, /skill: deep-interview activated and initial state initialized at \.omx\/state\/sessions\/sess-deep-interview-msg\/deep-interview-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.match(message, /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
             assert.match(message, /Deep-interview is active, but this session is not attached to tmux/);
             assert.match(message, /Do not invoke `omx question`, `omx hud`, or `omx team`/);
             assert.match(message, /native structured question tool when available/);
@@ -1717,8 +1954,11 @@ export async function onHookEvent(event) {
             }, { cwd });
             assert.match(JSON.stringify(denied.outputJson), /denied workflow keyword/i);
             assert.match(JSON.stringify(denied.outputJson), /Unsupported workflow overlap: team \+ autopilot\./);
-            assert.match(JSON.stringify(denied.outputJson), /`omx state clear --mode <mode>`/);
-            assert.match(JSON.stringify(denied.outputJson), /`omx_state\.\*` MCP tools/);
+            assert.match(JSON.stringify(denied.outputJson), /omx state clear --input/);
+            assert.match(JSON.stringify(denied.outputJson), /mode\\":\\"<mode>/);
+            assert.match(JSON.stringify(denied.outputJson), /--json/);
+            assert.match(JSON.stringify(denied.outputJson), /explicit MCP compatibility is enabled/);
+            assert.match(JSON.stringify(denied.outputJson), /`omx_state\.\*` tools/);
             assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-deny-1", "autopilot-state.json")), false);
         }
         finally {
@@ -1777,7 +2017,7 @@ export async function onHookEvent(event) {
             assert.match(message, /\$ralph" -> ralph/);
             assert.doesNotMatch(message, /mode transiting:/);
             assert.match(message, /planning preserved over simultaneous execution follow-up; deferred skills: team, ralph\./);
-            assert.match(message, /skill: ralplan activated and initial state initialized at \.omx\/state\/sessions\/sess-multi-1\/ralplan-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.match(message, /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
             assert.doesNotMatch(message, /Use the durable OMX team runtime via `omx team \.\.\.`/);
         }
         finally {
@@ -1802,7 +2042,7 @@ export async function onHookEvent(event) {
             assert.match(message, /\$oh-my-codex:ralph" -> ralph/);
             assert.doesNotMatch(message, /mode transiting:/);
             assert.match(message, /planning preserved over simultaneous execution follow-up; deferred skills: team, ralph\./);
-            assert.match(message, /skill: ralplan activated and initial state initialized at \.omx\/state\/sessions\/sess-plugin-multi-1\/ralplan-state\.json; write subsequent updates via omx_state MCP\./);
+            assert.match(message, /use CLI-first state updates via `omx state write\/read\/clear --input '<json>' --json`/);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -3572,7 +3812,7 @@ exit 0
             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, /omx 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/);
@@ -3742,7 +3982,7 @@ exit 0
             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 || ""), /Retry via CLI parity with `omx 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");
@@ -3800,7 +4040,7 @@ exit 0
                 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.",
+                    additionalContext: "Clear MCP transport-death signal detected. Preserve current team/runtime state. Retry via CLI parity with `omx 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);
@@ -4965,6 +5205,38 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("ignores stale source-root team Stop fallback when OMX_TEAM_STATE_ROOT is authoritative", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-stale-source-root-"));
+        const teamStateRoot = join(cwd, "shared-team-state");
+        const priorTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        try {
+            process.env.OMX_TEAM_STATE_ROOT = teamStateRoot;
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await mkdir(join(teamStateRoot, "team", "stale-source-team"), { recursive: true });
+            await writeJson(join(cwd, ".omx", "state", "team-state.json"), {
+                active: true,
+                team_name: "stale-source-team",
+                current_phase: "team-exec",
+            });
+            await writeJson(join(teamStateRoot, "team", "stale-source-team", "phase.json"), {
+                current_phase: "team-exec",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stale-source-team",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            if (typeof priorTeamStateRoot === "string")
+                process.env.OMX_TEAM_STATE_ROOT = priorTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("returns Stop continuation output from canonical team state rooted via OMX_TEAM_STATE_ROOT", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-env-root-"));
         const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
@@ -5856,6 +6128,69 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("blocks Codex App Stop when Ralph is marked complete without completion-audit evidence", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralph-complete-audit-missing-"));
+        try {
+            const sessionId = "sess-ralph-complete-missing";
+            const statePath = join(cwd, ".omx", "state", "sessions", sessionId, "ralph-state.json");
+            await writeJson(join(cwd, ".omx", "state", "session.json"), { session_id: sessionId, native_session_id: sessionId, cwd });
+            await writeJson(statePath, {
+                active: false,
+                mode: "ralph",
+                current_phase: "complete",
+                session_id: sessionId,
+                completed_at: "2026-05-10T12:00:00.000Z",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+                last_assistant_message: "Done. Ralph complete.",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.match(String(result.outputJson?.reason), /Ralph completion audit is missing required evidence/);
+            assert.equal(result.outputJson?.stopReason, "ralph_completion_audit_missing_completion_audit");
+            const reopened = JSON.parse(await readFile(statePath, "utf-8"));
+            assert.equal(reopened.active, true);
+            assert.equal(reopened.current_phase, "verifying");
+            assert.equal(reopened.completion_audit_gate, "blocked");
+            assert.equal(reopened.completion_audit_missing_reason, "missing_completion_audit");
+            assert.equal(typeof reopened.completed_at, "undefined");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows Codex App Stop when complete Ralph state carries checklist and verification evidence", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ralph-complete-audit-present-"));
+        try {
+            const sessionId = "sess-ralph-complete-present";
+            await writeJson(join(cwd, ".omx", "state", "session.json"), { session_id: sessionId, native_session_id: sessionId, cwd });
+            await writeJson(join(cwd, ".omx", "state", "sessions", sessionId, "ralph-state.json"), {
+                active: false,
+                mode: "ralph",
+                current_phase: "complete",
+                session_id: sessionId,
+                completed_at: "2026-05-10T12:00:00.000Z",
+                completion_audit: {
+                    passed: true,
+                    prompt_to_artifact_checklist: ["issue #2260 fixed", "tests added"],
+                    verification_evidence: ["node --test dist/scripts/__tests__/codex-native-hook.test.js"],
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+                last_assistant_message: "Done with completion audit evidence recorded.",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("returns Stop continuation output while Ralph is active without an explicit session pin", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-"));
         try {