oh-my-codex 0.16.2 → 0.16.4

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 { 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";
@@ -21,9 +21,10 @@ import { resolveCodexExecutionSurface, } from "./codex-execution-surface.js";
 import { buildNativeHookEvent, } from "../hooks/extensibility/events.js";
 import { dispatchHookEventRuntime } from "../hooks/extensibility/runtime.js";
 import { reconcileHudForPromptSubmit } from "../hud/reconcile.js";
-import { onPostCompact as buildWikiPostCompactContext, onPreCompact as buildWikiPreCompactContext, onSessionStart as buildWikiSessionStartContext, } from "../wiki/lifecycle.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";
@@ -381,15 +382,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 +401,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 +485,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 +497,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 };
         }
     }
@@ -1030,6 +1086,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 +1148,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 +1159,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 +1185,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 +1223,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,
@@ -1315,7 +1374,10 @@ async function findActiveGoalWorkflowReconciliationRequirement(cwd) {
             continue;
         const mission = await readJsonIfExists(join(autoresearchRoot, entry.name, "mission.json"));
         const status = safeString(mission?.status);
-        if (mission?.workflow === "autoresearch-goal" && status && status !== "complete") {
+        const completion = await readJsonIfExists(join(autoresearchRoot, entry.name, "completion.json"));
+        const completionVerdict = safeString(completion?.verdict);
+        const completionPassed = completion?.passed === true || completionVerdict === "pass";
+        if (mission?.workflow === "autoresearch-goal" && status && status !== "complete" && completionPassed) {
             return {
                 workflow: "autoresearch-goal",
                 command: `omx autoresearch-goal complete --slug ${safeString(mission.slug) || entry.name} --codex-goal-json '<get_goal JSON or path>'`,
@@ -1351,15 +1413,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();
@@ -1372,7 +1434,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();
@@ -1422,10 +1484,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;
     }
@@ -1460,8 +1522,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) {
@@ -1496,8 +1560,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]
@@ -1506,7 +1570,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))
@@ -1554,16 +1618,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;
@@ -1590,7 +1654,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;
@@ -1649,17 +1713,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";
@@ -1667,21 +1731,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);
@@ -1692,7 +1756,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)));
@@ -1833,8 +1897,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;
@@ -1844,11 +1908,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 };
     }
@@ -1870,8 +1934,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);
@@ -1980,18 +2044,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) {
@@ -2044,7 +2123,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);
             }
@@ -2057,7 +2136,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);
             }
@@ -2068,7 +2147,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);
@@ -2106,7 +2185,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;
@@ -2176,6 +2257,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,
@@ -2282,26 +2364,10 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
         });
     }
     if (hookEventName === "PreCompact") {
-        const compactContext = buildWikiPreCompactContext({ cwd });
-        if (compactContext.additionalContext) {
-            outputJson = {
-                hookSpecificOutput: {
-                    hookEventName,
-                    additionalContext: compactContext.additionalContext,
-                },
-            };
-        }
-    }
-    else if (hookEventName === "PostCompact") {
-        const compactContext = buildWikiPostCompactContext({ cwd });
-        if (compactContext.additionalContext) {
-            outputJson = {
-                hookSpecificOutput: {
-                    hookEventName,
-                    additionalContext: compactContext.additionalContext,
-                },
-            };
-        }
+        // Codex native PreCompact currently accepts only the common continuation fields.
+        // Keep the OMX lifecycle dispatch above, but do not emit `hookSpecificOutput`
+        // unless Codex defines a supported PreCompact output contract.
+        buildWikiPreCompactContext({ cwd });
     }
     else if ((hookEventName === "SessionStart" && !skipCanonicalSessionStartContext) || hookEventName === "UserPromptSubmit") {
         const additionalContext = hookEventName === "SessionStart"