oh-my-codex 0.18.0 → 0.18.2

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

@@ -15,8 +15,11 @@ 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 { renderHud } from "../../hud/render.js";
 import { getLegacyWikiDir, serializePage, writePage } from "../../wiki/storage.js";
 import { WIKI_SCHEMA_VERSION } from "../../wiki/types.js";
+import { createUltragoalPlan, readUltragoalPlan } from "../../ultragoal/artifacts.js";
+import { getBaseStateDir } from "../../state/paths.js";
 function nativeHookScriptPath() {
     return join(process.cwd(), "dist", "scripts", "codex-native-hook.js");
 }
@@ -39,6 +42,38 @@ async function writeJson(path, value) {
     await mkdir(dirname(path), { recursive: true }).catch(() => { });
     await writeFile(path, JSON.stringify(value, null, 2));
 }
+async function withLoreGuardConfig(value, prefix, run) {
+    const cwd = await mkdtemp(join(tmpdir(), `omx-native-hook-pretool-git-commit-lore-${prefix}-`));
+    const codexHome = await mkdtemp(join(tmpdir(), `omx-native-hook-codex-home-lore-${prefix}-`));
+    const defaultHome = await mkdtemp(join(tmpdir(), `omx-native-hook-home-lore-${prefix}-`));
+    const originalGuard = process.env.OMX_LORE_COMMIT_GUARD;
+    const originalCodexHome = process.env.CODEX_HOME;
+    const originalHome = process.env.HOME;
+    try {
+        delete process.env.OMX_LORE_COMMIT_GUARD;
+        process.env.CODEX_HOME = codexHome;
+        process.env.HOME = defaultHome;
+        await writeFile(join(codexHome, "config.toml"), `[shell_environment_policy.set]\nOMX_LORE_COMMIT_GUARD = "${value}"\n`, "utf-8");
+        return await run(cwd);
+    }
+    finally {
+        if (originalGuard === undefined)
+            delete process.env.OMX_LORE_COMMIT_GUARD;
+        else
+            process.env.OMX_LORE_COMMIT_GUARD = originalGuard;
+        if (originalCodexHome === undefined)
+            delete process.env.CODEX_HOME;
+        else
+            process.env.CODEX_HOME = originalCodexHome;
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        await rm(cwd, { recursive: true, force: true });
+        await rm(codexHome, { recursive: true, force: true });
+        await rm(defaultHome, { recursive: true, force: true });
+    }
+}
 function buildWorkerStopFakeTmux(tmuxLogPath, options = {}) {
     return `#!/usr/bin/env bash
 set -eu
@@ -189,7 +224,7 @@ describe("codex native hook config", () => {
         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");
+        assert.equal(preToolUse.matcher, undefined);
         assert.match(String(preToolUse.hooks?.[0]?.command || ""), /codex-native-hook\.js"?$/);
         assert.equal(preToolUse.hooks?.[0]?.statusMessage, undefined);
         const postToolUse = config.hooks.PostToolUse[0];
@@ -567,7 +602,16 @@ describe("codex native hook dispatch", () => {
     });
     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 originalCodexHome = process.env.CODEX_HOME;
+        try {
+            process.env.CODEX_HOME = join(cwd, "codex-home");
+            await writeJson(join(process.env.CODEX_HOME, ".omx-config.json"), {
+                notifications: {
+                    enabled: true,
+                    verbosity: "session",
+                    telegram: { enabled: true, botToken: "123:abc", chatId: "456" },
+                },
+            });
             const stateDir = join(cwd, ".omx", "state");
             const canonicalSessionId = "omx-leader-session";
             const leaderNativeSessionId = "codex-leader-thread";
@@ -583,6 +627,13 @@ describe("codex native hook dispatch", () => {
                 iteration: 1,
                 max_iterations: 5,
             });
+            await mkdir(join(cwd, ".omx", "hooks"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "hooks", "record-lifecycle.mjs"), [
+                "import { appendFileSync } from 'node:fs';",
+                "export async function onHookEvent(event) {",
+                "  appendFileSync('hook-events.jsonl', `${JSON.stringify({ event: event.event, context: event.context })}\\n`);",
+                "}",
+            ].join("\n"));
             const transcriptPath = join(cwd, "subagent-rollout.jsonl");
             await writeFile(transcriptPath, `${JSON.stringify({
                 type: "session_meta",
@@ -616,6 +667,7 @@ describe("codex native hook dispatch", () => {
             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");
+            assert.equal(existsSync(join(cwd, "hook-events.jsonl")), false, "subagent SessionStart must not independently dispatch session-start hook notifications");
             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");
@@ -623,8 +675,213 @@ describe("codex native hook dispatch", () => {
             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");
+            await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: childNativeSessionId,
+                thread_id: childNativeSessionId,
+                turn_id: "child-stop-turn",
+            }, { cwd });
+            assert.equal(existsSync(join(cwd, "hook-events.jsonl")), false, "subagent Stop must not independently dispatch stop hook notifications");
+        }
+        finally {
+            if (originalCodexHome === undefined) {
+                delete process.env.CODEX_HOME;
+            }
+            else {
+                process.env.CODEX_HOME = originalCodexHome;
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("suppresses child-agent SessionStart hook dispatch at minimal verbosity", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-subagent-session-minimal-"));
+        const originalCodexHome = process.env.CODEX_HOME;
+        try {
+            process.env.CODEX_HOME = join(cwd, "codex-home");
+            await writeJson(join(process.env.CODEX_HOME, ".omx-config.json"), {
+                notifications: {
+                    enabled: true,
+                    verbosity: "minimal",
+                    telegram: { enabled: true, botToken: "123:abc", chatId: "456" },
+                },
+            });
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "omx-leader-session-minimal";
+            const leaderNativeSessionId = "codex-leader-thread-minimal";
+            const childNativeSessionId = "codex-child-thread-minimal";
+            await mkdir(join(stateDir, "sessions", canonicalSessionId), { recursive: true });
+            await writeSessionStart(cwd, canonicalSessionId, {
+                nativeSessionId: leaderNativeSessionId,
+            });
+            await mkdir(join(cwd, ".omx", "hooks"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "hooks", "record-lifecycle.mjs"), [
+                "import { appendFileSync } from 'node:fs';",
+                "export async function onHookEvent(event) {",
+                "  appendFileSync('hook-events.jsonl', `${JSON.stringify({ event: event.event })}\\n`);",
+                "}",
+            ].join("\n"));
+            const transcriptPath = join(cwd, "minimal-subagent-rollout.jsonl");
+            await writeFile(transcriptPath, `${JSON.stringify({
+                type: "session_meta",
+                payload: {
+                    id: childNativeSessionId,
+                    source: {
+                        subagent: {
+                            thread_spawn: {
+                                parent_thread_id: leaderNativeSessionId,
+                                agent_role: "verifier",
+                            },
+                        },
+                    },
+                },
+            })}\n`);
+            await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: childNativeSessionId,
+                transcript_path: transcriptPath,
+            }, { cwd, sessionOwnerPid: process.pid });
+            assert.equal(existsSync(join(cwd, "hook-events.jsonl")), false, "subagent SessionStart must be suppressed at minimal verbosity");
+        }
+        finally {
+            if (originalCodexHome === undefined) {
+                delete process.env.CODEX_HOME;
+            }
+            else {
+                process.env.CODEX_HOME = originalCodexHome;
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows explicit child-agent lifecycle hook dispatch when includeChildAgents is enabled", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-subagent-session-include-"));
+        const originalCodexHome = process.env.CODEX_HOME;
+        try {
+            process.env.CODEX_HOME = join(cwd, "codex-home");
+            await writeJson(join(process.env.CODEX_HOME, ".omx-config.json"), {
+                notifications: {
+                    enabled: true,
+                    verbosity: "session",
+                    includeChildAgents: true,
+                    telegram: { enabled: true, botToken: "123:abc", chatId: "456" },
+                },
+            });
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "omx-leader-session-include";
+            const leaderNativeSessionId = "codex-leader-thread-include";
+            const childNativeSessionId = "codex-child-thread-include";
+            await mkdir(join(stateDir, "sessions", canonicalSessionId), { recursive: true });
+            await writeSessionStart(cwd, canonicalSessionId, {
+                nativeSessionId: leaderNativeSessionId,
+            });
+            await mkdir(join(cwd, ".omx", "hooks"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "hooks", "record-lifecycle.mjs"), [
+                "import { appendFileSync } from 'node:fs';",
+                "export async function onHookEvent(event) {",
+                "  appendFileSync('hook-events.jsonl', `${JSON.stringify({ event: event.event })}\\n`);",
+                "}",
+            ].join("\n"));
+            const transcriptPath = join(cwd, "included-subagent-rollout.jsonl");
+            await writeFile(transcriptPath, `${JSON.stringify({
+                type: "session_meta",
+                payload: {
+                    id: childNativeSessionId,
+                    source: {
+                        subagent: {
+                            thread_spawn: {
+                                parent_thread_id: leaderNativeSessionId,
+                                agent_role: "verifier",
+                            },
+                        },
+                    },
+                },
+            })}\n`);
+            await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: childNativeSessionId,
+                transcript_path: transcriptPath,
+            }, { cwd, sessionOwnerPid: process.pid });
+            await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: childNativeSessionId,
+                thread_id: childNativeSessionId,
+                turn_id: "included-child-stop-turn",
+            }, { cwd });
+            const hookEvents = await readFile(join(cwd, "hook-events.jsonl"), "utf-8");
+            assert.match(hookEvents, /"event":"session-start"/);
+            assert.match(hookEvents, /"event":"stop"/);
+        }
+        finally {
+            if (originalCodexHome === undefined) {
+                delete process.env.CODEX_HOME;
+            }
+            else {
+                process.env.CODEX_HOME = originalCodexHome;
+            }
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows child-agent lifecycle hook dispatch at agent verbosity", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-subagent-session-agent-"));
+        const originalCodexHome = process.env.CODEX_HOME;
+        try {
+            process.env.CODEX_HOME = join(cwd, "codex-home");
+            await writeJson(join(process.env.CODEX_HOME, ".omx-config.json"), {
+                notifications: {
+                    enabled: true,
+                    verbosity: "agent",
+                    telegram: { enabled: true, botToken: "123:abc", chatId: "456" },
+                },
+            });
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "omx-leader-session-agent";
+            const leaderNativeSessionId = "codex-leader-thread-agent";
+            const childNativeSessionId = "codex-child-thread-agent";
+            await mkdir(join(stateDir, "sessions", canonicalSessionId), { recursive: true });
+            await writeSessionStart(cwd, canonicalSessionId, {
+                nativeSessionId: leaderNativeSessionId,
+            });
+            await mkdir(join(cwd, ".omx", "hooks"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "hooks", "record-lifecycle.mjs"), [
+                "import { appendFileSync } from 'node:fs';",
+                "export async function onHookEvent(event) {",
+                "  appendFileSync('hook-events.jsonl', `${JSON.stringify({ event: event.event })}\\n`);",
+                "}",
+            ].join("\n"));
+            const transcriptPath = join(cwd, "agent-verbosity-subagent-rollout.jsonl");
+            await writeFile(transcriptPath, `${JSON.stringify({
+                type: "session_meta",
+                payload: {
+                    id: childNativeSessionId,
+                    source: {
+                        subagent: {
+                            thread_spawn: {
+                                parent_thread_id: leaderNativeSessionId,
+                                agent_role: "verifier",
+                            },
+                        },
+                    },
+                },
+            })}\n`);
+            await dispatchCodexNativeHook({
+                hook_event_name: "SessionStart",
+                cwd,
+                session_id: childNativeSessionId,
+                transcript_path: transcriptPath,
+            }, { cwd, sessionOwnerPid: process.pid });
+            const hookEvents = await readFile(join(cwd, "hook-events.jsonl"), "utf-8");
+            assert.match(hookEvents, /"event":"session-start"/);
         }
         finally {
+            if (originalCodexHome === undefined) {
+                delete process.env.CODEX_HOME;
+            }
+            else {
+                process.env.CODEX_HOME = originalCodexHome;
+            }
             await rm(cwd, { recursive: true, force: true });
         }
     });
@@ -1218,6 +1475,62 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not repeat performance-goal reconciliation after a recorded objective mismatch blocker", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-performance-mismatch-blocked-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "goals", "performance", "latency", "state.json"), {
+                version: 1,
+                workflow: "performance-goal",
+                slug: "latency",
+                objective: "Reduce latency",
+                status: "blocked",
+                lastValidation: {
+                    status: "blocked",
+                    evidence: "omx performance-goal complete rejected the fresh get_goal snapshot: Codex goal objective mismatch: expected \"reduce latency\", got \"legacy objective\".",
+                    recordedAt: "2026-05-20T00:00:00.000Z",
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-performance-mismatch-blocked-stop",
+                thread_id: "thread-performance-mismatch-blocked-stop",
+                last_assistant_message: "Performance goal complete; next call update_goal({status: \"complete\"}).",
+            }, { cwd });
+            assert.notEqual(result.outputJson?.decision, "block");
+            assert.doesNotMatch(JSON.stringify(result.outputJson), /omx performance-goal complete --slug latency/);
+            assert.doesNotMatch(JSON.stringify(result.outputJson), /get_goal snapshot reconciliation/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block Stop for an already complete performance-goal state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-performance-complete-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "goals", "performance", "latency", "state.json"), {
+                version: 1,
+                workflow: "performance-goal",
+                slug: "latency",
+                objective: "Reduce latency",
+                status: "complete",
+                completedAt: "2026-05-20T00:00:00.000Z",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-performance-complete-stop",
+                thread_id: "thread-performance-complete-stop",
+                last_assistant_message: "Performance goal complete; next call update_goal({status: \"complete\"}).",
+            }, { cwd });
+            assert.notEqual(result.outputJson?.decision, "block");
+            assert.doesNotMatch(JSON.stringify(result.outputJson), /omx performance-goal complete --slug latency/);
+            assert.doesNotMatch(JSON.stringify(result.outputJson), /get_goal snapshot reconciliation/);
+        }
+        finally {
+            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 {
@@ -1262,7 +1575,7 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("blocks ultragoal Stop with blocked checkpoint and fresh-thread remediation for completed legacy snapshots", async () => {
+    it("blocks ultragoal Stop with blocked checkpoint and available-goal-context 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"), {
@@ -1281,7 +1594,11 @@ describe("codex native hook dispatch", () => {
             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, /Codex goal context/);
+            assert.match(output, /no such table: thread_goals/);
+            assert.match(output, /unavailable get_goal error JSON or path/);
+            assert.match(output, /safe-recovery blocker/);
+            assert.doesNotMatch(output, /fresh (?:Codex )?(?:thread|session)s?/i);
             assert.match(output, /Hooks must not mutate Codex goal state/);
         }
         finally {
@@ -1294,7 +1611,7 @@ describe("codex native hook dispatch", () => {
             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",
+                codexObjective: "Complete the durable ultragoal plan in .omx/ultragoal/goals.json, including later accepted/appended stories, under the original brief constraints; use .omx/ultragoal/ledger.jsonl as the audit trail.",
                 activeGoalId: "G001-micro",
                 aggregateCompletion: {
                     status: "complete",
@@ -1552,6 +1869,30 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("injects autopilot ralplan consensus gate guidance on prompt activation", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-gate-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-autopilot-ralplan-gate",
+                thread_id: "thread-autopilot-ralplan-gate",
+                turn_id: "turn-autopilot-ralplan-gate",
+                prompt: "$autopilot implement issue #2430",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "autopilot");
+            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
+            assert.match(message, /Autopilot protocol:/);
+            assert.match(message, /deep-interview -> ralplan -> ultragoal -> code-review -> ultraqa/);
+            assert.match(message, /Planner output has been reviewed sequentially by Architect and then Critic/);
+            assert.match(message, /do not hand off to Ultragoal or implementation until .*ralplan_architect_review.*ralplan_critic_review/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("records ultragoal prompt skill activation with goal-tool handoff guidance", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-"));
         try {
@@ -1566,14 +1907,229 @@ describe("codex native hook dispatch", () => {
             }, { cwd });
             assert.equal(result.omxEventName, "keyword-detector");
             assert.equal(result.skillState?.skill, "ultragoal");
-            assert.equal(result.skillState?.initialized_mode, undefined);
+            assert.equal(result.skillState?.initialized_mode, "ultragoal");
+            assert.equal(result.skillState?.initialized_state_path, ".omx/state/sessions/sess-ultragoal-1/ultragoal-state.json");
             const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
             assert.match(message, /"\$ultragoal" -> ultragoal/);
             assert.match(message, /Ultragoal protocol:/);
             assert.match(message, /get_goal/);
             assert.match(message, /create_goal/);
             assert.match(message, /update_goal/);
-            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-ultragoal-1", "ultragoal-state.json")), false);
+            assert.match(message, /does not call `\/goal clear`/);
+            assert.match(message, /multiple sequential ultragoal runs/);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", "sess-ultragoal-1", "ultragoal-state.json")), true);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("deactivates active deep-interview state on explicit ultragoal handoff", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-deep-interview-handoff-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionDir = join(stateDir, "sessions", "sess-ultragoal-handoff");
+            await mkdir(sessionDir, { recursive: true });
+            await writeJson(join(sessionDir, "skill-active-state.json"), {
+                version: 1,
+                active: true,
+                skill: "deep-interview",
+                phase: "planning",
+                session_id: "sess-ultragoal-handoff",
+                active_skills: [{ skill: "deep-interview", phase: "planning", active: true, session_id: "sess-ultragoal-handoff" }],
+            });
+            await writeJson(join(sessionDir, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "intent-first",
+                session_id: "sess-ultragoal-handoff",
+                question_enforcement: {
+                    obligation_id: "obligation-ultragoal-handoff",
+                    source: "omx-question",
+                    status: "pending",
+                    requested_at: "2026-05-21T03:00:00.000Z",
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-ultragoal-handoff",
+                thread_id: "thread-ultragoal-handoff",
+                turn_id: "turn-ultragoal-handoff",
+                prompt: "$ultragoal turn the clarified spec into goals",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "ultragoal");
+            assert.match(JSON.stringify(result.outputJson), /mode transiting: deep-interview -> ultragoal/);
+            const completed = JSON.parse(await readFile(join(sessionDir, "deep-interview-state.json"), "utf-8"));
+            assert.equal(completed.active, false);
+            assert.equal(completed.current_phase, "completed");
+            assert.equal(completed.question_enforcement?.status, "cleared");
+            assert.equal(completed.question_enforcement?.clear_reason, "handoff");
+            assert.equal(existsSync(join(sessionDir, "ultragoal-state.json")), true);
+            const edit = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: "sess-ultragoal-handoff",
+                thread_id: "thread-ultragoal-handoff",
+                tool_name: "Edit",
+                tool_use_id: "tool-ultragoal-post-handoff-edit",
+                tool_input: { file_path: "src/implementation.ts", old_string: "a", new_string: "b" },
+            }, { cwd });
+            assert.equal(edit.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("applies only explicit structured UserPromptSubmit ultragoal steering directives", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-steer-"));
+        try {
+            await createUltragoalPlan(cwd, {
+                brief: "G002-cli-and-prompt-submit-bridge .omx/ultragoal hook steering fixture",
+                goals: [{ title: "First", objective: "Complete first milestone with tests." }],
+            });
+            const prose = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-ultragoal-steer-1",
+                prompt: "Please add a subgoal for docs later; this is normal prose, not a directive.",
+            }, { cwd });
+            assert.equal(prose.outputJson, null);
+            assert.equal((await readUltragoalPlan(cwd)).goals.length, 1);
+            const jsonExample = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-ultragoal-steer-1",
+                prompt: `Here is an inert example:\n\`\`\`json\n${JSON.stringify({
+                    kind: "add_subgoal",
+                    source: "user_prompt_submit",
+                    evidence: "Example JSON should not mutate .omx/ultragoal.",
+                    rationale: "Only explicit steering fences or labels are executable.",
+                    title: "Inert JSON example",
+                    objective: "This example must not be added.",
+                })}\n\`\`\``,
+            }, { cwd });
+            assert.equal(jsonExample.outputJson, null);
+            assert.equal((await readUltragoalPlan(cwd)).goals.length, 1);
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-ultragoal-steer-1",
+                prompt: `OMX_ULTRAGOAL_STEER: ${JSON.stringify({
+                    kind: "add_subgoal",
+                    source: "user_prompt_submit",
+                    evidence: "Prompt-submit supplied a structured .omx/ultragoal directive for G002-cli-and-prompt-submit-bridge.",
+                    rationale: "Add bounded hook regression work while preserving all completion gates.",
+                    title: "Prompt bridge regression",
+                    objective: "Verify UserPromptSubmit bounded steering bridge with tests.",
+                })}`,
+            }, { cwd });
+            const message = String(result.outputJson?.hookSpecificOutput?.additionalContext || "");
+            assert.match(message, /bounded \.omx\/ultragoal steering/);
+            assert.match(message, /G002-cli-and-prompt-submit-bridge/);
+            assert.match(message, /accepted/);
+            const plan = await readUltragoalPlan(cwd);
+            assert.equal(plan.goals.length, 2);
+            assert.equal(plan.goals[1]?.title, "Prompt bridge regression");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not apply UserPromptSubmit ultragoal steering from native subagent prompts", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-steer-subagent-"));
+        try {
+            await createUltragoalPlan(cwd, {
+                brief: "G002-cli-and-prompt-submit-bridge .omx/ultragoal subagent steering fixture",
+                goals: [{ title: "First", objective: "Complete first milestone with tests." }],
+            });
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "sess-ultragoal-parent";
+            const leaderNativeSessionId = "native-ultragoal-parent";
+            const childNativeSessionId = "native-ultragoal-child";
+            const nowIso = new Date().toISOString();
+            await writeJson(join(stateDir, "session.json"), {
+                session_id: canonicalSessionId,
+                native_session_id: leaderNativeSessionId,
+            });
+            await writeJson(join(stateDir, "subagent-tracking.json"), {
+                schemaVersion: 1,
+                sessions: {
+                    [canonicalSessionId]: {
+                        session_id: canonicalSessionId,
+                        leader_thread_id: leaderNativeSessionId,
+                        updated_at: nowIso,
+                        threads: {
+                            [leaderNativeSessionId]: {
+                                thread_id: leaderNativeSessionId,
+                                kind: "leader",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                            },
+                            [childNativeSessionId]: {
+                                thread_id: childNativeSessionId,
+                                kind: "subagent",
+                                first_seen_at: nowIso,
+                                last_seen_at: nowIso,
+                                turn_count: 1,
+                                mode: "architect",
+                            },
+                        },
+                    },
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: childNativeSessionId,
+                thread_id: childNativeSessionId,
+                turn_id: "turn-ultragoal-child-1",
+                prompt: `OMX_ULTRAGOAL_STEER: ${JSON.stringify({
+                    kind: "add_subgoal",
+                    source: "user_prompt_submit",
+                    evidence: "Subagent prompt text must be literal delegated context.",
+                    rationale: "Subagent prompts should not mutate the parent .omx/ultragoal ledger.",
+                    title: "Subagent should not add this",
+                    objective: "This must remain literal prompt text.",
+                })}`,
+            }, { cwd });
+            assert.equal(result.outputJson, null);
+            const plan = await readUltragoalPlan(cwd);
+            assert.equal(plan.goals.length, 1);
+            const ledger = await readFile(join(cwd, ".omx/ultragoal/ledger.jsonl"), "utf-8");
+            assert.equal((ledger.match(/"event":"steering_accepted"/g) ?? []).length, 0);
+            assert.equal((ledger.match(/"event":"steering_rejected"/g) ?? []).length, 0);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("dedupes repeated UserPromptSubmit ultragoal steering directives by prompt signature", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-steer-dedupe-"));
+        try {
+            await createUltragoalPlan(cwd, {
+                brief: "G002-cli-and-prompt-submit-bridge .omx/ultragoal dedupe fixture",
+                goals: [{ title: "First", objective: "Complete first milestone with tests." }],
+            });
+            const prompt = `\`\`\`omx-ultragoal-steer
+${JSON.stringify({
+                kind: "add_subgoal",
+                source: "user_prompt_submit",
+                evidence: "Structured prompt-submit directive adds exactly one deduped goal.",
+                rationale: "Use idempotent bridge semantics for repeated hook delivery.",
+                title: "Deduped bridge regression",
+                objective: "Verify repeated UserPromptSubmit steering does not duplicate goals.",
+            })}
+\`\`\``;
+            await dispatchCodexNativeHook({ hook_event_name: "UserPromptSubmit", cwd, session_id: "sess-dedupe", prompt }, { cwd });
+            const second = await dispatchCodexNativeHook({ hook_event_name: "UserPromptSubmit", cwd, session_id: "sess-dedupe", prompt }, { cwd });
+            const message = String(second.outputJson?.hookSpecificOutput?.additionalContext || "");
+            assert.match(message, /deduped/);
+            const plan = await readUltragoalPlan(cwd);
+            assert.equal(plan.goals.filter((goal) => goal.title === "Deduped bridge regression").length, 1);
+            const ledger = await readFile(join(cwd, ".omx/ultragoal/ledger.jsonl"), "utf-8");
+            assert.equal((ledger.match(/"event":"steering_accepted"/g) ?? []).length, 1);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -2729,52 +3285,199 @@ exit 0
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
-                source: "codex-app",
-                session_id: "sess-team-node-native-block",
-                tool_name: "Bash",
-                tool_use_id: "tool-team-node-native-block",
-                tool_input: { command: "node ./dist/cli/omx.js team status my-team" },
+                source: "codex-app",
+                session_id: "sess-team-node-native-block",
+                tool_name: "Bash",
+                tool_use_id: "tool-team-node-native-block",
+                tool_input: { command: "node ./dist/cli/omx.js team status my-team" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(String(result.outputJson?.systemMessage || ""), /Codex App\/native outside-tmux sessions/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("preserves direct CLI outside-tmux omx team Bash behavior", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-team-cli-outside-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                source: "cli",
+                session_id: "sess-team-cli-outside",
+                tool_name: "Bash",
+                tool_use_id: "tool-team-cli-outside",
+                tool_input: { command: "omx team status my-team" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("preserves source-less outside-tmux omx team Bash behavior when no native session evidence exists", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-team-cli-nosource-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: "sess-team-cli-nosource",
+                tool_name: "Bash",
+                tool_use_id: "tool-team-cli-nosource",
+                tool_input: { command: "omx team status my-team" },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks implementation file edits while deep-interview remains active after a clarified answer", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-deep-interview-edit-block-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionDir = join(stateDir, "sessions", "sess-di-edit-block");
+            await mkdir(sessionDir, { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-di-edit-block", cwd });
+            await writeJson(join(sessionDir, "skill-active-state.json"), {
+                version: 1,
+                active: true,
+                skill: "deep-interview",
+                phase: "planning",
+                session_id: "sess-di-edit-block",
+                thread_id: "thread-di-edit-block",
+                active_skills: [{ skill: "deep-interview", phase: "planning", active: true, session_id: "sess-di-edit-block", thread_id: "thread-di-edit-block" }],
+            });
+            await writeJson(join(sessionDir, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "intent-first",
+                session_id: "sess-di-edit-block",
+                thread_id: "thread-di-edit-block",
+                rounds: [{ answer: "Implement by editing src/hooks/keyword-detector.ts and add tests." }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: "sess-di-edit-block",
+                thread_id: "thread-di-edit-block",
+                tool_name: "Edit",
+                tool_use_id: "tool-di-edit-block",
+                tool_input: { file_path: "src/hooks/keyword-detector.ts", old_string: "a", new_string: "b" },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.equal(result.outputJson?.decision, "block");
-            assert.match(String(result.outputJson?.systemMessage || ""), /Codex App\/native outside-tmux sessions/);
+            assert.match(String(result.outputJson?.reason ?? ""), /Deep-interview is active/);
+            assert.match(JSON.stringify(result.outputJson), /requirements\/spec mode/);
+            assert.match(JSON.stringify(result.outputJson), /\$ralplan/);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("preserves direct CLI outside-tmux omx team Bash behavior", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-team-cli-outside-"));
+    it("allows deep-interview artifact and state writes while blocking implementation Bash writes", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-deep-interview-artifact-"));
         try {
-            const result = await dispatchCodexNativeHook({
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionDir = join(stateDir, "sessions", "sess-di-artifact");
+            await mkdir(sessionDir, { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-di-artifact", cwd });
+            await writeJson(join(sessionDir, "skill-active-state.json"), {
+                version: 1,
+                active: true,
+                skill: "deep-interview",
+                phase: "planning",
+                session_id: "sess-di-artifact",
+                active_skills: [{ skill: "deep-interview", phase: "planning", active: true, session_id: "sess-di-artifact" }],
+            });
+            await writeJson(join(sessionDir, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "intent-first",
+                session_id: "sess-di-artifact",
+            });
+            const allowedWrite = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
-                source: "cli",
-                session_id: "sess-team-cli-outside",
+                session_id: "sess-di-artifact",
+                tool_name: "Write",
+                tool_use_id: "tool-di-spec-write",
+                tool_input: { file_path: ".omx/specs/deep-interview-demo.md", content: "# Spec" },
+            }, { cwd });
+            assert.equal(allowedWrite.outputJson, null);
+            const allowedBash = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: "sess-di-artifact",
                 tool_name: "Bash",
-                tool_use_id: "tool-team-cli-outside",
-                tool_input: { command: "omx team status my-team" },
+                tool_use_id: "tool-di-context-bash",
+                tool_input: { command: "cat > .omx/context/demo.md <<'EOF'\n# Context\nEOF" },
             }, { cwd });
-            assert.equal(result.omxEventName, "pre-tool-use");
-            assert.equal(result.outputJson, null);
+            assert.equal(allowedBash.outputJson, null);
+            const allowedAppendBash = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: "sess-di-artifact",
+                tool_name: "Bash",
+                tool_use_id: "tool-di-context-append-bash",
+                tool_input: { command: "echo more context >> .omx/context/demo.md" },
+            }, { cwd });
+            assert.equal(allowedAppendBash.outputJson, null);
+            const blockedBash = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                session_id: "sess-di-artifact",
+                tool_name: "Bash",
+                tool_use_id: "tool-di-src-bash",
+                tool_input: { command: "cat > src/implementation.ts <<'EOF'\nexport const x = 1;\nEOF" },
+            }, { cwd });
+            assert.equal(blockedBash.outputJson?.decision, "block");
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("preserves source-less outside-tmux omx team Bash behavior when no native session evidence exists", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-team-cli-nosource-"));
+    it("allows implementation tools after an explicit deep-interview handoff deactivates the mode", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-deep-interview-handoff-"));
         try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionDir = join(stateDir, "sessions", "sess-di-handoff");
+            await mkdir(sessionDir, { recursive: true });
+            await writeJson(join(sessionDir, "skill-active-state.json"), {
+                version: 1,
+                active: true,
+                skill: "deep-interview",
+                phase: "planning",
+                session_id: "sess-di-handoff",
+                active_skills: [{ skill: "deep-interview", phase: "planning", active: true, session_id: "sess-di-handoff" }],
+            });
+            await writeJson(join(sessionDir, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "intent-first",
+                session_id: "sess-di-handoff",
+            });
+            await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-di-handoff",
+                prompt: "$ralph implement the clarified spec in src/implementation.ts",
+            }, { cwd });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
-                session_id: "sess-team-cli-nosource",
-                tool_name: "Bash",
-                tool_use_id: "tool-team-cli-nosource",
-                tool_input: { command: "omx team status my-team" },
+                session_id: "sess-di-handoff",
+                tool_name: "Edit",
+                tool_use_id: "tool-di-post-handoff-edit",
+                tool_input: { file_path: "src/implementation.ts", old_string: "a", new_string: "b" },
             }, { cwd });
-            assert.equal(result.omxEventName, "pre-tool-use");
             assert.equal(result.outputJson, null);
+            const completed = JSON.parse(await readFile(join(sessionDir, "deep-interview-state.json"), "utf-8"));
+            assert.equal(completed.active, false);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -3109,7 +3812,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-slop-git-priority",
-                tool_input: { command: 'git commit -m "quick hack fallback if it fails"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 git commit -m "quick hack fallback if it fails"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.equal(result.outputJson?.decision, "block");
@@ -3128,7 +3831,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-commit-invalid",
-                tool_input: { command: 'git commit -m "fix tests"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 git commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3153,11 +3856,35 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("allows non-Lore git commit messages when the Lore commit guard is explicitly disabled", async () => {
+    it("blocks PreToolUse git commit when process env explicitly enables the Lore commit guard", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-env-enabled-"));
+        const original = process.env.OMX_LORE_COMMIT_GUARD;
+        try {
+            process.env.OMX_LORE_COMMIT_GUARD = "1";
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-git-commit-lore-env-enabled",
+                tool_input: { command: 'git commit -m "fix tests"' },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(JSON.stringify(result.outputJson), /Lore protocol/);
+        }
+        finally {
+            if (original === undefined)
+                delete process.env.OMX_LORE_COMMIT_GUARD;
+            else
+                process.env.OMX_LORE_COMMIT_GUARD = original;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("allows non-Lore git commit messages when the Lore commit guard is disabled by default", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-disabled-"));
         const original = process.env.OMX_LORE_COMMIT_GUARD;
         try {
-            process.env.OMX_LORE_COMMIT_GUARD = "0";
+            delete process.env.OMX_LORE_COMMIT_GUARD;
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
@@ -3176,6 +3903,60 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("blocks non-Lore git commit messages when the Lore commit guard is enabled in CODEX_HOME config.toml", async () => {
+        await withLoreGuardConfig("1", "config-enabled", async (cwd) => {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-git-commit-lore-config-enabled",
+                tool_input: { command: 'git commit -m "fix: conventional"' },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(JSON.stringify(result.outputJson), /Lore protocol/);
+        });
+    });
+    it("allows non-Lore git commit messages when the Lore commit guard is disabled in CODEX_HOME config.toml", async () => {
+        await withLoreGuardConfig("0", "config-disabled", async (cwd) => {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-git-commit-lore-config-disabled",
+                tool_input: { command: 'git commit -m "fix: use conventional commit"' },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        });
+    });
+    it("lets inline Lore commit guard values override a disabled CODEX_HOME config.toml", async () => {
+        await withLoreGuardConfig("0", "config-inline-enabled", async (cwd) => {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-git-commit-lore-config-inline-enabled",
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 git commit -m "fix: conventional"' },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(JSON.stringify(result.outputJson), /Lore protocol/);
+        });
+    });
+    it("restores default-off Lore guard when env -u removes a disabled CODEX_HOME config source", async () => {
+        await withLoreGuardConfig("0", "config-codex-home-unset", async (cwd) => {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-git-commit-lore-config-codex-home-unset",
+                tool_input: { command: 'env -u CODEX_HOME git commit -m "fix: conventional"' },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        });
+    });
     it("allows non-Lore git commit messages when the Lore commit guard is disabled inline", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-inline-disabled-"));
         try {
@@ -3193,7 +3974,30 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("does not treat newline-separated Lore guard assignment as inline git commit env", async () => {
+    it("allows inline disabled guard to override an enabled process env", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-inline-override-disabled-"));
+        const original = process.env.OMX_LORE_COMMIT_GUARD;
+        try {
+            process.env.OMX_LORE_COMMIT_GUARD = "1";
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-git-commit-lore-inline-override-disabled",
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=0 git commit -m "fix: conventional"' },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            if (original === undefined)
+                delete process.env.OMX_LORE_COMMIT_GUARD;
+            else
+                process.env.OMX_LORE_COMMIT_GUARD = original;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not treat newline-separated Lore guard assignment as inline git commit opt-in", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-newline-assignment-"));
         try {
             const result = await dispatchCodexNativeHook({
@@ -3201,21 +4005,33 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-commit-lore-newline-assignment",
-                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=0\ngit commit -m "fix: conventional"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1\ngit commit -m "fix: conventional"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
-            assert.equal(result.outputJson?.decision, "block");
-            assert.match(JSON.stringify(result.outputJson), /Lore protocol/);
+            assert.equal(result.outputJson, null);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("restores default-on Lore guard when env -u unsets a disabled process env", async () => {
+    it("restores default-off Lore guard when env -u unsets a config.toml fallback", async () => {
+        await withLoreGuardConfig("1", "config-env-unset", async (cwd) => {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreToolUse",
+                cwd,
+                tool_name: "Bash",
+                tool_use_id: "tool-git-commit-lore-config-env-unset",
+                tool_input: { command: 'env -u OMX_LORE_COMMIT_GUARD git commit -m "fix: conventional"' },
+            }, { cwd });
+            assert.equal(result.omxEventName, "pre-tool-use");
+            assert.equal(result.outputJson, null);
+        });
+    });
+    it("restores default-off Lore guard when env -u unsets an enabled process env", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-env-unset-"));
         const original = process.env.OMX_LORE_COMMIT_GUARD;
         try {
-            process.env.OMX_LORE_COMMIT_GUARD = "0";
+            process.env.OMX_LORE_COMMIT_GUARD = "1";
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
@@ -3224,8 +4040,7 @@ exit 0
                 tool_input: { command: 'env -u OMX_LORE_COMMIT_GUARD git commit -m "fix: conventional"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
-            assert.equal(result.outputJson?.decision, "block");
-            assert.match(JSON.stringify(result.outputJson), /Lore protocol/);
+            assert.equal(result.outputJson, null);
         }
         finally {
             if (original === undefined)
@@ -3235,11 +4050,11 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("restores default-on Lore guard when env -i clears a disabled process env", async () => {
+    it("restores default-off Lore guard when env -i clears an enabled process env", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-env-ignore-"));
         const original = process.env.OMX_LORE_COMMIT_GUARD;
         try {
-            process.env.OMX_LORE_COMMIT_GUARD = "0";
+            process.env.OMX_LORE_COMMIT_GUARD = "1";
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "PreToolUse",
                 cwd,
@@ -3248,8 +4063,7 @@ exit 0
                 tool_input: { command: 'env -i PATH=/usr/bin git commit -m "fix: conventional"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
-            assert.equal(result.outputJson?.decision, "block");
-            assert.match(JSON.stringify(result.outputJson), /Lore protocol/);
+            assert.equal(result.outputJson, null);
         }
         finally {
             if (original === undefined)
@@ -3259,7 +4073,7 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("keeps Lore commit enforcement enabled for unknown inline guard values", async () => {
+    it("keeps Lore commit enforcement disabled for unknown inline guard values", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-inline-unknown-"));
         try {
             const result = await dispatchCodexNativeHook({
@@ -3270,8 +4084,7 @@ exit 0
                 tool_input: { command: 'OMX_LORE_COMMIT_GUARD=maybe git commit -m "fix: conventional"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
-            assert.equal(result.outputJson?.decision, "block");
-            assert.match(JSON.stringify(result.outputJson), /Lore protocol/);
+            assert.equal(result.outputJson, null);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -3300,7 +4113,7 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("keeps Lore commit enforcement enabled for unknown guard values", async () => {
+    it("keeps Lore commit enforcement disabled for unknown guard values", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-git-commit-lore-unknown-"));
         const original = process.env.OMX_LORE_COMMIT_GUARD;
         try {
@@ -3313,8 +4126,7 @@ exit 0
                 tool_input: { command: 'git commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
-            assert.equal(result.outputJson?.decision, "block");
-            assert.match(JSON.stringify(result.outputJson), /Lore protocol/);
+            assert.equal(result.outputJson, null);
         }
         finally {
             if (original === undefined)
@@ -3407,7 +4219,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-commit-env-invalid",
-                tool_input: { command: 'HUSKY=0 git commit -m "fix tests"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 HUSKY=0 git commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3437,7 +4249,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-commit-option-invalid",
-                tool_input: { command: 'git -c core.editor=true commit -m "fix tests"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 git -c core.editor=true commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3467,7 +4279,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-exe-commit-env-wrapper-invalid",
-                tool_input: { command: 'env git.exe commit -m "fix tests"' },
+                tool_input: { command: 'env OMX_LORE_COMMIT_GUARD=1 git.exe commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3497,7 +4309,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-exe-commit-invalid",
-                tool_input: { command: 'git.exe commit -m "fix tests"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 git.exe commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3527,7 +4339,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-exe-commit-env-flag-wrapper-invalid",
-                tool_input: { command: 'env -i PATH=/usr/bin git.exe commit -m "fix tests"' },
+                tool_input: { command: 'env -i PATH=/usr/bin OMX_LORE_COMMIT_GUARD=1 git.exe commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3557,7 +4369,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-exe-commit-env-value-wrapper-invalid",
-                tool_input: { command: 'env -u FOO git.exe commit -m "fix tests"' },
+                tool_input: { command: 'env -u FOO OMX_LORE_COMMIT_GUARD=1 git.exe commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3587,7 +4399,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-exe-commit-windows-path-invalid",
-                tool_input: { command: '"C:/Program Files/Git/cmd/git.exe" commit -m "fix tests"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 "C:/Program Files/Git/cmd/git.exe" commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3617,7 +4429,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-exe-commit-windows-backslash-path-invalid",
-                tool_input: { command: '"C:\\Program Files\\Git\\cmd\\git.exe" commit -m "fix tests"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 "C:\\Program Files\\Git\\cmd\\git.exe" commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3647,7 +4459,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-commit-path-invalid",
-                tool_input: { command: '/usr/bin/git commit -m "fix tests"' },
+                tool_input: { command: 'OMX_LORE_COMMIT_GUARD=1 /usr/bin/git commit -m "fix tests"' },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3677,7 +4489,7 @@ exit 0
                 cwd,
                 tool_name: "Bash",
                 tool_use_id: "tool-git-commit-file",
-                tool_input: { command: "git commit -F .git/COMMIT_EDITMSG" },
+                tool_input: { command: "OMX_LORE_COMMIT_GUARD=1 git commit -F .git/COMMIT_EDITMSG" },
             }, { cwd });
             assert.equal(result.omxEventName, "pre-tool-use");
             assert.deepEqual(result.outputJson, {
@@ -3706,7 +4518,7 @@ exit 0
                 tool_use_id: "tool-git-commit-missing-omx-coauthor",
                 tool_input: {
                     command: [
-                        'git commit',
+                        'OMX_LORE_COMMIT_GUARD=1 git commit',
                         '-m "Prevent invalid history from bypassing Lore enforcement"',
                         '-m "The native pre-tool-use hook now blocks inline git commit messages that skip Lore trailers or the required OmX co-author trailer."',
                         '-m "Constraint: Native PreToolUse can only inspect the Bash command text"',
@@ -3741,7 +4553,7 @@ exit 0
                 tool_use_id: "tool-git-commit-valid",
                 tool_input: {
                     command: [
-                        'git commit',
+                        'OMX_LORE_COMMIT_GUARD=1 git commit',
                         '-m "Prevent invalid history from bypassing Lore enforcement"',
                         '-m "The native pre-tool-use hook now blocks inline git commit messages that skip Lore trailers or the required OmX co-author trailer."',
                         '-m "Constraint: Native PreToolUse can only inspect the Bash command text"',
@@ -3767,7 +4579,7 @@ exit 0
                 tool_use_id: "tool-git-commit-compact-coauthor",
                 tool_input: {
                     command: [
-                        'git commit',
+                        'OMX_LORE_COMMIT_GUARD=1 git commit',
                         '-m "Launch lvisai.xyz intro site"',
                         '-m "Co-authored-by: OmX <omx@oh-my-codex.dev>"',
                     ].join(" "),
@@ -3790,7 +4602,7 @@ exit 0
                 tool_use_id: "tool-git-commit-compact-trailers",
                 tool_input: {
                     command: [
-                        'git commit',
+                        'OMX_LORE_COMMIT_GUARD=1 git commit',
                         '-m "Launch lvisai.xyz intro site"',
                         '-m "Constraint: Native PreToolUse can only inspect inline Bash command text\nTested: node --test dist/scripts/__tests__/codex-native-hook.test.js\n\nCo-authored-by: OmX <omx@oh-my-codex.dev>"',
                     ].join(" "),
@@ -3813,7 +4625,7 @@ exit 0
                 tool_use_id: "tool-git-commit-compact-no-separator",
                 tool_input: {
                     command: [
-                        'git commit',
+                        'OMX_LORE_COMMIT_GUARD=1 git commit',
                         '--message="Launch lvisai.xyz intro site\nCo-authored-by: OmX <omx@oh-my-codex.dev>"',
                     ].join(" "),
                 },
@@ -4622,6 +5434,80 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("allows Stop when terminal Autopilot run-state shadows stale session ralplan state", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-autopilot-terminal-run-state-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-stop-autopilot-terminal-run-state";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "run-state.json"), {
+                version: 1,
+                active: false,
+                mode: "autopilot",
+                outcome: "finish",
+                lifecycle_outcome: "finished",
+                current_phase: "complete",
+                completed_at: "2026-05-20T11:00:00.000Z",
+                updated_at: "2026-05-20T11:00:00.000Z",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-stop-autopilot-terminal-run-state",
+                turn_id: "turn-stop-autopilot-terminal-run-state-1",
+                last_assistant_message: "Done. Verification passed.",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("still blocks Stop while Autopilot ralplan state is genuinely non-terminal", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-autopilot-active-ralplan-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-stop-autopilot-active-ralplan";
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "ralplan",
+            });
+            await writeJson(join(stateDir, "sessions", sessionId, "run-state.json"), {
+                version: 1,
+                active: true,
+                mode: "autopilot",
+                outcome: "continue",
+                current_phase: "ralplan",
+                updated_at: "2026-05-20T11:00:00.000Z",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-stop-autopilot-active-ralplan",
+                turn_id: "turn-stop-autopilot-active-ralplan-1",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: "OMX autopilot is still active (phase: ralplan); continue the task and gather fresh verification evidence before stopping.",
+                stopReason: "autopilot_ralplan",
+                systemMessage: "OMX autopilot is still active (phase: ralplan).",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("does not block Stop from stale root Autopilot planning state when the explicit session has no scoped state", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-stale-root-autopilot-planning-"));
         try {
@@ -4772,6 +5658,7 @@ exit 0
                 active: true,
                 current_phase: "team-exec",
                 team_name: "review-team",
+                session_id: "sess-stop-team",
             });
             await writeJson(join(stateDir, "team", "review-team", "phase.json"), {
                 current_phase: "team-verify",
@@ -5544,19 +6431,76 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("returns Stop continuation output from canonical team state when coarse mode state is missing", async () => {
-        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-canonical-"));
+    it("returns Stop continuation output from canonical team state when coarse mode state is missing", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-canonical-"));
+        try {
+            await initTeamState("canonical-team", "canonical stop fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-canonical" });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-team-canonical",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (canonical-team) at phase team-exec; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                stopReason: "team_team-exec",
+                systemMessage: "OMX team pipeline is still active at phase team-exec.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not block Stop from canonical team state owned by another thread", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-canonical-other-thread-"));
+        try {
+            await initTeamState("canonical-other-thread-team", "canonical other-thread stop fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-canonical-thread" });
+            const manifestPath = join(cwd, ".omx", "state", "team", "canonical-other-thread-team", "manifest.v2.json");
+            const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+            await writeJson(manifestPath, {
+                ...manifest,
+                leader: {
+                    ...manifest.leader,
+                    thread_id: "thread-other",
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-team-canonical-thread",
+                thread_id: "thread-current",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks Stop from canonical team state owned by the current thread", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-canonical-current-thread-"));
         try {
-            await initTeamState("canonical-team", "canonical stop fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-canonical" });
+            await initTeamState("canonical-current-thread-team", "canonical current-thread stop fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-canonical-current-thread" });
+            const manifestPath = join(cwd, ".omx", "state", "team", "canonical-current-thread-team", "manifest.v2.json");
+            const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+            await writeJson(manifestPath, {
+                ...manifest,
+                leader: {
+                    ...manifest.leader,
+                    thread_id: "thread-current",
+                },
+            });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
-                session_id: "sess-stop-team-canonical",
+                session_id: "sess-stop-team-canonical-current-thread",
+                thread_id: "thread-current",
             }, { cwd });
             assert.equal(result.omxEventName, "stop");
             assert.deepEqual(result.outputJson, {
                 decision: "block",
-                reason: `OMX team pipeline is still active (canonical-team) at phase team-exec; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                reason: `OMX team pipeline is still active (canonical-current-thread-team) at phase team-exec; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
                 stopReason: "team_team-exec",
                 systemMessage: "OMX team pipeline is still active at phase team-exec.",
             });
@@ -5738,8 +6682,8 @@ exit 0
         const sharedRoot = join(cwd, "shared-root");
         const priorTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
         try {
-            process.env.OMX_TEAM_STATE_ROOT = "shared-root";
-            await initTeamState("canonical-root-team", "canonical stop root fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-root", OMX_TEAM_STATE_ROOT: "shared-root" });
+            process.env.OMX_TEAM_STATE_ROOT = sharedRoot;
+            await initTeamState("canonical-root-team", "canonical stop root fallback", "executor", 1, cwd, undefined, { ...process.env, OMX_SESSION_ID: "sess-stop-team-root", OMX_TEAM_STATE_ROOT: sharedRoot });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
                 cwd,
@@ -5796,13 +6740,14 @@ exit 0
     });
     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 teamStateRoot = join(cwd, "shared-team-state");
         const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
         try {
-            process.env.OMX_TEAM_STATE_ROOT = "shared-team-state";
+            process.env.OMX_TEAM_STATE_ROOT = teamStateRoot;
             await initTeamState("env-root-team", "env root stop fallback", "executor", 1, cwd, undefined, {
                 ...process.env,
                 OMX_SESSION_ID: "sess-stop-team-env-root",
-                OMX_TEAM_STATE_ROOT: "shared-team-state",
+                OMX_TEAM_STATE_ROOT: teamStateRoot,
             });
             const result = await dispatchCodexNativeHook({
                 hook_event_name: "Stop",
@@ -6961,16 +7906,25 @@ exit 0
             assert.equal(result.omxEventName, "stop");
             const reason = String(result.outputJson?.reason);
             assert.match(reason, /Ralph completion audit is missing required evidence/);
-            assert.match(reason, /state\.completion_audit = \{ passed: true, prompt_to_artifact_checklist: \[\.\.\.\], verification_evidence: \[\.\.\.\] \}/);
+            assert.match(reason, /set "completion_audit" on the Ralph state object/);
+            assert.doesNotMatch(reason, /state\.completion_audit/);
             assert.match(reason, /repo-relative JSON file/);
             assert.match(reason, /Markdown artifacts and flat top-level checklist\/evidence fields are not accepted/);
             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.active, false);
+            assert.equal(reopened.current_phase, "complete");
             assert.equal(reopened.completion_audit_gate, "blocked");
             assert.equal(reopened.completion_audit_missing_reason, "missing_completion_audit");
-            assert.equal(typeof reopened.completed_at, "undefined");
+            assert.equal(reopened.completed_at, "2026-05-10T12:00:00.000Z");
+            const repeat = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+                last_assistant_message: "Done. Ralph complete.",
+            }, { cwd });
+            assert.equal(repeat.outputJson?.stopReason, "ralph_completion_audit_missing_completion_audit");
+            assert.doesNotMatch(String(repeat.outputJson?.reason), /Ralph is still active/);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -8531,6 +9485,8 @@ exit 0
                 active: true,
                 current_phase: "team-exec",
                 team_name: "review-team",
+                session_id: "sess-stop-team-refire",
+                thread_id: "thread-stop-team-refire",
             });
             await writeJson(join(stateDir, "team", "review-team", "phase.json"), {
                 current_phase: "team-verify",
@@ -8719,6 +9675,214 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not block Stop from root team state without team_name when no session is known", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-team-no-session-no-name-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(stateDir, { recursive: true });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                mode: "team",
+                current_phase: "starting",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+            }, { 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 team state without team_name for a foreign session", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-team-foreign-no-name-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                mode: "team",
+                current_phase: "starting",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+                thread_id: "thread-current",
+            }, { 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 another thread's stale root team state when no scoped team state exists", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-stale-root-team-thread-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "stale-root-thread-team",
+                session_id: "sess-current",
+                thread_id: "thread-other",
+            });
+            await writeJson(join(stateDir, "team", "stale-root-thread-team", "phase.json"), {
+                current_phase: "team-exec",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+                thread_id: "thread-current",
+            }, { 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 team state with matching session but missing thread ownership", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-team-missing-thread-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "root-missing-thread-team",
+                session_id: "sess-current",
+            });
+            await writeJson(join(stateDir, "team", "root-missing-thread-team", "phase.json"), {
+                current_phase: "team-exec",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+                thread_id: "thread-current",
+            }, { 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 team state when canonical phase is missing", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-root-team-missing-phase-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await mkdir(join(stateDir, "team", "root-missing-phase-team"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "root-missing-phase-team",
+                session_id: "sess-current",
+                thread_id: "thread-current",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+                thread_id: "thread-current",
+            }, { 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 session-scoped team state owned by another thread", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-scoped-team-other-thread-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "sessions", "sess-current", "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "scoped-other-thread-team",
+                session_id: "sess-current",
+                thread_id: "thread-other",
+            });
+            await writeJson(join(stateDir, "team", "scoped-other-thread-team", "phase.json"), {
+                current_phase: "team-exec",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+                thread_id: "thread-current",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks Stop from session-scoped team state owned by the current session and thread", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-scoped-team-current-thread-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            await mkdir(join(stateDir, "sessions", "sess-current"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-current" });
+            await writeJson(join(stateDir, "sessions", "sess-current", "team-state.json"), {
+                active: true,
+                current_phase: "starting",
+                team_name: "scoped-current-team",
+                session_id: "sess-current",
+                thread_id: "thread-current",
+            });
+            await writeJson(join(stateDir, "team", "scoped-current-team", "phase.json"), {
+                current_phase: "team-exec",
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-current",
+                thread_id: "thread-current",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.deepEqual(result.outputJson, {
+                decision: "block",
+                reason: `OMX team pipeline is still active (scoped-current-team) at phase team-exec; continue coordinating until the team reaches a terminal phase.${TEAM_STOP_COMMIT_GUIDANCE}`,
+                stopReason: "team_team-exec",
+                systemMessage: "OMX team pipeline is still active at phase team-exec.",
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("does not block Stop from another session's stale root team state when no scoped team state exists", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-stale-root-team-"));
         try {
@@ -8901,6 +10065,79 @@ describe("codex native hook triage integration", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not activate workflow state for native subagent prompts even when canonical id is the child session", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-subagent-keyword-"));
+        const boxedRoot = await mkdtemp(join(tmpdir(), "omx-native-subagent-keyword-boxed-"));
+        const originalOmxRoot = process.env.OMX_ROOT;
+        const originalOmxStateRoot = process.env.OMX_STATE_ROOT;
+        const originalTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        try {
+            process.env.OMX_ROOT = boxedRoot;
+            delete process.env.OMX_STATE_ROOT;
+            delete process.env.OMX_TEAM_STATE_ROOT;
+            const boxedStateDir = getBaseStateDir(cwd);
+            await mkdir(boxedStateDir, { recursive: true });
+            await writeJson(join(boxedStateDir, "subagent-tracking.json"), {
+                schemaVersion: 1,
+                sessions: {
+                    "omx-parent-session": {
+                        session_id: "omx-parent-session",
+                        leader_thread_id: "parent-native-thread",
+                        updated_at: "2026-05-21T19:04:40.000Z",
+                        threads: {
+                            "parent-native-thread": {
+                                thread_id: "parent-native-thread",
+                                kind: "leader",
+                                first_seen_at: "2026-05-21T19:04:40.000Z",
+                                last_seen_at: "2026-05-21T19:04:40.000Z",
+                                turn_count: 1,
+                            },
+                            "child-native-session": {
+                                thread_id: "child-native-session",
+                                kind: "subagent",
+                                first_seen_at: "2026-05-21T19:04:41.000Z",
+                                last_seen_at: "2026-05-21T19:04:41.000Z",
+                                turn_count: 1,
+                                mode: "review",
+                            },
+                        },
+                    },
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "child-native-session",
+                thread_id: "child-native-session",
+                turn_id: "turn-subagent-review",
+                prompt: [
+                    "Read-only review only. Do not edit files. Do not inspect/mutate OMX state/hooks.",
+                    "Context: The user asked for $autopilot, and this subagent must only review the patch.",
+                ].join("\n\n"),
+            }, { cwd });
+            const additionalContext = String(result.outputJson?.hookSpecificOutput?.additionalContext ?? "");
+            assert.equal(additionalContext, "");
+            assert.equal(existsSync(join(boxedStateDir, "sessions", "child-native-session", "skill-active-state.json")), false);
+            assert.equal(existsSync(join(boxedStateDir, "sessions", "child-native-session", "autopilot-state.json")), false);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "subagent-tracking.json")), false, "subagent tracking must not leak into the source worktree when OMX_ROOT is boxed");
+        }
+        finally {
+            if (originalOmxRoot === undefined)
+                delete process.env.OMX_ROOT;
+            else
+                process.env.OMX_ROOT = originalOmxRoot;
+            if (originalOmxStateRoot === undefined)
+                delete process.env.OMX_STATE_ROOT;
+            else
+                process.env.OMX_STATE_ROOT = originalOmxStateRoot;
+            if (originalTeamStateRoot === undefined)
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            else
+                process.env.OMX_TEAM_STATE_ROOT = originalTeamStateRoot;
+            await rm(cwd, { recursive: true, force: true });
+            await rm(boxedRoot, { recursive: true, force: true });
+        }
+    });
     it("does not inject triage advisory for autopilot keyword prompts", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-triage-keyword-autopilot-"));
         try {
@@ -8925,6 +10162,48 @@ describe("codex native hook triage integration", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("makes autopilot keyword activation observable in state, HUD context, and prompt guidance", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-autopilot-observable-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeSessionStart(cwd, "sess-autopilot-observable");
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-autopilot-observable",
+                thread_id: "thread-autopilot-observable",
+                turn_id: "turn-autopilot-observable",
+                prompt: "$autopilot implement issue #2430",
+            }, { cwd });
+            assert.equal(result.skillState?.skill, "autopilot");
+            assert.equal(result.skillState?.phase, "deep-interview");
+            assert.equal(result.skillState?.initialized_state_path, ".omx/state/sessions/sess-autopilot-observable/autopilot-state.json");
+            const additionalContext = String(result.outputJson?.hookSpecificOutput?.additionalContext ?? "");
+            assert.match(additionalContext, /detected workflow keyword "\$autopilot" -> autopilot/);
+            assert.match(additionalContext, /\$deep-interview -> \$ralplan -> \$ultragoal \(\+ \$team if needed\) -> \$code-review -> \$ultraqa/);
+            assert.match(additionalContext, /deep_interview_gate\.skip_reason/);
+            assert.match(additionalContext, /Do not silently fall back to ordinary \$plan\/ralplan-only handling/);
+            assert.match(additionalContext, /Codex goal-mode handoff guidance/);
+            assert.doesNotMatch(additionalContext, /multi-step goal with no workflow keyword/);
+            const statePath = join(cwd, ".omx", "state", "sessions", "sess-autopilot-observable", "autopilot-state.json");
+            const modeState = JSON.parse(await readFile(statePath, "utf-8"));
+            assert.equal(modeState.active, true);
+            assert.equal(modeState.current_phase, "deep-interview");
+            assert.deepEqual(modeState.state?.phase_cycle, ["deep-interview", "ralplan", "ultragoal", "code-review", "ultraqa"]);
+            assert.deepEqual(modeState.state?.deep_interview_gate, {
+                status: "required",
+                skip_reason: null,
+                rationale: "Autopilot starts at the deep-interview gate by default; clear bounded tasks may skip only with an explicit persisted skip reason.",
+            });
+            const hudState = await readAllState(cwd);
+            assert.equal(hudState.autopilot?.active, true);
+            assert.equal(hudState.autopilot?.current_phase, "deep-interview");
+            assert.match(renderHud(hudState, "focused"), /autopilot:deep-interview/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     // ── Group 2: HEAVY injection ─────────────────────────────────────────────
     it("injects HEAVY advisory and writes prompt-routing-state for a multi-step goal prompt", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-triage-heavy-"));