oh-my-codex 0.16.1 → 0.16.3

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

@@ -14,6 +14,8 @@ import { writeSessionStart } from "../../hooks/session.js";
 import { resetTriageConfigCache } from "../../hooks/triage-config.js";
 import { executeStateOperation } from "../../state/operations.js";
 import { OMX_TMUX_HUD_OWNER_ENV } from "../../hud/reconcile.js";
+import { writePage } from "../../wiki/storage.js";
+import { WIKI_SCHEMA_VERSION } from "../../wiki/types.js";
 function nativeHookScriptPath() {
     return join(process.cwd(), "dist", "scripts", "codex-native-hook.js");
 }
@@ -176,6 +178,8 @@ describe("codex native hook config", () => {
             "PreToolUse",
             "PostToolUse",
             "UserPromptSubmit",
+            "PreCompact",
+            "PostCompact",
             "Stop",
         ]);
         const sessionStart = config.hooks.SessionStart[0];
@@ -195,6 +199,10 @@ describe("codex native hook config", () => {
         assert.equal(userPromptSubmit.hooks?.[0]?.statusMessage, undefined);
         const stop = config.hooks.Stop[0];
         assert.equal(stop.hooks?.[0]?.timeout, 30);
+        const postCompact = config.hooks.PostCompact[0];
+        assert.equal(postCompact.matcher, undefined);
+        assert.match(String(postCompact.hooks?.[0]?.command || ""), /codex-native-hook\.js"?$/);
+        assert.doesNotMatch(String(postCompact.hooks?.[0]?.command || ""), /PostCompact Nudge|additionalContext|printf/);
     });
 });
 describe("codex native hook dispatch", () => {
@@ -392,8 +400,100 @@ describe("codex native hook dispatch", () => {
         assert.equal(mapCodexHookEventToOmxEvent("UserPromptSubmit"), "keyword-detector");
         assert.equal(mapCodexHookEventToOmxEvent("PreToolUse"), "pre-tool-use");
         assert.equal(mapCodexHookEventToOmxEvent("PostToolUse"), "post-tool-use");
+        assert.equal(mapCodexHookEventToOmxEvent("PreCompact"), "pre-compact");
+        assert.equal(mapCodexHookEventToOmxEvent("PostCompact"), "post-compact");
         assert.equal(mapCodexHookEventToOmxEvent("Stop"), "stop");
     });
+    it("does not write PreCompact stdout that Codex rejects as hook JSON", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-precompact-"));
+        try {
+            writePage(cwd, {
+                filename: "architecture.md",
+                frontmatter: {
+                    title: "Architecture",
+                    tags: ["architecture"],
+                    created: "2026-05-08T00:00:00.000Z",
+                    updated: "2026-05-08T00:00:00.000Z",
+                    sources: [],
+                    links: [],
+                    category: "architecture",
+                    confidence: "high",
+                    schemaVersion: WIKI_SCHEMA_VERSION,
+                },
+                content: "\n# Architecture\n\nCompaction-relevant architecture note.\n",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PreCompact",
+                cwd,
+                session_id: "sess-precompact",
+            });
+            assert.equal(result.hookEventName, "PreCompact");
+            assert.equal(result.omxEventName, "pre-compact");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("emits no CLI stdout for PreCompact when no Codex action is needed", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-precompact-cli-"));
+        try {
+            writePage(cwd, {
+                filename: "architecture.md",
+                frontmatter: {
+                    title: "Architecture",
+                    tags: ["architecture"],
+                    created: "2026-05-08T00:00:00.000Z",
+                    updated: "2026-05-08T00:00:00.000Z",
+                    sources: [],
+                    links: [],
+                    category: "architecture",
+                    confidence: "high",
+                    schemaVersion: WIKI_SCHEMA_VERSION,
+                },
+                content: "\n# Architecture\n\nCompaction-relevant architecture note.\n",
+            });
+            const stdout = runNativeHookCli({
+                hook_event_name: "PreCompact",
+                cwd,
+                session_id: "sess-precompact-cli",
+            });
+            assert.equal(stdout, "");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("does not write PostCompact stdout that Codex rejects as hook JSON", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-postcompact-"));
+        try {
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "PostCompact",
+                cwd,
+                session_id: "sess-postcompact",
+            });
+            assert.equal(result.hookEventName, "PostCompact");
+            assert.equal(result.omxEventName, "post-compact");
+            assert.equal(result.outputJson, null);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("emits no CLI stdout for PostCompact when no Codex action is needed", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-postcompact-cli-"));
+        try {
+            const stdout = runNativeHookCli({
+                hook_event_name: "PostCompact",
+                cwd,
+                session_id: "sess-postcompact-cli",
+            });
+            assert.equal(stdout, "");
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("writes SessionStart state against the long-lived session owner pid and injects environment context", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-start-"));
         try {
@@ -863,7 +963,8 @@ describe("codex native hook dispatch", () => {
             assert.equal(result.skillState?.skill, "ralplan");
             assert.ok(result.outputJson, "UserPromptSubmit should emit developer context");
             assert.match(JSON.stringify(result.outputJson), /skill: ralplan activated and initial state initialized at \.omx\/state\/sessions\/sess-1\/ralplan-state\.json; write subsequent updates via omx_state MCP\./);
-            const statePath = join(cwd, ".omx", "state", "skill-active-state.json");
+            assert.equal(existsSync(join(cwd, ".omx", "state", "skill-active-state.json")), false, "session-scoped keyword activation should not write root skill-active-state.json");
+            const statePath = join(cwd, ".omx", "state", "sessions", "sess-1", "skill-active-state.json");
             assert.equal(existsSync(statePath), true);
             const state = JSON.parse(await readFile(statePath, "utf-8"));
             assert.equal(state.skill, "ralplan");
@@ -924,6 +1025,94 @@ describe("codex native hook dispatch", () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it("does not block Stop for non-passing autoresearch-goal professor-critic verdicts", async () => {
+        for (const verdict of ["blocked", "fail", "failed"]) {
+            const cwd = await mkdtemp(join(tmpdir(), `omx-native-hook-autoresearch-${verdict}-stop-`));
+            const slug = `${verdict}-mission`;
+            try {
+                await writeJson(join(cwd, ".omx", "goals", "autoresearch", slug, "mission.json"), {
+                    version: 1,
+                    workflow: "autoresearch-goal",
+                    slug,
+                    topic: "Blocked research",
+                    status: verdict === "blocked" ? "blocked" : "failed",
+                });
+                await writeJson(join(cwd, ".omx", "goals", "autoresearch", slug, "completion.json"), {
+                    verdict,
+                    passed: false,
+                });
+                const result = await dispatchCodexNativeHook({
+                    hook_event_name: "Stop",
+                    cwd,
+                    session_id: `sess-autoresearch-${verdict}-stop`,
+                    thread_id: `thread-autoresearch-${verdict}-stop`,
+                    last_assistant_message: "Autoresearch goal complete; next call update_goal({status: \"complete\"}).",
+                }, { cwd });
+                assert.notEqual(result.outputJson?.decision, "block");
+                assert.doesNotMatch(JSON.stringify(result.outputJson), new RegExp(`autoresearch-goal complete --slug ${slug}`));
+                assert.doesNotMatch(JSON.stringify(result.outputJson), /get_goal snapshot reconciliation/);
+            }
+            finally {
+                await rm(cwd, { recursive: true, force: true });
+            }
+        }
+    });
+    it("blocks Stop for passing autoresearch-goal professor-critic verdicts that need reconciliation", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autoresearch-pass-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "goals", "autoresearch", "passing-mission", "mission.json"), {
+                version: 1,
+                workflow: "autoresearch-goal",
+                slug: "passing-mission",
+                topic: "Passing research",
+                status: "validation_passed",
+            });
+            await writeJson(join(cwd, ".omx", "goals", "autoresearch", "passing-mission", "completion.json"), {
+                verdict: "fail",
+                passed: true,
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-autoresearch-pass-stop",
+                thread_id: "thread-autoresearch-pass-stop",
+                last_assistant_message: "Autoresearch goal complete; next call update_goal({status: \"complete\"}).",
+            }, { cwd });
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(JSON.stringify(result.outputJson), /get_goal snapshot reconciliation/);
+            assert.match(JSON.stringify(result.outputJson), /omx autoresearch-goal complete --slug passing-mission/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it("blocks Stop for autoresearch-goal verdict=pass even when passed is omitted", async () => {
+        const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autoresearch-verdict-pass-stop-"));
+        try {
+            await writeJson(join(cwd, ".omx", "goals", "autoresearch", "verdict-pass-mission", "mission.json"), {
+                version: 1,
+                workflow: "autoresearch-goal",
+                slug: "verdict-pass-mission",
+                topic: "Passing research",
+                status: "validation_passed",
+            });
+            await writeJson(join(cwd, ".omx", "goals", "autoresearch", "verdict-pass-mission", "completion.json"), {
+                verdict: "pass",
+            });
+            const result = await dispatchCodexNativeHook({
+                hook_event_name: "Stop",
+                cwd,
+                session_id: "sess-autoresearch-verdict-pass-stop",
+                thread_id: "thread-autoresearch-verdict-pass-stop",
+                last_assistant_message: "Autoresearch goal complete; next call update_goal({status: \"complete\"}).",
+            }, { cwd });
+            assert.equal(result.outputJson?.decision, "block");
+            assert.match(JSON.stringify(result.outputJson), /omx autoresearch-goal complete --slug verdict-pass-mission/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it("treats workflow keywords in native subagent prompt text as literal delegation text", async () => {
         const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-subagent-keyword-literal-"));
         try {