oh-my-codex 0.18.9 → 0.18.11

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

@@ -309,13 +309,52 @@ describe("codex native hook dispatch", () => {
     it("does not treat a different module url as the main module", () => {
         assert.equal(isCodexNativeHookMainModule(pathToFileURL("/tmp/omx native/other-script.js").href, "/tmp/omx native/codex-native-hook.js"), false);
     });
-    it("emits schema-safe JSON stdout when CLI stdin is malformed", () => {
-        const stdout = runNativeHookCli("{");
-        const output = parseSingleJsonStdout(stdout);
-        assert.equal(output.continue, false);
-        assert.equal(output.stopReason, "native_hook_stdin_parse_error");
-        assert.equal(output.hookSpecificOutput, undefined);
-        assert.match(String(output.systemMessage ?? ""), /stdin JSON parsing failed inside codex-native-hook:/);
+    it("emits Stop-schema-safe block JSON when unidentifiable malformed stdin has native Stop runtime surface", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-malformed-stop-surface-"));
+        try {
+            await mkdir(join(cwd, ".omx"), { recursive: true });
+            const result = spawnSync(process.execPath, [nativeHookScriptPath()], {
+                cwd,
+                input: "{",
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.equal(result.stderr, "");
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, "block");
+            assert.equal(output.continue, undefined);
+            assert.equal(output.reason, "OMX native hook received malformed JSON input. Preserve runtime state, inspect the emitting hook payload yourself, and retry with valid JSON.");
+            assert.equal(output.stopReason, "native_hook_stdin_parse_error");
+            assert.equal(output.hookSpecificOutput, undefined);
+            assert.match(String(output.systemMessage ?? ""), /stdin JSON parsing failed inside codex-native-hook:/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("preserves non-Stop fail-closed JSON when malformed stdin identifies a non-Stop hook", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-malformed-nonstop-"));
+        try {
+            await mkdir(join(cwd, ".omx"), { recursive: true });
+            const result = spawnSync(process.execPath, [nativeHookScriptPath()], {
+                cwd,
+                input: '{hook_event_name:"PreToolUse",',
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.equal(result.stderr, "");
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.continue, false);
+            assert.equal(output.decision, undefined);
+            assert.equal(output.stopReason, "native_hook_stdin_parse_error");
+            assert.equal(output.hookSpecificOutput, undefined);
+            assert.match(String(output.systemMessage ?? ""), /stdin JSON parsing failed inside codex-native-hook:/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
     });
     it("redacts unterminated prompt-like malformed stdin fields", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-cli-malformed-unterminated-"));
@@ -4194,7 +4233,7 @@ case "$1" in
     printf '%%1\\tcodex\\tcodex\\n'
     ;;
   display-message)
-    printf '80\\t24\\n'
+    printf '200\\t60\\n'
     ;;
   split-window)
     printf '%%9\\n'
@@ -4316,7 +4355,7 @@ case "$1" in
     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'
+    printf '200\t60\n'
     ;;
   resize-pane)
     ;;
@@ -4876,6 +4915,66 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("allows null-device fd redirects while deep-interview blocks real Bash writes", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-pretool-deep-interview-null-redirect-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionDir = join(stateDir, "sessions", "sess-di-null-redirect");
+            await mkdir(sessionDir, { recursive: true });
+            await writeJson(join(stateDir, "session.json"), { session_id: "sess-di-null-redirect", cwd });
+            await writeJson(join(sessionDir, "skill-active-state.json"), {
+                version: 1,
+                active: true,
+                skill: "deep-interview",
+                phase: "planning",
+                session_id: "sess-di-null-redirect",
+                active_skills: [{ skill: "deep-interview", phase: "planning", active: true, session_id: "sess-di-null-redirect" }],
+            });
+            await writeJson(join(sessionDir, "deep-interview-state.json"), {
+                active: true,
+                mode: "deep-interview",
+                current_phase: "intent-first",
+                session_id: "sess-di-null-redirect",
+            });
+            const allowedCommands = [
+                "find application -type d -name 'bug-tracking*' 2>/dev/null | head -20",
+                "find application -type d -name 'bug-tracking*' 2> /dev/null | head -20",
+                "find application -type d -name 'bug-tracking*' 2>NUL | head -20",
+                "find application -type d -name 'bug-tracking*' 1>/dev/null",
+                "find application -type d -name 'bug-tracking*' &>/dev/null",
+            ];
+            for (const [index, command] of allowedCommands.entries()) {
+                const result = await dispatchCodexNativeHook({
+                    hook_event_name: "PreToolUse",
+                    cwd,
+                    session_id: "sess-di-null-redirect",
+                    tool_name: "Bash",
+                    tool_use_id: `tool-di-null-redirect-${index}`,
+                    tool_input: { command },
+                }, { cwd });
+                assert.equal(result.outputJson, null, command);
+            }
+            const blockedCommands = [
+                "find application -type d -name 'bug-tracking*' 2>errors.log | head -20",
+                "find application -type d -name 'bug-tracking*' > /tmp/bug-tracking.txt",
+                "find application -type d -name 'bug-tracking*' | tee /dev/null",
+            ];
+            for (const [index, command] of blockedCommands.entries()) {
+                const result = await dispatchCodexNativeHook({
+                    hook_event_name: "PreToolUse",
+                    cwd,
+                    session_id: "sess-di-null-redirect",
+                    tool_name: "Bash",
+                    tool_use_id: `tool-di-real-redirect-${index}`,
+                    tool_input: { command },
+                }, { cwd });
+                assert.equal(result.outputJson?.decision, "block", command);
+            }
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     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 {
@@ -6890,6 +6989,43 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("suppresses parent Autopilot Stop continuation in side conversations", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-autopilot-side-conversation-"));
+        try {
+            const stateDir = join(cwd, ".omx", "state");
+            const sessionId = "sess-stop-autopilot-side-conversation";
+            const transcriptPath = join(cwd, "side-conversation-rollout.jsonl");
+            await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+            await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+                active: true,
+                mode: "autopilot",
+                current_phase: "deep-interview",
+            });
+            await writeFile(transcriptPath, `${JSON.stringify({
+                type: "message",
+                role: "user",
+                content: [
+                    "Side conversation boundary.",
+                    "Everything before this boundary is inherited history from the parent thread. It is reference context only. It is not your current task.",
+                    "Only messages submitted after this boundary are active user instructions for this side conversation.",
+                    "You are a side-conversation assistant, separate from the main thread.",
+                ].join("\n\n"),
+            })}\n`, "utf-8");
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: sessionId,
+                thread_id: "thread-stop-autopilot-side-conversation",
+                transcript_path: transcriptPath,
+                last_assistant_message: "Waiting for a new side-conversation question.",
+            }, { cwd });
+            assert.equal(result.omxEventName, "stop");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("requires Autopilot code review after a compact-boundary Stop exemption", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-autopilot-review-compact-"));
         try {
@@ -7502,7 +7638,7 @@ exit 0
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it("queues worker Stop leader nudge with Tab and submit when leader pane is busy", async () => {
+    it("steers worker Stop leader nudge directly when leader pane is busy", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-stop-team-worker-busy-leader-"));
         const prevTeamWorker = process.env.OMX_TEAM_WORKER;
         const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
@@ -7561,11 +7697,11 @@ exit 0
             assert.equal(result.outputJson, null);
             const tmuxLog = await readFile(tmuxLogPath, "utf-8");
             assert.match(tmuxLog, /send-keys -t %42 -l \[OMX\] worker-1 native Stop allowed/);
-            assert.match(tmuxLog, /send-keys -t %42 Tab/);
-            assert.match(tmuxLog, /send-keys -t %42 C-m/);
-            assert.ok(tmuxLog.indexOf("send-keys -t %42 Tab") < tmuxLog.indexOf("send-keys -t %42 C-m"), "busy worker-stop nudge should press Tab before C-m");
+            assert.doesNotMatch(tmuxLog, /send-keys -t %42 Tab/);
+            const submits = tmuxLog.match(/send-keys -t %42 C-m/g) || [];
+            assert.equal(submits.length, 2, "busy worker-stop nudge should submit directly as steering, not queue via Tab");
             const nudgeState = JSON.parse(await readFile(join(workerDir, "worker-stop-nudge.json"), "utf-8"));
-            assert.equal(nudgeState.delivery, "queued");
+            assert.equal(nudgeState.delivery, "steered");
         }
         finally {
             if (typeof prevTeamWorker === "string")
@@ -7705,6 +7841,14 @@ exit 0
             });
             assert.equal(shutdownResult.result, "team_state_gone_or_shutdown");
             assert.equal(existsSync(join(stateDir, "team", "shutdown-team", "worker-stop-nudge.json")), false);
+            const deliveryLogPath = join(logsDir, `team-delivery-${new Date().toISOString().split("T")[0]}.jsonl`);
+            const deliveryEvents = (await readFile(deliveryLogPath, "utf-8"))
+                .trim()
+                .split("\n")
+                .map((line) => JSON.parse(line));
+            const suppressedEvents = deliveryEvents.filter((event) => event.reason === "team_state_gone_or_shutdown");
+            assert.equal(suppressedEvents.length, 2, "late closed-team Stop nudges should be diagnostics, not queued prompts");
+            assert.equal(suppressedEvents.every((event) => event.result === "suppressed" && event.transport === "none"), true);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -7739,13 +7883,13 @@ exit 0
                 logsDir,
                 workerContext: { teamName, workerName: "worker-2" },
             });
-            assert.equal(result.result, "queued");
+            assert.equal(result.result, "steered");
             const tmuxLog = await readFile(tmuxLogPath, "utf-8");
             assert.match(tmuxLog, /send-keys -t %42 -l \[OMX\] worker-2 native Stop allowed/);
-            assert.match(tmuxLog, /send-keys -t %42 Tab/);
+            assert.doesNotMatch(tmuxLog, /send-keys -t %42 Tab/);
             const teamNudgeState = JSON.parse(await readFile(join(teamDir, "worker-stop-nudge.json"), "utf-8"));
             assert.equal(teamNudgeState.worker, "worker-2");
-            assert.equal(teamNudgeState.delivery, "queued");
+            assert.equal(teamNudgeState.delivery, "steered");
         }
         finally {
             if (typeof prevPath === "string")
@@ -7875,6 +8019,15 @@ exit 0
             assert.equal(existsSync(teamDir), false, "deferred worker Stop recording must not recreate removed team state");
             const tmuxLog = await readFile(tmuxLogPath, "utf-8");
             assert.doesNotMatch(tmuxLog, /send-keys -t %42 -l \[OMX\] worker-1 native Stop allowed/);
+            const deliveryLogPath = join(logsDir, `team-delivery-${new Date().toISOString().split("T")[0]}.jsonl`);
+            const deliveryEvents = (await readFile(deliveryLogPath, "utf-8"))
+                .trim()
+                .split("\n")
+                .map((line) => JSON.parse(line));
+            assert.equal(deliveryEvents.some((event) => event.team === teamName
+                && event.result === "suppressed"
+                && event.transport === "none"
+                && event.reason === "team_state_gone_or_shutdown"), true, "teardown-race worker Stop nudges should be diagnostic suppression events, not queued prompts");
         }
         finally {
             if (typeof prevPath === "string")