oh-my-codex 0.16.4 → 0.17.0

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

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