oh-my-codex 0.18.2 → 0.18.4

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

@@ -14,6 +14,7 @@ import { writeSessionStart } from "../../hooks/session.js";
 import { resetTriageConfigCache } from "../../hooks/triage-config.js";
 import { executeStateOperation } from "../../state/operations.js";
 import { OMX_TMUX_HUD_OWNER_ENV } from "../../hud/reconcile.js";
+import { OMX_TMUX_HUD_LEADER_PANE_ENV } from "../../hud/tmux.js";
 import { readAllState } from "../../hud/state.js";
 import { renderHud } from "../../hud/render.js";
 import { getLegacyWikiDir, serializePage, writePage } from "../../wiki/storage.js";
@@ -42,6 +43,33 @@ async function writeJson(path, value) {
     await mkdir(dirname(path), { recursive: true }).catch(() => { });
     await writeFile(path, JSON.stringify(value, null, 2));
 }
+async function setTeamPaneIds(cwd, teamName, paneIds) {
+    for (const fileName of ["config.json", "manifest.v2.json"]) {
+        const filePath = join(cwd, ".omx", "state", "team", teamName, fileName);
+        const parsed = JSON.parse(await readFile(filePath, "utf-8"));
+        parsed.leader_pane_id = paneIds.leaderPaneId;
+        parsed.workers = (parsed.workers ?? []).map((worker) => ({
+            ...worker,
+            pane_id: worker.name ? paneIds.workerPaneIds[worker.name] ?? worker.pane_id ?? null : worker.pane_id ?? null,
+        }));
+        await writeJson(filePath, parsed);
+    }
+}
+async function withIsolatedHome(prefix, run) {
+    const homeDir = await mkdtemp(join(tmpdir(), `omx-native-hook-home-${prefix}-`));
+    const previousHome = process.env.HOME;
+    try {
+        process.env.HOME = homeDir;
+        return await run(homeDir);
+    }
+    finally {
+        if (typeof previousHome === "string")
+            process.env.HOME = previousHome;
+        else
+            delete process.env.HOME;
+        await rm(homeDir, { recursive: true, force: true });
+    }
+}
 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}-`));
@@ -176,6 +204,7 @@ const TEAM_STOP_COMMIT_GUIDANCE = " If system-generated worker auto-checkpoint c
 const DEFAULT_AUTO_NUDGE_RESPONSE = "continue with the current task only if it is already authorized";
 const TEAM_ENV_KEYS = [
     "OMX_TEAM_WORKER",
+    "OMX_TEAM_INTERNAL_WORKER",
     "OMX_TEAM_STATE_ROOT",
     "OMX_TEAM_LEADER_CWD",
     "OMX_SESSION_ID",
@@ -1291,6 +1320,308 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("injects deep-interview config overrides into UserPromptSubmit developer context", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-config-"));
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "config.toml"), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.05
+standardMaxRounds = 15
+enableChallengeModes = false
+`);
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-deep-interview-config",
+                thread_id: "thread-1",
+                turn_id: "turn-1",
+                prompt: "$deep-interview prove config reflection",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.skill, "deep-interview");
+            const serializedOutput = JSON.stringify(result.outputJson);
+            assert.match(serializedOutput, /Deep-interview config override active/);
+            assert.match(serializedOutput, /threshold=0\.05/);
+            assert.match(serializedOutput, /max_rounds=15/);
+            assert.match(serializedOutput, /enableChallengeModes=false/);
+            const modeState = JSON.parse(await readFile(join(cwd, ".omx", "state", "sessions", "sess-deep-interview-config", "deep-interview-state.json"), "utf-8"));
+            assert.equal(modeState.profile, "standard");
+            assert.equal(modeState.threshold, 0.05);
+            assert.equal(modeState.max_rounds, 15);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("proves UserPromptSubmit context changes before and after adding deep-interview config", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-config-before-after-"));
+        const sessionId = "sess-deep-interview-config-before-after";
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            const before = await withIsolatedHome("deep-interview-config-before-after", async () => (dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-before-after",
+                turn_id: "turn-before",
+                prompt: "$deep-interview prove before config context",
+            }, { cwd })));
+            const beforeOutput = JSON.stringify(before.outputJson);
+            const beforeState = JSON.parse(await readFile(join(cwd, ".omx", "state", "sessions", sessionId, "deep-interview-state.json"), "utf-8"));
+            assert.equal(before.skillState?.skill, "deep-interview");
+            assert.doesNotMatch(beforeOutput, /Deep-interview config override active/);
+            assert.equal(before.skillState?.deep_interview_config, undefined);
+            assert.equal(beforeState.deep_interview_config, undefined);
+            assert.equal(beforeState.threshold, undefined);
+            assert.equal(beforeState.max_rounds, undefined);
+            await writeFile(join(cwd, ".omx", "config.toml"), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.05
+standardMaxRounds = 15
+`);
+            const after = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-before-after",
+                turn_id: "turn-after",
+                prompt: "$deep-interview prove after config context",
+            }, { cwd });
+            const afterOutput = JSON.stringify(after.outputJson);
+            const afterState = JSON.parse(await readFile(join(cwd, ".omx", "state", "sessions", sessionId, "deep-interview-state.json"), "utf-8"));
+            assert.equal(after.skillState?.deep_interview_config?.profile, "standard");
+            assert.match(afterOutput, /Deep-interview config override active/);
+            assert.match(afterOutput, /threshold=0\.05/);
+            assert.match(afterOutput, /max_rounds=15/);
+            assert.equal(afterState.deep_interview_config?.profile, "standard");
+            assert.equal(afterState.threshold, 0.05);
+            assert.equal(afterState.max_rounds, 15);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("injects deep-interview config for mixed workflow prompts that defer execution modes", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-config-mixed-"));
+        const sessionId = "sess-deep-interview-config-mixed";
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "config.toml"), `[omx.deepInterview]
+defaultProfile = "deep"
+deepThreshold = 0.13
+deepMaxRounds = 21
+enableChallengeModes = false
+`);
+            const result = await withIsolatedHome("deep-interview-config-mixed", async () => (dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-mixed-config",
+                turn_id: "turn-mixed-config",
+                prompt: "$autopilot $deep-interview prove mixed config context",
+            }, { cwd })));
+            const serializedOutput = JSON.stringify(result.outputJson);
+            const modeState = JSON.parse(await readFile(join(cwd, ".omx", "state", "sessions", sessionId, "deep-interview-state.json"), "utf-8"));
+            assert.equal(result.skillState?.skill, "deep-interview");
+            assert.deepEqual(result.skillState?.deferred_skills, ["autopilot"]);
+            assert.equal(result.skillState?.deep_interview_config?.profile, "deep");
+            assert.equal(result.skillState?.deep_interview_config?.threshold, 0.13);
+            assert.equal(result.skillState?.deep_interview_config?.maxRounds, 21);
+            assert.equal(result.skillState?.deep_interview_config?.enableChallengeModes, false);
+            assert.match(serializedOutput, /Deep-interview config override active/);
+            assert.match(serializedOutput, /profile=deep/);
+            assert.match(serializedOutput, /threshold=0\.13/);
+            assert.match(serializedOutput, /max_rounds=21/);
+            assert.match(serializedOutput, /enableChallengeModes=false/);
+            assert.equal(modeState.deep_interview_config?.profile, "deep");
+            assert.equal(modeState.profile, "deep");
+            assert.equal(modeState.threshold, 0.13);
+            assert.equal(modeState.max_rounds, 21);
+            assert.equal(modeState.enable_challenge_modes, false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("keeps deep-interview config override context on continuation prompts", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-config-continuation-"));
+        const sessionId = "sess-deep-interview-config-continuation";
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "config.toml"), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.05
+standardMaxRounds = 15
+`);
+            await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-continuation",
+                turn_id: "turn-start",
+                prompt: "$deep-interview prove config continuation",
+            }, { cwd });
+            const continued = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-continuation",
+                turn_id: "turn-continue",
+                prompt: "continue",
+            }, { cwd });
+            const serializedOutput = JSON.stringify(continued.outputJson);
+            const modeState = JSON.parse(await readFile(join(cwd, ".omx", "state", "sessions", sessionId, "deep-interview-state.json"), "utf-8"));
+            assert.equal(continued.skillState?.skill, "deep-interview");
+            assert.match(serializedOutput, /Deep-interview config override active/);
+            assert.match(serializedOutput, /threshold=0\.05/);
+            assert.match(serializedOutput, /max_rounds=15/);
+            assert.equal(modeState.profile, "standard");
+            assert.equal(modeState.threshold, 0.05);
+            assert.equal(modeState.max_rounds, 15);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("keeps explicit deep-interview profile flags reflected on continuation prompts", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-config-profile-continuation-"));
+        const sessionId = "sess-deep-interview-config-profile-continuation";
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "config.toml"), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.22
+standardMaxRounds = 13
+deepThreshold = 0.13
+deepMaxRounds = 21
+`);
+            await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-profile-continuation",
+                turn_id: "turn-start",
+                prompt: "$deep-interview --deep prove explicit profile continuation",
+            }, { cwd });
+            const continued = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-profile-continuation",
+                turn_id: "turn-continue",
+                prompt: "continue",
+            }, { cwd });
+            const serializedOutput = JSON.stringify(continued.outputJson);
+            const modeState = JSON.parse(await readFile(join(cwd, ".omx", "state", "sessions", sessionId, "deep-interview-state.json"), "utf-8"));
+            assert.equal(continued.skillState?.skill, "deep-interview");
+            assert.equal(continued.skillState?.deep_interview_config?.profile, "deep");
+            assert.match(serializedOutput, /Deep-interview config override active/);
+            assert.match(serializedOutput, /profile=deep/);
+            assert.match(serializedOutput, /threshold=0\.13/);
+            assert.match(serializedOutput, /max_rounds=21/);
+            assert.equal(modeState.deep_interview_config?.profile, "deep");
+            assert.equal(modeState.profile, "deep");
+            assert.equal(modeState.threshold, 0.13);
+            assert.equal(modeState.max_rounds, 21);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("keeps the documented deep-interview Suggested Config reflected in UserPromptSubmit context", async () => {
+        const skillDoc = await readFile(join(process.cwd(), "skills", "deep-interview", "SKILL.md"), "utf-8");
+        const markerIndex = skillDoc.indexOf("## Suggested Config (optional)");
+        assert.notEqual(markerIndex, -1);
+        const configMatch = skillDoc.slice(markerIndex).match(/```toml\n([\s\S]*?)\n```/);
+        assert.ok(configMatch);
+        const documentedConfig = configMatch[1]?.trimEnd();
+        assert.ok(documentedConfig);
+        assert.match(documentedConfig, /standardThreshold = 0\.20/);
+        assert.match(documentedConfig, /standardMaxRounds = 12/);
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-doc-config-"));
+        const sessionId = "sess-deep-interview-doc-config";
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "config.toml"), `${documentedConfig}\n`);
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-doc-config",
+                turn_id: "turn-doc-config",
+                prompt: "$deep-interview prove documented config context",
+            }, { cwd });
+            const serializedOutput = JSON.stringify(result.outputJson);
+            const modeState = JSON.parse(await readFile(join(cwd, ".omx", "state", "sessions", sessionId, "deep-interview-state.json"), "utf-8"));
+            assert.equal(result.skillState?.deep_interview_config?.profile, "standard");
+            assert.equal(result.skillState?.deep_interview_config?.threshold, 0.2);
+            assert.equal(result.skillState?.deep_interview_config?.maxRounds, 12);
+            assert.match(serializedOutput, /Deep-interview config override active/);
+            assert.match(serializedOutput, /profile=standard/);
+            assert.match(serializedOutput, /threshold=0\.2/);
+            assert.match(serializedOutput, /max_rounds=12/);
+            assert.equal(modeState.deep_interview_config?.profile, "standard");
+            assert.equal(modeState.profile, "standard");
+            assert.equal(modeState.threshold, 0.2);
+            assert.equal(modeState.max_rounds, 12);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("injects deep-interview config overrides when state is boxed under OMX_ROOT", async () => {
+        const root = await mkdtemp(join(tmpdir(), "omx-native-hook-deep-interview-config-boxed-"));
+        const cwd = join(root, "source");
+        const omxRoot = join(root, "box");
+        const sessionId = "sess-boxed-deep-interview-config";
+        const previousOmxRoot = process.env.OMX_ROOT;
+        const previousOmxStateRoot = process.env.OMX_STATE_ROOT;
+        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        try {
+            await mkdir(join(cwd, ".omx", "state"), { recursive: true });
+            await writeFile(join(cwd, ".omx", "config.toml"), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.05
+standardMaxRounds = 15
+`);
+            process.env.OMX_ROOT = omxRoot;
+            delete process.env.OMX_STATE_ROOT;
+            delete process.env.OMX_TEAM_STATE_ROOT;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-boxed",
+                turn_id: "turn-boxed",
+                prompt: "$deep-interview prove boxed config reflection",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(result.skillState?.initialized_state_path, `.omx/state/sessions/${sessionId}/deep-interview-state.json`);
+            const boxedStatePath = join(omxRoot, ".omx", "state", "sessions", sessionId, "deep-interview-state.json");
+            assert.equal(existsSync(boxedStatePath), true);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", sessionId, "deep-interview-state.json")), false);
+            const serializedOutput = JSON.stringify(result.outputJson);
+            assert.match(serializedOutput, /Deep-interview config override active/);
+            assert.match(serializedOutput, /threshold=0\.05/);
+            assert.match(serializedOutput, /max_rounds=15/);
+        }
+        finally {
+            if (typeof previousOmxRoot === "string")
+                process.env.OMX_ROOT = previousOmxRoot;
+            else
+                delete process.env.OMX_ROOT;
+            if (typeof previousOmxStateRoot === "string")
+                process.env.OMX_STATE_ROOT = previousOmxStateRoot;
+            else
+                delete process.env.OMX_STATE_ROOT;
+            if (typeof previousTeamStateRoot === "string")
+                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            await rm(root, { recursive: true, force: true });
+        }
+    });
     it("records boxed keyword activation mode detail and skill state under OMX_ROOT", async () => {
         const root = await mkdtemp(join(tmpdir(), "omx-native-hook-boxed-"));
         const cwd = join(root, "source");
@@ -1605,6 +1936,36 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not repeat ultragoal Stop recovery after a safe completed-aggregate microgoal blocker is recorded", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-aggregate-blocked-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "ultragoal", "goals.json"), {
+                version: 1,
+                codexGoalMode: "aggregate",
+                activeGoalId: "G001-demo",
+                goals: [{
+                        id: "G001-demo",
+                        status: "in_progress",
+                        objective: "Demo goal",
+                        failureReason: "aggregate Codex goal already complete and unreconcilable while repo-native .omx/ultragoal/goals.json still has an in-progress microgoal; stop the recovery loop",
+                    }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-ultragoal-aggregate-blocked-stop",
+                thread_id: "thread-ultragoal-aggregate-blocked-stop",
+                stop_hook_active: true,
+                last_assistant_message: "Goal complete.",
+            }, { cwd });
+            assert.notEqual(result.outputJson?.decision, "block");
+            assert.notEqual(result.outputJson?.stopReason, "ultragoal_codex_goal_snapshot_required");
+            assert.doesNotMatch(JSON.stringify(result.outputJson), /omx ultragoal checkpoint --goal-id G001-demo --status complete/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("does not block ultragoal Stop after task-scoped reconciliation finishes exploded bookkeeping", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-ultragoal-reconciled-stop-"));
         try {
@@ -2852,6 +3213,178 @@ export async function onHookEvent(event) {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("skips prompt-submit HUD reconciliation for confirmed team worker panes", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-team-worker-skip-"));
+        try {
+            const teamName = "hud-worker-skip";
+            await initTeamState(teamName, "skip worker HUD reconcile", "executor", 1, cwd);
+            await setTeamPaneIds(cwd, teamName, {
+                leaderPaneId: "%42",
+                workerPaneIds: { "worker-1": "%10" },
+            });
+            process.env.TMUX = "1";
+            process.env.TMUX_PANE = "%10";
+            process.env.OMX_TEAM_INTERNAL_WORKER = `${teamName}/worker-1`;
+            process.env.OMX_TEAM_WORKER = `${teamName}/worker-1`;
+            process.env[OMX_TMUX_HUD_OWNER_ENV] = "1";
+            let reconcileCalls = 0;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-hud-team-worker",
+                prompt: "$ralplan prepare plan",
+            }, {
+                cwd,
+                reconcileHudForPromptSubmitFn: async () => {
+                    reconcileCalls += 1;
+                    return { status: "recreated", paneId: "%9", desiredHeight: 3, duplicateCount: 0 };
+                },
+            });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(reconcileCalls, 0);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("preserves prompt-submit HUD reconciliation for team leader panes", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-team-leader-preserve-"));
+        try {
+            const teamName = "hud-leader-keep";
+            await initTeamState(teamName, "preserve leader HUD reconcile", "executor", 1, cwd);
+            await setTeamPaneIds(cwd, teamName, {
+                leaderPaneId: "%42",
+                workerPaneIds: { "worker-1": "%10" },
+            });
+            process.env.TMUX = "1";
+            process.env.TMUX_PANE = "%42";
+            process.env[OMX_TMUX_HUD_OWNER_ENV] = "1";
+            let reconcileCall = null;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-hud-team-leader",
+                prompt: "$ralplan prepare plan",
+            }, {
+                cwd,
+                reconcileHudForPromptSubmitFn: async (hookCwd, deps = {}) => {
+                    reconcileCall = { cwd: hookCwd, sessionId: deps.sessionId };
+                    return { status: "recreated", paneId: "%9", desiredHeight: 3, duplicateCount: 0 };
+                },
+            });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.deepEqual(reconcileCall, { cwd, sessionId: "sess-hud-team-leader" });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("preserves prompt-submit HUD reconciliation when worker pane detection is ambiguous", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-team-worker-ambiguous-"));
+        try {
+            const teamName = "hud-worker-ambiguous";
+            await initTeamState(teamName, "fail closed for ambiguous worker HUD reconcile", "executor", 1, cwd);
+            await setTeamPaneIds(cwd, teamName, {
+                leaderPaneId: "%42",
+                workerPaneIds: { "worker-1": "%10" },
+            });
+            process.env.TMUX = "1";
+            process.env.TMUX_PANE = "%99";
+            process.env.OMX_TEAM_INTERNAL_WORKER = `${teamName}/worker-1`;
+            process.env.OMX_TEAM_WORKER = `${teamName}/worker-1`;
+            process.env[OMX_TMUX_HUD_OWNER_ENV] = "1";
+            let reconcileCalls = 0;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: "sess-hud-team-worker-ambiguous",
+                prompt: "$ralplan prepare plan",
+            }, {
+                cwd,
+                reconcileHudForPromptSubmitFn: async () => {
+                    reconcileCalls += 1;
+                    return { status: "recreated", paneId: "%9", desiredHeight: 3, duplicateCount: 0 };
+                },
+            });
+            assert.equal(result.omxEventName, "keyword-detector");
+            assert.equal(reconcileCalls, 1);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("preserves prompt-submit HUD reconciliation for native subagents even with worker pane env", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-subagent-worker-preserve-"));
+        try {
+            const teamName = "hud-subagent-keep";
+            await initTeamState(teamName, "preserve subagent HUD reconcile", "executor", 1, cwd);
+            await setTeamPaneIds(cwd, teamName, {
+                leaderPaneId: "%42",
+                workerPaneIds: { "worker-1": "%10" },
+            });
+            const stateDir = join(cwd, ".omx", "state");
+            const canonicalSessionId = "sess-subagent-hud-parent";
+            const leaderNativeSessionId = "native-subagent-hud-parent";
+            const childNativeSessionId = "native-subagent-hud-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: "verifier",
+                            },
+                        },
+                    },
+                },
+            });
+            process.env.TMUX = "1";
+            process.env.TMUX_PANE = "%10";
+            process.env.OMX_TEAM_INTERNAL_WORKER = `${teamName}/worker-1`;
+            process.env.OMX_TEAM_WORKER = `${teamName}/worker-1`;
+            process.env[OMX_TMUX_HUD_OWNER_ENV] = "1";
+            let reconcileCall = null;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: childNativeSessionId,
+                thread_id: childNativeSessionId,
+                turn_id: "turn-subagent-hud-child",
+                prompt: "Review the worker patch literally; do not activate $ralplan.",
+            }, {
+                cwd,
+                reconcileHudForPromptSubmitFn: async (hookCwd, deps = {}) => {
+                    reconcileCall = { cwd: hookCwd, sessionId: deps.sessionId };
+                    return { status: "recreated", paneId: "%9", desiredHeight: 3, duplicateCount: 0 };
+                },
+            });
+            assert.equal(result.outputJson, null);
+            assert.deepEqual(reconcileCall, { cwd, sessionId: canonicalSessionId });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("runs prompt-submit HUD reconciliation as a best-effort tmux-only side effect", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-reconcile-"));
         const originalTmux = process.env.TMUX;
@@ -2925,6 +3458,75 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("reuses an existing owner-tagged HUD pane when UserPromptSubmit revives with the canonical session id", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-reuse-"));
+        const originalTmux = process.env.TMUX;
+        const originalTmuxPane = process.env.TMUX_PANE;
+        const originalPath = process.env.PATH;
+        const originalHudOwner = process.env[OMX_TMUX_HUD_OWNER_ENV];
+        try {
+            process.env.TMUX = "1";
+            process.env.TMUX_PANE = "%1";
+            process.env[OMX_TMUX_HUD_OWNER_ENV] = "1";
+            const canonicalSessionId = "omx-canonical-hud-reuse";
+            const nativeSessionId = "codex-native-hud-reuse";
+            await mkdir(join(cwd, ".omx", "state", "sessions", canonicalSessionId), { recursive: true });
+            await writeSessionStart(cwd, canonicalSessionId);
+            const binDir = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-reuse-bin-"));
+            const tmuxLog = join(cwd, "tmux.log");
+            await writeFile(join(binDir, "tmux"), `#!/usr/bin/env bash
+set -euo pipefail
+printf '%s\n' "$*" >> ${JSON.stringify(tmuxLog)}
+case "$1" in
+  list-panes)
+    printf '%%1\tcodex\tcodex\n'
+    printf '%%2\tnode\texec env OMX_TMUX_HUD_OWNER='"'"'1'"'"' ${OMX_TMUX_HUD_LEADER_PANE_ENV}='"'"'%%1'"'"' /node /omx.js hud --watch\n'
+    ;;
+  display-message)
+    printf '80\t24\n'
+    ;;
+  resize-pane)
+    ;;
+  split-window)
+    printf '%%9\n'
+    ;;
+esac
+`);
+            await chmod(join(binDir, "tmux"), 0o755);
+            process.env.PATH = `${binDir}:${originalPath}`;
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "UserPromptSubmit",
+                cwd,
+                session_id: nativeSessionId,
+                thread_id: "thread-hud-reuse",
+                turn_id: "turn-hud-reuse",
+                prompt: "$ralplan prepare plan",
+            }, { cwd });
+            assert.equal(result.omxEventName, "keyword-detector");
+            const tmuxCalls = await readFile(tmuxLog, "utf-8");
+            assert.match(tmuxCalls, /list-panes -t %1 -F/);
+            assert.match(tmuxCalls, /resize-pane -t %2 -y 3/);
+            assert.doesNotMatch(tmuxCalls, /split-window/);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", canonicalSessionId, "ralplan-state.json")), true);
+            assert.equal(existsSync(join(cwd, ".omx", "state", "sessions", nativeSessionId, "ralplan-state.json")), false);
+        }
+        finally {
+            if (originalTmux === undefined)
+                delete process.env.TMUX;
+            else
+                process.env.TMUX = originalTmux;
+            if (originalTmuxPane === undefined)
+                delete process.env.TMUX_PANE;
+            else
+                process.env.TMUX_PANE = originalTmuxPane;
+            if (originalHudOwner === undefined)
+                delete process.env[OMX_TMUX_HUD_OWNER_ENV];
+            else
+                process.env[OMX_TMUX_HUD_OWNER_ENV] = originalHudOwner;
+            process.env.PATH = originalPath;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("skips prompt-submit HUD reconciliation inside unowned tmux panes", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-hud-unowned-"));
         const originalTmux = process.env.TMUX;
@@ -7263,6 +7865,65 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not report ralplan subagent waiting when notify-fallback already recorded completion", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-skill-subagent-complete-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const now = new Date().toISOString();
+            await mkdir(join(stateDir, "sessions", "sess-stop-skill-subagent-complete"), { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-stop-skill-subagent-complete" });
+            await writeJson(join(stateDir, "sessions", "sess-stop-skill-subagent-complete", "skill-active-state.json"), {
+                active: true,
+                skill: "ralplan",
+                phase: "planning",
+            });
+            await writeJson(join(stateDir, "sessions", "sess-stop-skill-subagent-complete", "ralplan-state.json"), {
+                active: true,
+                current_phase: "planning",
+            });
+            await writeJson(join(stateDir, "subagent-tracking.json"), {
+                schemaVersion: 1,
+                sessions: {
+                    "sess-stop-skill-subagent-complete": {
+                        session_id: "sess-stop-skill-subagent-complete",
+                        leader_thread_id: "leader-1",
+                        updated_at: now,
+                        threads: {
+                            "leader-1": {
+                                thread_id: "leader-1",
+                                kind: "leader",
+                                first_seen_at: now,
+                                last_seen_at: now,
+                                turn_count: 1,
+                            },
+                            "sub-1": {
+                                thread_id: "sub-1",
+                                kind: "subagent",
+                                first_seen_at: now,
+                                last_seen_at: now,
+                                completed_at: now,
+                                last_completed_turn_id: "turn-complete-1",
+                                completion_source: "notify-fallback-watcher",
+                                turn_count: 2,
+                            },
+                        },
+                    },
+                },
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-stop-skill-subagent-complete",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson?.decision, "block");
+            assert.doesNotMatch(String(result.outputJson?.reason ?? ""), /waiting for 1 active native subagent thread/);
+            assert.equal(result.outputJson?.stopReason, "skill_ralplan_planning_continue_artifact");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("does not block on stale root ralplan skill when the explicit session-scoped canonical skill state is absent", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-stale-root-skill-"));
         try {
@@ -10981,4 +11642,61 @@ describe("codex native hook triage integration", () => {
         }
     });
 });
+describe('native Stop autopilot deep-interview wait', () => {
+    it('does not force continued execution while autopilot is waiting on a deep-interview omx question', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-native-hook-autopilot-question-wait-'));
+        try {
+            const sessionId = 'sess-autopilot-wait';
+            const sessionDir = join(cwd, '.omx', 'state', 'sessions', sessionId);
+            await writeJson(join(cwd, '.omx', 'state', 'session.json'), { session_id: sessionId });
+            await writeJson(join(sessionDir, 'autopilot-state.json'), {
+                mode: 'autopilot',
+                active: true,
+                current_phase: 'waiting-for-user',
+                run_outcome: 'blocked_on_user',
+                lifecycle_outcome: 'askuserQuestion',
+                session_id: sessionId,
+                state: {
+                    deep_interview_question: {
+                        status: 'waiting_for_user',
+                        source: 'omx-question',
+                        obligation_id: 'obligation-stop-1',
+                        previous_phase: 'deep-interview',
+                    },
+                },
+            });
+            await writeJson(join(sessionDir, 'deep-interview-state.json'), {
+                mode: 'deep-interview',
+                active: false,
+                current_phase: 'intent-first',
+                lifecycle_outcome: 'askuserQuestion',
+                run_outcome: 'blocked_on_user',
+                session_id: sessionId,
+                question_enforcement: {
+                    obligation_id: 'obligation-stop-1',
+                    source: 'omx-question',
+                    status: 'pending',
+                    lifecycle_outcome: 'askuserQuestion',
+                    requested_at: '2026-04-19T00:00:00.000Z',
+                },
+            });
+            await writeJson(join(sessionDir, 'skill-active-state.json'), {
+                active: true,
+                skill: 'autopilot',
+                phase: 'deep-interview',
+                session_id: sessionId,
+                active_skills: [{ skill: 'autopilot', phase: 'deep-interview', active: true, session_id: sessionId }],
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: 'Stop',
+                session_id: sessionId,
+                thread_id: 'thread-autopilot-wait',
+            }, { cwd });
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+});
 //# sourceMappingURL=codex-native-hook.test.js.map