oh-my-codex 0.16.3 → 0.17.0

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

@@ -9,12 +9,13 @@ import { afterEach, beforeEach, describe, it } from "node:test";
 import { buildManagedCodexHooksConfig } from "../../config/codex-hooks.js";
 import { DOCUMENT_REFRESH_EXEMPTION_PREFIX } from "../../document-refresh/enforcer.js";
 import { initTeamState, readTeamLeaderAttention, readTeamPhase, writeTeamLeaderAttention, } from "../../team/state.js";
-import { dispatchCodexNativeHook, isCodexNativeHookMainModule, mapCodexHookEventToOmxEvent, resolveSessionOwnerPidFromAncestry, } from "../codex-native-hook.js";
+import { dispatchCodexNativeHook, isCodexNativeHookMainModule, looksLikeGoalCompletionPrompt, 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";
 import { OMX_TMUX_HUD_OWNER_ENV } from "../../hud/reconcile.js";
-import { writePage } from "../../wiki/storage.js";
+import { readAllState } from "../../hud/state.js";
+import { getLegacyWikiDir, serializePage, writePage } from "../../wiki/storage.js";
 import { WIKI_SCHEMA_VERSION } from "../../wiki/types.js";
 function nativeHookScriptPath() {
     return join(process.cwd(), "dist", "scripts", "codex-native-hook.js");
@@ -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");
@@ -858,6 +859,61 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("prefers repository project-memory.json during SessionStart while preserving legacy wiki guidance", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-root-memory-legacy-wiki-"));
+        try {
+            const now = new Date().toISOString();
+            const legacyWikiDir = getLegacyWikiDir(cwd);
+            await mkdir(legacyWikiDir, { recursive: true });
+            await writeFile(join(legacyWikiDir, "legacy.md"), serializePage({
+                filename: "legacy.md",
+                frontmatter: {
+                    title: "Legacy",
+                    tags: ["legacy"],
+                    created: now,
+                    updated: now,
+                    sources: [],
+                    links: [],
+                    category: "reference",
+                    confidence: "medium",
+                    schemaVersion: WIKI_SCHEMA_VERSION,
+                },
+                content: "\n# Legacy\n\nLegacy wiki context must remain visible.\n",
+            }));
+            await writeJson(join(cwd, ".omx", "project-memory.json"), {
+                techStack: "Legacy runtime memory should not win",
+                notes: [{ category: "legacy", content: "stale legacy note", timestamp: now }],
+            });
+            await writeJson(join(cwd, "project-memory.json"), {
+                techStack: "Canonical root memory",
+                build: "npm run build && node --test dist/scripts/__tests__/codex-native-hook.test.js",
+                conventions: "prefer repository-visible project memory at startup",
+                directives: [
+                    { directive: "Load root project-memory.json before legacy .omx memory.", priority: "high", timestamp: now },
+                ],
+                notes: [
+                    { category: "issue", content: "Regression fixture for issue #2273.", timestamp: now },
+                ],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: "sess-root-memory-legacy-wiki",
+            }, { cwd, sessionOwnerPid: 43210 });
+            const additionalContext = String(result.outputJson?.hookSpecificOutput?.additionalContext ?? "");
+            assert.match(additionalContext, /\[Project memory\]/);
+            assert.match(additionalContext, /source: project-memory\.json/);
+            assert.match(additionalContext, /Canonical root memory/);
+            assert.match(additionalContext, /Load root project-memory\.json before legacy \.omx memory\./);
+            assert.match(additionalContext, /Regression fixture for issue #2273\./);
+            assert.doesNotMatch(additionalContext, /Legacy runtime memory should not win/);
+            assert.match(additionalContext, /legacy pages at \.omx\/wiki\//);
+            assert.match(additionalContext, /Legacy wiki fallback is read-only/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("starts a fresh native session without inheriting stale task-scoped context", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-isolation-"));
         try {
@@ -962,7 +1018,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);
@@ -976,6 +1032,141 @@ 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("classifies only actionable goal completion wording", () => {
+        const actionable = [
+            "complete this goal now",
+            "Performance goal complete; next call update_goal({status: \"complete\"}).",
+            "get_goal returned a completed legacy goal, so ultragoal complete failed; marking complete now.",
+            "omx ultragoal checkpoint --goal-id G001-demo --status complete --codex-goal-json goal.json",
+            "Call update_goal({status: \"complete\"}) after verification.",
+            "Goal complete.",
+            "The goal is complete.",
+            "Goal complete: verified with tests.",
+            "Goal complete — verified with tests.",
+            "The goal is complete: verified.",
+            "The goal is complete — verified.",
+        ];
+        const ordinary = [
+            "my goal is to complete the migration without regressions",
+            "Our goal is to finish this carefully after tests pass.",
+            "The goal of this patch is to close a review gap.",
+            "A goal can be complete only after a human review.",
+        ];
+        for (const text of actionable) {
+            assert.equal(looksLikeGoalCompletionPrompt(text), true, text);
+        }
+        for (const text of ordinary) {
+            assert.equal(looksLikeGoalCompletionPrompt(text), false, text);
+        }
+    });
     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 {
@@ -1025,6 +1216,109 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("blocks ultragoal Stop for concise generic goal completion claims", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-generic-complete-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "ultragoal", "goals.json"), {
+                version: 1,
+                activeGoalId: "G001-demo",
+                goals: [{ id: "G001-demo", status: "in_progress", objective: "Demo goal" }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-ultragoal-generic-complete-stop",
+                thread_id: "thread-ultragoal-generic-complete-stop",
+                last_assistant_message: "Goal complete.",
+            }, { cwd });
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(JSON.stringify(result.outputJson), /omx ultragoal checkpoint --goal-id G001-demo --status complete/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block ultragoal Stop for ordinary prose about a goal to complete work", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-ordinary-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "ultragoal", "goals.json"), {
+                version: 1,
+                activeGoalId: "G001-demo",
+                goals: [{ id: "G001-demo", status: "in_progress", objective: "Demo goal" }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-ultragoal-ordinary-stop",
+                thread_id: "thread-ultragoal-ordinary-stop",
+                last_assistant_message: "My goal is to complete the migration without regressions, so I will keep testing.",
+            }, { cwd });
+            assert.notEqual(result.outputJson?.stopReason, "ultragoal_codex_goal_snapshot_required");
+            assert.doesNotMatch(JSON.stringify(result.outputJson), /omx ultragoal checkpoint --goal-id G001-demo --status complete/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks ultragoal Stop with blocked checkpoint and fresh-thread remediation for completed legacy snapshots", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-legacy-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "ultragoal", "goals.json"), {
+                version: 1,
+                activeGoalId: "G001-demo",
+                goals: [{ id: "G001-demo", status: "in_progress", objective: "Demo goal" }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-ultragoal-legacy-stop",
+                thread_id: "thread-ultragoal-legacy-stop",
+                last_assistant_message: "get_goal returned a completed legacy goal, so ultragoal complete failed; marking complete now.",
+            }, { cwd });
+            const output = JSON.stringify(result.outputJson);
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(output, /omx ultragoal checkpoint --goal-id G001-demo --status complete/);
+            assert.match(output, /--status blocked/);
+            assert.match(output, /fresh Codex thread/);
+            assert.match(output, /Hooks must not mutate Codex goal state/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block ultragoal Stop after task-scoped reconciliation finishes exploded bookkeeping", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-reconciled-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "ultragoal", "goals.json"), {
+                version: 1,
+                codexGoalMode: "aggregate",
+                codexObjective: "Complete all ultragoal stories in .omx/ultragoal/goals.json: many micro goals",
+                activeGoalId: "G001-micro",
+                aggregateCompletion: {
+                    status: "complete",
+                    completedAt: "2026-05-04T10:04:00.000Z",
+                    evidence: "planned work done; validation complete; reviews clean",
+                },
+                goals: Array.from({ length: 136 }, (_, index) => ({
+                    id: `G${String(index + 1).padStart(3, "0")}-micro`,
+                    status: index === 0 ? "in_progress" : "pending",
+                    objective: `Synthetic slice ${index + 1}.`,
+                })),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-ultragoal-reconciled-stop",
+                thread_id: "thread-ultragoal-reconciled-stop",
+                last_assistant_message: "Yes — planned implementation work is done; ultragoal bookkeeping reconciled complete.",
+            }, { cwd });
+            assert.notEqual(result.outputJson?.stopReason, "ultragoal_codex_goal_snapshot_required");
+            assert.doesNotMatch(JSON.stringify(result.outputJson), /omx ultragoal checkpoint --goal-id/);
+        }
+        finally {
+            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-`));
@@ -1188,7 +1482,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 {
@@ -1362,7 +1656,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\./);
         }
@@ -1386,7 +1680,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 {
@@ -1455,7 +1749,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/);
@@ -1845,8 +2139,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 {
@@ -1905,7 +2202,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 {
@@ -1930,7 +2227,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 });
@@ -3700,7 +3997,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/);
@@ -3870,7 +4167,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");
@@ -3928,7 +4225,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);
@@ -5093,6 +5390,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;
@@ -5984,6 +6313,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 {