oh-my-codex 0.16.3 → 0.17.0

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

@@ -4,14 +4,14 @@ import { appendFile, mkdir, readFile, readdir, writeFile } from "fs/promises";
 import { extname, join, relative, resolve } from "path";
 import { pathToFileURL } from "url";
 import { readModeState, readModeStateForActiveDecision, readModeStateForSession, updateModeState } from "../modes/base.js";
-import { extractSessionIdFromInitializedStatePath, getSkillActiveStatePaths, listActiveSkills, readSkillActiveState, readVisibleSkillActiveState, } from "../state/skill-active.js";
+import { extractSessionIdFromInitializedStatePath, getSkillActiveStatePathsForStateDir, listActiveSkills, readSkillActiveState, readVisibleSkillActiveStateForStateDir, } from "../state/skill-active.js";
 import { readSubagentSessionSummary, recordSubagentTurnForSession, } from "../subagents/tracker.js";
 import { resolveCanonicalTeamStateRoot, resolveWorkerNotifyTeamStateRootPath } from "../team/state-root.js";
 import { appendToLog, isSessionStateUsable, readSessionState, readUsableSessionState, reconcileNativeSessionStart, } from "../hooks/session.js";
 import { appendTeamEvent, readTeamLeaderAttention, readTeamManifestV2, readTeamPhase, writeTeamLeaderAttention, writeTeamPhase, } from "../team/state.js";
-import { omxNotepadPath, omxProjectMemoryPath } from "../utils/paths.js";
+import { omxNotepadPath, resolveProjectMemoryPath } from "../utils/paths.js";
 import { findGitLayout } from "../utils/git-layout.js";
-import { getStateFilePath, getStatePath } from "../mcp/state-paths.js";
+import { getBaseStateDir, getStateFilePath, getStatePath } from "../mcp/state-paths.js";
 import { detectKeywords, detectPrimaryKeyword, recordSkillActivation, } from "../hooks/keyword-detector.js";
 import { detectNativeStopStallPattern, loadAutoNudgeConfig, normalizeAutoNudgeSignatureText, resolveEffectiveAutoNudgeResponse, } from "./notify-hook/auto-nudge.js";
 import { SLOPPY_FALLBACK_GROUNDING_PATTERNS, SLOPPY_FALLBACK_IMPLEMENTATION_CONTEXT_PATTERNS, SLOPPY_FALLBACK_PHRASE_PATTERNS, buildNativePostToolUseOutput, buildNativePreToolUseOutput, detectMcpTransportFailure, hasAnyPattern, } from "./codex-native-pre-post.js";
@@ -24,6 +24,7 @@ import { reconcileHudForPromptSubmit } from "../hud/reconcile.js";
 import { onPreCompact as buildWikiPreCompactContext, onSessionStart as buildWikiSessionStartContext, } from "../wiki/lifecycle.js";
 import { readAutoresearchCompletionStatus, readAutoresearchModeStateForActiveDecision } from "../autoresearch/skill-validation.js";
 import { readRunState } from "../runtime/run-state.js";
+import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
 import { getRunContinuationSnapshot, shouldContinueRun } from "../runtime/run-loop.js";
 import { triagePrompt } from "../hooks/triage-heuristic.js";
 import { readTriageConfig } from "../hooks/triage-config.js";
@@ -62,6 +63,12 @@ function safeString(value) {
 function safeObject(value) {
     return value && typeof value === "object" ? value : {};
 }
+function safeContextSnippet(value, maxLength = 300) {
+    const text = safeString(value).replace(/\s+/g, " ").trim();
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, maxLength - 1).trimEnd()}…`;
+}
 function readBoundedFirstLineSync(path) {
     const fd = openSync(path, "r");
     try {
@@ -381,15 +388,15 @@ async function readCanonicalTerminalRunStateForStop(cwd, sessionId, mode) {
     const runRecord = runState;
     return shouldHonorCanonicalTerminalRunState(runRecord, mode) ? runRecord : null;
 }
-async function isVisibleRalphActiveForSession(cwd, sessionId) {
-    const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+async function isVisibleRalphActiveForSession(stateDir, sessionId) {
+    const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
     if (!canonicalState)
         return false;
     return listActiveSkills(canonicalState).some((entry) => (entry.skill === "ralph"
         && matchesSkillStopContext(entry, canonicalState, sessionId, "")));
 }
-async function hasConsistentRalphSkillActivation(cwd, sessionId) {
-    const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+async function hasConsistentRalphSkillActivation(stateDir, sessionId) {
+    const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
     if (!canonicalState)
         return true;
     const initializedMode = safeString(canonicalState.initialized_mode).trim();
@@ -400,8 +407,63 @@ async function hasConsistentRalphSkillActivation(cwd, sessionId) {
         return false;
     return true;
 }
-async function readActiveRalphState(stateDir, preferredSessionId, ownerContext) {
-    const cwd = resolve(stateDir, "..", "..");
+async function readRalphCompletionAuditBlockState(cwd, stateDir, preferredSessionId, ownerContext) {
+    const [rawSessionInfo, usableSessionInfo] = await Promise.all([
+        readSessionState(cwd),
+        readUsableSessionState(cwd),
+    ]);
+    const currentOmxSessionId = safeString(usableSessionInfo?.session_id).trim();
+    const currentNativeSessionId = safeString(usableSessionInfo?.native_session_id).trim();
+    const staleCurrentSessionId = rawSessionInfo && !isSessionStateUsable(rawSessionInfo, cwd)
+        ? safeString(rawSessionInfo.session_id).trim()
+        : "";
+    const sessionCandidates = [...new Set([
+            safeString(preferredSessionId).trim(),
+            currentOmxSessionId,
+        ].filter(Boolean))];
+    const evaluateCandidate = (state, path, sessionId) => {
+        if (!state || state.mode && safeString(state.mode) !== "ralph")
+            return null;
+        if (!isRalphCompletePhase(state.current_phase ?? state.currentPhase))
+            return null;
+        if (activeRalphStateMatchesStopOwner(state, {
+            sessionId,
+            payloadSessionId: safeString(ownerContext?.payloadSessionId).trim(),
+            threadId: safeString(ownerContext?.threadId).trim(),
+            currentNativeSessionId,
+            tmuxPaneId: safeString(ownerContext?.tmuxPaneId).trim(),
+        }) !== true)
+            return null;
+        const audit = evaluateRalphCompletionAuditEvidence(state, cwd);
+        return audit.complete ? null : { state, path, reason: audit.reason };
+    };
+    for (const sessionId of sessionCandidates) {
+        if (staleCurrentSessionId && sessionId === staleCurrentSessionId)
+            continue;
+        const sessionScopedPath = getStateFilePath("ralph-state.json", cwd, sessionId);
+        const result = evaluateCandidate(await readJsonIfExists(sessionScopedPath), sessionScopedPath, sessionId);
+        if (result)
+            return result;
+    }
+    if (sessionCandidates.length > 0)
+        return null;
+    const directPath = join(stateDir, "ralph-state.json");
+    return evaluateCandidate(await readJsonIfExists(directPath), directPath, "");
+}
+async function reopenRalphCompletionAuditBlock(block) {
+    const nowIso = new Date().toISOString();
+    const next = {
+        ...block.state,
+        active: true,
+        current_phase: "verifying",
+        completion_audit_gate: "blocked",
+        completion_audit_missing_reason: block.reason,
+        completion_audit_blocked_at: nowIso,
+    };
+    delete next.completed_at;
+    await writeFile(block.path, JSON.stringify(next, null, 2));
+}
+async function readActiveRalphState(cwd, stateDir, preferredSessionId, ownerContext) {
     const [rawSessionInfo, usableSessionInfo] = await Promise.all([
         readSessionState(cwd),
         readUsableSessionState(cwd),
@@ -429,7 +491,7 @@ async function readActiveRalphState(stateDir, preferredSessionId, ownerContext)
         const sessionScoped = await readJsonIfExists(sessionScopedPath);
         if (sessionScoped?.active === true
             && isRalphStartingPhase(sessionScoped)
-            && !(await isVisibleRalphActiveForSession(cwd, sessionId))) {
+            && !(await isVisibleRalphActiveForSession(stateDir, sessionId))) {
             continue;
         }
         if (sessionScoped?.active === true
@@ -441,7 +503,7 @@ async function readActiveRalphState(stateDir, preferredSessionId, ownerContext)
                 currentNativeSessionId,
                 tmuxPaneId: safeString(ownerContext?.tmuxPaneId).trim(),
             })
-            && await hasConsistentRalphSkillActivation(cwd, sessionId)) {
+            && await hasConsistentRalphSkillActivation(stateDir, sessionId)) {
             return { state: sessionScoped, path: sessionScopedPath };
         }
     }
@@ -818,14 +880,17 @@ async function buildSessionStartContext(cwd, sessionId, options = {}) {
     if (modeSummaries.length > 0) {
         sections.push(["[Active OMX modes]", ...modeSummaries].join("\n"));
     }
-    const projectMemory = await readJsonIfExists(omxProjectMemoryPath(cwd));
-    if (projectMemory) {
+    const projectMemoryPath = resolveProjectMemoryPath(cwd);
+    const projectMemory = projectMemoryPath ? await readJsonIfExists(projectMemoryPath) : null;
+    if (projectMemory && projectMemoryPath) {
         const directives = Array.isArray(projectMemory.directives) ? projectMemory.directives : [];
         const notes = Array.isArray(projectMemory.notes) ? projectMemory.notes : [];
-        const techStack = safeString(projectMemory.techStack).trim();
-        const conventions = safeString(projectMemory.conventions).trim();
-        const build = safeString(projectMemory.build).trim();
+        const techStack = safeContextSnippet(projectMemory.techStack);
+        const conventions = safeContextSnippet(projectMemory.conventions);
+        const build = safeContextSnippet(projectMemory.build);
         const summary = [];
+        const relativeMemoryPath = relative(cwd, projectMemoryPath).replace(/\\/g, "/");
+        summary.push(`- source: ${relativeMemoryPath === "project-memory.json" ? "project-memory.json" : ".omx/project-memory.json"}`);
         if (techStack)
             summary.push(`- stack: ${techStack}`);
         if (conventions)
@@ -834,17 +899,17 @@ async function buildSessionStartContext(cwd, sessionId, options = {}) {
             summary.push(`- build: ${build}`);
         if (directives.length > 0) {
             const firstDirective = directives[0];
-            const directive = safeString(firstDirective.directive).trim();
+            const directive = safeContextSnippet(firstDirective.directive);
             if (directive)
                 summary.push(`- directive: ${directive}`);
         }
         if (notes.length > 0) {
             const firstNote = notes[0];
-            const note = safeString(firstNote.content).trim();
+            const note = safeContextSnippet(firstNote.content);
             if (note)
                 summary.push(`- note: ${note}`);
         }
-        if (summary.length > 0) {
+        if (summary.length > 1) {
             sections.push(["[Project memory]", ...summary].join("\n"));
         }
     }
@@ -1030,6 +1095,9 @@ function buildNativeOutsideTmuxTeamPromptBlockState(prompt, cwd, payload, sessio
         transition_error: "Codex App/native outside-tmux sessions cannot activate the tmux-only `team` workflow directly. Launch OMX CLI from an attached tmux shell first, then run `omx team ...` there.",
     };
 }
+function buildSkillStateCliInstruction(mode, statePath) {
+    return `skill: ${mode} activated and initial state initialized at ${statePath}; use CLI-first state updates via \`omx state write/read/clear --input '<json>' --json\`; use omx_state MCP only when explicit MCP compatibility is enabled.`;
+}
 function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(), payload) {
     if (!prompt)
         return null;
@@ -1089,7 +1157,7 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
             promptPriorityMessage,
             ultragoalPromptActivationNote,
             skillState.initialized_mode && skillState.initialized_state_path
-                ? `skill: ${skillState.initialized_mode} activated and initial state initialized at ${skillState.initialized_state_path}; write subsequent updates via omx_state MCP.`
+                ? buildSkillStateCliInstruction(skillState.initialized_mode, skillState.initialized_state_path)
                 : null,
             teamDetected
                 ? buildTeamRuntimeInstruction(cwd, payload)
@@ -1100,7 +1168,7 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
     }
     if (teamDetected) {
         const initializedStateMessage = skillState?.initialized_mode && skillState.initialized_state_path
-            ? `skill: ${skillState.initialized_mode} activated and initial state initialized at ${skillState.initialized_state_path}; write subsequent updates via omx_state MCP.`
+            ? buildSkillStateCliInstruction(skillState.initialized_mode, skillState.initialized_state_path)
             : null;
         return [
             detectedKeywordMessage,
@@ -1126,7 +1194,7 @@ function buildAdditionalContextMessage(prompt, skillState, cwd = process.cwd(),
                 ? `planning preserved over simultaneous execution follow-up; deferred skills: ${deferredSkills.join(", ")}.`
                 : null,
             promptPriorityMessage,
-            `skill: ${skillState.initialized_mode} activated and initial state initialized at ${skillState.initialized_state_path}; write subsequent updates via omx_state MCP.`,
+            buildSkillStateCliInstruction(skillState.initialized_mode, skillState.initialized_state_path),
             deepInterviewPromptActivationNote,
             ultraworkPromptActivationNote,
             ultragoalPromptActivationNote,
@@ -1164,7 +1232,7 @@ async function resolveTeamWorkerStopDecision(cwd) {
         || parseTeamWorkerEnv(safeString(process.env.OMX_TEAM_WORKER));
     if (!workerContext)
         return { kind: "unresolved", reason: "missing_worker_context" };
-    const blockWorkerStop = (reasonCode, detail, stateDirForDecision = join(cwd, ".omx", "state")) => ({
+    const blockWorkerStop = (reasonCode, detail, stateDirForDecision = getBaseStateDir(cwd)) => ({
         kind: "blocked",
         stateDir: stateDirForDecision,
         workerContext,
@@ -1281,19 +1349,32 @@ async function buildModeBasedStopOutput(mode, cwd, sessionId) {
         systemMessage: `OMX ${mode} is still active (phase: ${phase}).`,
     };
 }
-function looksLikeGoalCompletionPrompt(text) {
-    return /\b(?:complete|checkpoint|finish|close|mark)\b.{0,80}\b(?:goal|ultragoal|performance-goal|autoresearch-goal)\b/i.test(text)
-        || /\bupdate_goal\s*\(/i.test(text)
-        || /\bomx\s+(?:ultragoal|performance-goal|autoresearch-goal)\s+(?:checkpoint|complete)\b/i.test(text);
+export function looksLikeGoalCompletionPrompt(text) {
+    return /\bupdate_goal\s*\(/i.test(text)
+        || /\bomx\s+(?:ultragoal|performance-goal|autoresearch-goal)\s+(?:checkpoint|complete)\b/i.test(text)
+        || /\b(?:complete|checkpoint|finish|close|mark)\b.{0,80}\b(?:goal|ultragoal|performance[-\s]goal|autoresearch[-\s]goal)\b/i.test(text)
+        || /\b(?:ultragoal|performance[-\s]goal|autoresearch[-\s]goal)\b.{0,80}\b(?:complete|checkpoint|finish|close|mark)\b/i.test(text)
+        || /(?:^|[.!?]\s+)(?:the\s+)?goal\s+(?:is\s+|now\s+|has\s+been\s+)?(?:complete|completed|finished|closed)(?:\s*(?:[.!?]|$)|\s*[:;]\s*\S|\s*[—–-]\s*\S)/i.test(text);
 }
 async function findActiveGoalWorkflowReconciliationRequirement(cwd) {
     const ultragoal = await readJsonIfExists(join(cwd, ".omx", "ultragoal", "goals.json"));
+    const aggregateCompletion = safeObject(ultragoal?.aggregateCompletion);
+    const aggregateProductComplete = safeString(aggregateCompletion.status) === "complete";
     const ultragoals = Array.isArray(ultragoal?.goals) ? ultragoal.goals.map(safeObject) : [];
-    const activeUltragoal = ultragoals.find((goal) => safeString(goal.status) === "in_progress" || safeString(goal.id) === safeString(ultragoal?.activeGoalId));
+    const activeUltragoal = aggregateProductComplete
+        ? undefined
+        : ultragoals.find((goal) => safeString(goal.status) === "in_progress" || safeString(goal.id) === safeString(ultragoal?.activeGoalId));
     if (activeUltragoal) {
+        const goalId = safeString(activeUltragoal.id) || "<goal-id>";
         return {
             workflow: "ultragoal",
-            command: `omx ultragoal checkpoint --goal-id ${safeString(activeUltragoal.id) || "<goal-id>"} --status complete --codex-goal-json '<get_goal JSON or path>' --evidence '<evidence>'`,
+            command: `omx ultragoal checkpoint --goal-id ${goalId} --status complete --codex-goal-json '<get_goal JSON or path>' --evidence '<evidence>'`,
+            remediation: [
+                `If get_goal returns a completed task-scoped objective for the same aggregate ultragoal plan, checkpoint ${goalId} with evidence naming ${goalId} plus .omx/ultragoal/goals.json or ledger.jsonl and pass final quality-gate JSON; OMX will reconcile the completed planned scope without mutating Codex goal state.`,
+                `If get_goal instead returns a different completed legacy objective and complete checkpointing fails, do not repeat --status complete in this thread.`,
+                `Record the non-terminal blocker with: omx ultragoal checkpoint --goal-id ${goalId} --status blocked --codex-goal-json '<different completed get_goal JSON or path>' --evidence '<completed legacy Codex goal blocks create_goal in this thread>'.`,
+                "Then continue this ultragoal from a fresh Codex thread in the same repo/worktree and create the intended goal there.",
+            ].join(" "),
         };
     }
     const performanceRoot = join(cwd, ".omx", "goals", "performance");
@@ -1337,7 +1418,8 @@ async function buildGoalWorkflowReconciliationPromptWarning(cwd, prompt) {
         `OMX ${requirement.workflow} goal workflow requires Codex goal snapshot reconciliation before completion.`,
         "Call get_goal, pass the resulting JSON or a path with --codex-goal-json, and do not rely on hooks or shell commands to mutate Codex-owned goal state.",
         `Required command shape: ${requirement.command}.`,
-    ].join(" ");
+        requirement.remediation,
+    ].filter(Boolean).join(" ");
 }
 async function buildGoalWorkflowReconciliationStopOutput(payload, cwd) {
     const lastAssistantMessage = safeString(payload.last_assistant_message ?? payload.lastAssistantMessage);
@@ -1346,7 +1428,11 @@ async function buildGoalWorkflowReconciliationStopOutput(payload, cwd) {
     const requirement = await findActiveGoalWorkflowReconciliationRequirement(cwd);
     if (!requirement)
         return null;
-    const systemMessage = `OMX ${requirement.workflow} requires get_goal snapshot reconciliation before completion; call get_goal and pass --codex-goal-json to ${requirement.command}. Hooks must not mutate Codex goal state.`;
+    const systemMessage = [
+        `OMX ${requirement.workflow} requires get_goal snapshot reconciliation before completion; call get_goal and pass --codex-goal-json to ${requirement.command}.`,
+        requirement.remediation,
+        "Hooks must not mutate Codex goal state.",
+    ].filter(Boolean).join(" ");
     return {
         decision: "block",
         reason: systemMessage,
@@ -1354,15 +1440,15 @@ async function buildGoalWorkflowReconciliationStopOutput(payload, cwd) {
         systemMessage,
     };
 }
-async function readTeamModeStateForStop(cwd, sessionId) {
+async function readTeamModeStateForStop(cwd, stateDir, sessionId) {
     const normalizedSessionId = safeString(sessionId).trim();
     if (!normalizedSessionId) {
         return await readModeState("team", cwd);
     }
-    const scopedState = await readStopSessionPinnedState("team-state.json", cwd, normalizedSessionId);
+    const scopedState = await readStopSessionPinnedState("team-state.json", cwd, normalizedSessionId, stateDir);
     if (scopedState)
         return scopedState;
-    const rootState = await readJsonIfExists(join(cwd, ".omx", "state", "team-state.json"));
+    const rootState = await readJsonIfExists(join(stateDir, "team-state.json"));
     if (rootState?.active !== true)
         return null;
     const ownerSessionId = safeString(rootState.session_id).trim();
@@ -1375,7 +1461,7 @@ async function buildTeamStopOutput(cwd, sessionId) {
     if (await readCanonicalTerminalRunStateForStop(cwd, sessionId, "team")) {
         return null;
     }
-    const teamState = await readTeamModeStateForStop(cwd, sessionId);
+    const teamState = await readTeamModeStateForStop(cwd, getBaseStateDir(cwd), sessionId);
     if (teamState?.active !== true)
         return null;
     const teamName = safeString(teamState.team_name).trim();
@@ -1425,10 +1511,10 @@ function hasReleaseReadinessMode(payload) {
     const mode = safeString(payload.mode).trim().toLowerCase();
     return mode === "release-readiness";
 }
-async function hasReleaseReadinessStopMarker(cwd, sessionId, teamName) {
+async function hasReleaseReadinessStopMarker(cwd, stateDir, sessionId, teamName) {
     if (!sessionId)
         return false;
-    const markerState = await readStopSessionPinnedState("release-readiness-state.json", cwd, sessionId);
+    const markerState = await readStopSessionPinnedState("release-readiness-state.json", cwd, sessionId, stateDir);
     if (markerState?.active !== true || markerState.stable_final_recommendation_emitted !== true) {
         return false;
     }
@@ -1463,8 +1549,10 @@ async function resolveInternalSessionIdForPayload(cwd, payloadSessionId) {
         return canonicalSessionId;
     return payloadSessionId;
 }
-async function readStopSessionPinnedState(fileName, cwd, sessionId) {
-    const statePath = getStateFilePath(fileName, cwd, sessionId || undefined);
+async function readStopSessionPinnedState(fileName, cwd, sessionId, stateDir) {
+    const statePath = stateDir && sessionId
+        ? join(stateDir, "sessions", sessionId, fileName)
+        : getStateFilePath(fileName, cwd, sessionId || undefined);
     return readJsonIfExists(statePath);
 }
 function matchesSkillStopContext(entry, state, sessionId, threadId) {
@@ -1499,8 +1587,8 @@ function modeStateMatchesSkillStopContext(state, cwd, sessionId) {
     }
     return true;
 }
-async function readBlockingSkillForStop(cwd, sessionId, threadId, requiredSkill) {
-    const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+async function readBlockingSkillForStop(cwd, stateDir, sessionId, threadId, requiredSkill) {
+    const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
     const visibleEntries = canonicalState ? listActiveSkills(canonicalState) : [];
     const candidateSkills = requiredSkill
         ? [requiredSkill]
@@ -1509,7 +1597,7 @@ async function readBlockingSkillForStop(cwd, sessionId, threadId, requiredSkill)
         const terminalRunState = await readCanonicalTerminalRunStateForStop(cwd, sessionId, skill);
         if (terminalRunState)
             continue;
-        const modeState = await readStopSessionPinnedState(`${skill}-state.json`, cwd, sessionId);
+        const modeState = await readStopSessionPinnedState(`${skill}-state.json`, cwd, sessionId, stateDir);
         if (!modeState || modeState.active !== true)
             continue;
         if (!modeStateMatchesSkillStopContext(modeState, cwd, sessionId))
@@ -1557,16 +1645,16 @@ function isTerminalOrInactiveModeState(state) {
     const phase = safeString(state.current_phase ?? state.currentPhase).trim().toLowerCase();
     return phase !== "" && TERMINAL_MODE_PHASES.has(phase);
 }
-async function readSessionScopedModeStateForRootSkill(cwd, skill, sessionIds) {
+async function readSessionScopedModeStateForRootSkill(cwd, stateDir, skill, sessionIds) {
     for (const sessionId of sessionIds) {
-        const state = await readJsonIfExists(getStateFilePath(`${skill}-state.json`, cwd, sessionId));
+        const state = await readStopSessionPinnedState(`${skill}-state.json`, cwd, sessionId, stateDir);
         if (state)
             return state;
     }
     return null;
 }
-async function reconcileStaleRootSkillActiveStateForStop(cwd, sessionId) {
-    const { rootPath } = getSkillActiveStatePaths(cwd);
+async function reconcileStaleRootSkillActiveStateForStop(cwd, stateDir, sessionId) {
+    const { rootPath } = getSkillActiveStatePathsForStateDir(stateDir);
     const rootState = await readSkillActiveState(rootPath);
     if (!rootState?.active)
         return;
@@ -1593,7 +1681,7 @@ async function reconcileStaleRootSkillActiveStateForStop(cwd, sessionId) {
             initializedSessionId,
             safeString(rootState.session_id),
         ]);
-        const modeState = await readSessionScopedModeStateForRootSkill(cwd, skill, candidateSessionIds);
+        const modeState = await readSessionScopedModeStateForRootSkill(cwd, stateDir, skill, candidateSessionIds);
         if (isTerminalOrInactiveModeState(modeState)) {
             changed = true;
             continue;
@@ -1652,17 +1740,17 @@ function buildRalplanContinuationStatus(blocker, activeSubagentCount) {
         systemMessage: `OMX ralplan status: continue_from_artifact at phase ${phase}; continue from the current ralplan artifact and finish by stating whether ralplan is complete, paused for review, waiting for input, or still continuing.`,
     };
 }
-async function readStopAutoNudgePhase(cwd, sessionId, threadId) {
+async function readStopAutoNudgePhase(cwd, stateDir, sessionId, threadId) {
     const normalizedSessionId = sessionId.trim();
     if (normalizedSessionId) {
-        const scopedModeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, normalizedSessionId);
+        const scopedModeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, normalizedSessionId, stateDir);
         if (scopedModeState?.active === true
             && safeString(scopedModeState.current_phase).trim().toLowerCase() === "intent-first") {
             return "planning";
         }
     }
     else {
-        const rootModeState = await readJsonIfExists(join(cwd, ".omx", "state", "deep-interview-state.json"));
+        const rootModeState = await readJsonIfExists(join(stateDir, "deep-interview-state.json"));
         if (rootModeState?.active === true
             && safeString(rootModeState.current_phase).trim().toLowerCase() === "intent-first") {
             return "planning";
@@ -1670,21 +1758,21 @@ async function readStopAutoNudgePhase(cwd, sessionId, threadId) {
     }
     if (!normalizedSessionId)
         return "";
-    const canonicalState = await readVisibleSkillActiveState(cwd, normalizedSessionId);
+    const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, normalizedSessionId);
     const visibleEntries = canonicalState ? listActiveSkills(canonicalState) : [];
     const deepInterview = visibleEntries.find((entry) => (entry.skill === "deep-interview"
         && matchesSkillStopContext(entry, canonicalState ?? {}, normalizedSessionId, threadId)));
     if (!deepInterview)
         return "";
-    const modeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, normalizedSessionId);
+    const modeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, normalizedSessionId, stateDir);
     if (!modeState || modeState.active !== true)
         return "";
     const modePhase = safeString(modeState.current_phase).trim().toLowerCase();
     return modePhase === "intent-first" ? "planning" : "";
 }
-async function buildDeepInterviewQuestionStopOutput(cwd, sessionId, threadId) {
+async function buildDeepInterviewQuestionStopOutput(cwd, stateDir, sessionId, threadId) {
     await reconcileDeepInterviewQuestionEnforcementFromAnsweredRecords(cwd, sessionId);
-    const modeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId);
+    const modeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId, stateDir);
     if (!modeState)
         return null;
     const questionEnforcement = safeObject(modeState.question_enforcement);
@@ -1695,7 +1783,7 @@ async function buildDeepInterviewQuestionStopOutput(cwd, sessionId, threadId) {
     if (TERMINAL_MODE_PHASES.has(phase.toLowerCase()) || phase === "completing") {
         return null;
     }
-    const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+    const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
     if (canonicalState) {
         const blocker = listActiveSkills(canonicalState).find((entry) => (entry.skill === "deep-interview"
             && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)));
@@ -1836,8 +1924,8 @@ async function findCanonicalActiveTeamForSession(cwd, sessionId) {
     }
     return null;
 }
-async function resolveActiveTeamNameForStop(cwd, sessionId) {
-    const directState = await readTeamModeStateForStop(cwd, sessionId);
+async function resolveActiveTeamNameForStop(cwd, stateDir, sessionId) {
+    const directState = await readTeamModeStateForStop(cwd, stateDir, sessionId);
     const directTeamName = safeString(directState?.team_name).trim();
     if (directState?.active === true && directTeamName)
         return directTeamName;
@@ -1847,11 +1935,11 @@ async function resolveActiveTeamNameForStop(cwd, sessionId) {
 async function maybeBuildReleaseReadinessFinalizeStopOutput(payload, cwd, stateDir, sessionId) {
     if (!sessionId)
         return { matched: false, output: null };
-    const teamName = await resolveActiveTeamNameForStop(cwd, sessionId);
+    const teamName = await resolveActiveTeamNameForStop(cwd, stateDir, sessionId);
     if (!teamName)
         return { matched: false, output: null };
     const explicitReleaseReadinessContext = hasReleaseReadinessMode(payload)
-        || await hasReleaseReadinessStopMarker(cwd, sessionId, teamName);
+        || await hasReleaseReadinessStopMarker(cwd, stateDir, sessionId, teamName);
     if (!explicitReleaseReadinessContext) {
         return { matched: false, output: null };
     }
@@ -1873,8 +1961,8 @@ async function maybeBuildReleaseReadinessFinalizeStopOutput(payload, cwd, stateD
     }, sessionId);
     return { matched: true, output };
 }
-async function buildSkillStopOutput(cwd, sessionId, threadId) {
-    const blocker = await readBlockingSkillForStop(cwd, sessionId, threadId);
+async function buildSkillStopOutput(cwd, stateDir, sessionId, threadId) {
+    const blocker = await readBlockingSkillForStop(cwd, stateDir, sessionId, threadId);
     if (!blocker)
         return null;
     const subagentSummary = await readSubagentSessionSummary(cwd, sessionId).catch(() => null);
@@ -1983,18 +2071,33 @@ async function buildStopHookOutput(payload, cwd, stateDir, options = {}) {
     const canonicalSessionId = await resolveInternalSessionIdForPayload(cwd, sessionId);
     const threadId = readPayloadThreadId(payload);
     if (canonicalSessionId) {
-        await reconcileStaleRootSkillActiveStateForStop(cwd, canonicalSessionId);
+        await reconcileStaleRootSkillActiveStateForStop(cwd, stateDir, canonicalSessionId);
     }
     const execFollowupOutput = await buildExecFollowupStopOutput(cwd, canonicalSessionId);
     if (execFollowupOutput)
         return execFollowupOutput;
+    const ralphOwnerContext = {
+        payloadSessionId: sessionId,
+        threadId,
+        tmuxPaneId: safeString(process.env.TMUX_PANE).trim(),
+    };
+    const ralphCompletionAuditBlock = options.skipRalphStopBlock === true
+        ? null
+        : await readRalphCompletionAuditBlockState(cwd, stateDir, canonicalSessionId, ralphOwnerContext);
+    if (ralphCompletionAuditBlock) {
+        await reopenRalphCompletionAuditBlock(ralphCompletionAuditBlock);
+        const blockingPath = formatStopStatePath(cwd, ralphCompletionAuditBlock.path);
+        const systemMessage = `OMX Ralph completion audit is missing required evidence (${ralphCompletionAuditBlock.reason}; state: ${blockingPath}); continue verification, record a prompt-to-artifact checklist plus verification evidence, and do not report complete yet.`;
+        return await returnPersistentStopBlock(payload, stateDir, "ralph-completion-audit-stop", `${blockingPath}|${ralphCompletionAuditBlock.reason}`, {
+            decision: "block",
+            reason: systemMessage,
+            stopReason: `ralph_completion_audit_${ralphCompletionAuditBlock.reason}`,
+            systemMessage,
+        }, canonicalSessionId, { allowRepeatDuringStopHook: true });
+    }
     const ralphState = options.skipRalphStopBlock === true
         ? null
-        : await readActiveRalphState(stateDir, canonicalSessionId, {
-            payloadSessionId: sessionId,
-            threadId,
-            tmuxPaneId: safeString(process.env.TMUX_PANE).trim(),
-        });
+        : await readActiveRalphState(cwd, stateDir, canonicalSessionId, ralphOwnerContext);
     if (!ralphState) {
         const autoresearchState = await readActiveAutoresearchState(cwd, canonicalSessionId);
         if (autoresearchState) {
@@ -2047,7 +2150,7 @@ async function buildStopHookOutput(payload, cwd, stateDir, options = {}) {
             return await returnPersistentStopBlock(payload, stateDir, "team-stop", safeString(teamOutput.stopReason), teamOutput, canonicalSessionId);
         }
         if (canonicalSessionId) {
-            const deepInterviewQuestionOutput = await buildDeepInterviewQuestionStopOutput(cwd, canonicalSessionId, threadId);
+            const deepInterviewQuestionOutput = await buildDeepInterviewQuestionStopOutput(cwd, stateDir, canonicalSessionId, threadId);
             if (deepInterviewQuestionOutput) {
                 return await returnPersistentStopBlock(payload, stateDir, "deep-interview-question-stop", deepInterviewQuestionOutput.obligationId, deepInterviewQuestionOutput.output, canonicalSessionId);
             }
@@ -2060,7 +2163,7 @@ async function buildStopHookOutput(payload, cwd, stateDir, options = {}) {
                 if (repeatedCanonicalTeamOutput)
                     return repeatedCanonicalTeamOutput;
             }
-            const skillOutput = await buildSkillStopOutput(cwd, canonicalSessionId, threadId);
+            const skillOutput = await buildSkillStopOutput(cwd, stateDir, canonicalSessionId, threadId);
             if (skillOutput) {
                 return await returnPersistentStopBlock(payload, stateDir, "skill-stop", safeString(skillOutput.stopReason), skillOutput, canonicalSessionId);
             }
@@ -2071,7 +2174,7 @@ async function buildStopHookOutput(payload, cwd, stateDir, options = {}) {
             return await returnPersistentStopBlock(payload, stateDir, "goal-workflow-reconciliation-stop", safeString(goalWorkflowStopOutput.stopReason), goalWorkflowStopOutput, canonicalSessionId, { allowRepeatDuringStopHook: true });
         }
         const autoNudgeConfig = await loadAutoNudgeConfig();
-        const autoNudgePhase = await readStopAutoNudgePhase(cwd, canonicalSessionId, threadId);
+        const autoNudgePhase = await readStopAutoNudgePhase(cwd, stateDir, canonicalSessionId, threadId);
         if (autoNudgeConfig.enabled
             && detectNativeStopStallPattern(lastAssistantMessage, autoNudgeConfig.patterns, autoNudgePhase)) {
             const effectiveResponse = resolveEffectiveAutoNudgeResponse(autoNudgeConfig.response);
@@ -2109,7 +2212,9 @@ async function buildStopHookOutput(payload, cwd, stateDir, options = {}) {
 export async function dispatchCodexNativeHook(payload, options = {}) {
     const hookEventName = readHookEventName(payload);
     const cwd = options.cwd ?? (safeString(payload.cwd).trim() || process.cwd());
-    const stateDir = join(cwd, ".omx", "state");
+    // Native hooks must use the same authoritative runtime state root as HUD/MCP
+    // when boxed/team roots are active; do not bypass it with cwd/.omx/state.
+    const stateDir = getBaseStateDir(cwd);
     await mkdir(stateDir, { recursive: true });
     const omxEventName = mapCodexHookEventToOmxEvent(hookEventName);
     let skillState = null;
@@ -2179,6 +2284,7 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
         if (prompt && !isSubagentPromptSubmit) {
             skillState = buildNativeOutsideTmuxTeamPromptBlockState(prompt, cwd, payload, sessionIdForState, threadId || undefined, turnId || undefined) ?? await recordSkillActivation({
                 stateDir,
+                sourceCwd: cwd,
                 text: prompt,
                 sessionId: sessionIdForState,
                 threadId,