oh-my-codex 0.16.3 → 0.17.0

package/src/scripts/codex-native-hook.ts

@@ -6,10 +6,10 @@ import { pathToFileURL } from "url";
 import { readModeState, readModeStateForActiveDecision, readModeStateForSession, updateModeState } from "../modes/base.js";
 import {
   extractSessionIdFromInitializedStatePath,
-  getSkillActiveStatePaths,
+  getSkillActiveStatePathsForStateDir,
   listActiveSkills,
   readSkillActiveState,
-  readVisibleSkillActiveState,
+  readVisibleSkillActiveStateForStateDir,
   type SkillActiveStateLike,
 } from "../state/skill-active.js";
 import {
@@ -33,9 +33,9 @@ import {
   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,
@@ -76,6 +76,7 @@ import {
 } 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";
@@ -156,6 +157,12 @@ function safeObject(value: unknown): Record<string, unknown> {
   return value && typeof value === "object" ? value as Record<string, unknown> : {};
 }
 
+function safeContextSnippet(value: unknown, maxLength = 300): string {
+  const text = safeString(value).replace(/\s+/g, " ").trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1).trimEnd()}…`;
+}
+
 interface NativeSubagentSessionStartMetadata {
   parentThreadId: string;
   agentNickname?: string;
@@ -485,6 +492,12 @@ interface ActiveRalphStopState {
   path: string;
 }
 
+interface RalphCompletionAuditBlockState {
+  state: Record<string, unknown>;
+  path: string;
+  reason: string;
+}
+
 interface RalphStopOwnershipContext {
   sessionId: string;
   payloadSessionId: string;
@@ -559,8 +572,8 @@ async function readCanonicalTerminalRunStateForStop(
   return shouldHonorCanonicalTerminalRunState(runRecord, mode) ? runRecord : null;
 }
 
-async function isVisibleRalphActiveForSession(cwd: string, sessionId: string): Promise<boolean> {
-  const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+async function isVisibleRalphActiveForSession(stateDir: string, sessionId: string): Promise<boolean> {
+  const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
   if (!canonicalState) return false;
   return listActiveSkills(canonicalState).some((entry) => (
     entry.skill === "ralph"
@@ -568,8 +581,8 @@ async function isVisibleRalphActiveForSession(cwd: string, sessionId: string): P
   ));
 }
 
-async function hasConsistentRalphSkillActivation(cwd: string, sessionId: string): Promise<boolean> {
-  const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+async function hasConsistentRalphSkillActivation(stateDir: string, sessionId: string): Promise<boolean> {
+  const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
   if (!canonicalState) return true;
 
   const initializedMode = safeString(canonicalState.initialized_mode).trim();
@@ -581,7 +594,74 @@ async function hasConsistentRalphSkillActivation(cwd: string, sessionId: string)
   return true;
 }
 
+
+async function readRalphCompletionAuditBlockState(
+  cwd: string,
+  stateDir: string,
+  preferredSessionId?: string,
+  ownerContext?: {
+    payloadSessionId?: string;
+    threadId?: string;
+    tmuxPaneId?: string;
+  },
+): Promise<RalphCompletionAuditBlockState | null> {
+  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: Record<string, unknown> | null, path: string, sessionId: string): RalphCompletionAuditBlockState | null => {
+    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: RalphCompletionAuditBlockState): Promise<void> {
+  const nowIso = new Date().toISOString();
+  const next: Record<string, unknown> = {
+    ...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: string,
   stateDir: string,
   preferredSessionId?: string,
   ownerContext?: {
@@ -590,7 +670,6 @@ async function readActiveRalphState(
     tmuxPaneId?: string;
   },
 ): Promise<ActiveRalphStopState | null> {
-  const cwd = resolve(stateDir, "..", "..");
   const [rawSessionInfo, usableSessionInfo] = await Promise.all([
     readSessionState(cwd),
     readUsableSessionState(cwd),
@@ -620,7 +699,7 @@ async function readActiveRalphState(
     if (
       sessionScoped?.active === true
       && isRalphStartingPhase(sessionScoped)
-      && !(await isVisibleRalphActiveForSession(cwd, sessionId))
+      && !(await isVisibleRalphActiveForSession(stateDir, sessionId))
     ) {
       continue;
     }
@@ -634,7 +713,7 @@ async function readActiveRalphState(
         currentNativeSessionId,
         tmuxPaneId: safeString(ownerContext?.tmuxPaneId).trim(),
       })
-      && await hasConsistentRalphSkillActivation(cwd, sessionId)
+      && await hasConsistentRalphSkillActivation(stateDir, sessionId)
     ) {
       return { state: sessionScoped, path: sessionScopedPath };
     }
@@ -1049,28 +1128,31 @@ async function buildSessionStartContext(
     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: string[] = [];
+    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) summary.push(`- conventions: ${conventions}`);
     if (build) summary.push(`- build: ${build}`);
     if (directives.length > 0) {
       const firstDirective = directives[0] as Record<string, unknown>;
-      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] as Record<string, unknown>;
-      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"));
     }
   }
@@ -1313,6 +1395,10 @@ function buildNativeOutsideTmuxTeamPromptBlockState(
   };
 }
 
+function buildSkillStateCliInstruction(mode: string, statePath: string): string {
+  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: string,
   skillState?: SkillActiveState | null,
@@ -1374,7 +1460,7 @@ function buildAdditionalContextMessage(
       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)
@@ -1386,7 +1472,7 @@ function buildAdditionalContextMessage(
 
   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,
@@ -1413,7 +1499,7 @@ function buildAdditionalContextMessage(
         ? `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,
@@ -1480,7 +1566,7 @@ async function resolveTeamWorkerStopDecision(
   const blockWorkerStop = (
     reasonCode: string,
     detail: string,
-    stateDirForDecision = join(cwd, ".omx", "state"),
+    stateDirForDecision = getBaseStateDir(cwd),
   ): TeamWorkerStopDecision => ({
     kind: "blocked",
     stateDir: stateDirForDecision,
@@ -1618,20 +1704,33 @@ async function buildModeBasedStopOutput(
   };
 }
 
-function looksLikeGoalCompletionPrompt(text: string): boolean {
-  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: string): boolean {
+  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: string): Promise<{ workflow: string; command: string } | null> {
+async function findActiveGoalWorkflowReconciliationRequirement(cwd: string): Promise<{ workflow: string; command: string; remediation?: string } | null> {
   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(" "),
     };
   }
 
@@ -1675,7 +1774,8 @@ async function buildGoalWorkflowReconciliationPromptWarning(cwd: string, 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(
@@ -1687,7 +1787,11 @@ async function buildGoalWorkflowReconciliationStopOutput(
   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.`;
+    [
+      `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,
@@ -1698,6 +1802,7 @@ async function buildGoalWorkflowReconciliationStopOutput(
 
 async function readTeamModeStateForStop(
   cwd: string,
+  stateDir: string,
   sessionId?: string,
 ): Promise<Record<string, unknown> | null> {
   const normalizedSessionId = safeString(sessionId).trim();
@@ -1705,10 +1810,10 @@ async function readTeamModeStateForStop(
     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();
@@ -1723,7 +1828,7 @@ async function buildTeamStopOutput(cwd: string, sessionId?: string): Promise<Rec
   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();
   if (teamName) {
@@ -1781,12 +1886,13 @@ function hasReleaseReadinessMode(payload: CodexHookPayload): boolean {
 
 async function hasReleaseReadinessStopMarker(
   cwd: string,
+  stateDir: string,
   sessionId: string,
   teamName: string,
 ): Promise<boolean> {
   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;
   }
@@ -1831,8 +1937,11 @@ async function readStopSessionPinnedState(
   fileName: string,
   cwd: string,
   sessionId: string,
+  stateDir?: string,
 ): Promise<Record<string, unknown> | null> {
-  const statePath = getStateFilePath(fileName, cwd, sessionId || undefined);
+  const statePath = stateDir && sessionId
+    ? join(stateDir, "sessions", sessionId, fileName)
+    : getStateFilePath(fileName, cwd, sessionId || undefined);
   return readJsonIfExists(statePath);
 }
 
@@ -1883,11 +1992,12 @@ function modeStateMatchesSkillStopContext(
 
 async function readBlockingSkillForStop(
   cwd: string,
+  stateDir: string,
   sessionId: string,
   threadId: string,
   requiredSkill?: string,
 ): Promise<{ skill: string; phase: string; latestPlanPath?: string; planningComplete?: boolean; runOutcome?: string } | null> {
-  const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+  const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
   const visibleEntries = canonicalState ? listActiveSkills(canonicalState) : [];
   const candidateSkills = requiredSkill
     ? [requiredSkill]
@@ -1897,7 +2007,7 @@ async function readBlockingSkillForStop(
     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)) continue;
 
@@ -1957,11 +2067,12 @@ function isTerminalOrInactiveModeState(state: Record<string, unknown> | null): b
 
 async function readSessionScopedModeStateForRootSkill(
   cwd: string,
+  stateDir: string,
   skill: string,
   sessionIds: string[],
 ): Promise<Record<string, unknown> | null> {
   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;
@@ -1969,9 +2080,10 @@ async function readSessionScopedModeStateForRootSkill(
 
 async function reconcileStaleRootSkillActiveStateForStop(
   cwd: string,
+  stateDir: string,
   sessionId: string,
 ): Promise<void> {
-  const { rootPath } = getSkillActiveStatePaths(cwd);
+  const { rootPath } = getSkillActiveStatePathsForStateDir(stateDir);
   const rootState = await readSkillActiveState(rootPath);
   if (!rootState?.active) return;
 
@@ -1997,7 +2109,7 @@ async function reconcileStaleRootSkillActiveStateForStop(
       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;
@@ -2076,12 +2188,13 @@ function buildRalplanContinuationStatus(
 
 async function readStopAutoNudgePhase(
   cwd: string,
+  stateDir: string,
   sessionId: string,
   threadId: string,
 ): Promise<string> {
   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"
@@ -2089,7 +2202,7 @@ async function readStopAutoNudgePhase(
       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"
@@ -2100,7 +2213,7 @@ async function readStopAutoNudgePhase(
 
   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"
@@ -2108,7 +2221,7 @@ async function readStopAutoNudgePhase(
   ));
   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();
@@ -2117,11 +2230,12 @@ async function readStopAutoNudgePhase(
 
 async function buildDeepInterviewQuestionStopOutput(
   cwd: string,
+  stateDir: string,
   sessionId: string,
   threadId: string,
 ): Promise<{ output: Record<string, unknown>; obligationId: string } | null> {
   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);
@@ -2133,7 +2247,7 @@ async function buildDeepInterviewQuestionStopOutput(
     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"
@@ -2336,9 +2450,10 @@ async function findCanonicalActiveTeamForSession(
 
 async function resolveActiveTeamNameForStop(
   cwd: string,
+  stateDir: string,
   sessionId: string,
 ): Promise<string> {
-  const directState = await readTeamModeStateForStop(cwd, sessionId);
+  const directState = await readTeamModeStateForStop(cwd, stateDir, sessionId);
   const directTeamName = safeString(directState?.team_name).trim();
   if (directState?.active === true && directTeamName) return directTeamName;
 
@@ -2354,12 +2469,12 @@ async function maybeBuildReleaseReadinessFinalizeStopOutput(
 ): Promise<{ matched: boolean; output: Record<string, unknown> | null }> {
   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 };
   }
@@ -2397,10 +2512,11 @@ async function maybeBuildReleaseReadinessFinalizeStopOutput(
 
 async function buildSkillStopOutput(
   cwd: string,
+  stateDir: string,
   sessionId: string,
   threadId: string,
 ): Promise<Record<string, unknown> | null> {
-  const blocker = await readBlockingSkillForStop(cwd, sessionId, threadId);
+  const blocker = await readBlockingSkillForStop(cwd, stateDir, sessionId, threadId);
   if (!blocker) return null;
 
   const subagentSummary = await readSubagentSessionSummary(cwd, sessionId).catch(() => null);
@@ -2547,17 +2663,41 @@ async function buildStopHookOutput(
   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) {
@@ -2667,6 +2807,7 @@ async function buildStopHookOutput(
     if (canonicalSessionId) {
       const deepInterviewQuestionOutput = await buildDeepInterviewQuestionStopOutput(
         cwd,
+        stateDir,
         canonicalSessionId,
         threadId,
       );
@@ -2700,7 +2841,7 @@ async function buildStopHookOutput(
         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,
@@ -2730,7 +2871,7 @@ async function buildStopHookOutput(
       );
     }
     const autoNudgeConfig = await loadAutoNudgeConfig();
-    const autoNudgePhase = await readStopAutoNudgePhase(cwd, canonicalSessionId, threadId);
+    const autoNudgePhase = await readStopAutoNudgePhase(cwd, stateDir, canonicalSessionId, threadId);
 
     if (
       autoNudgeConfig.enabled
@@ -2816,7 +2957,9 @@ export async function dispatchCodexNativeHook(
 ): Promise<NativeHookDispatchResult> {
   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);
@@ -2918,6 +3061,7 @@ export async function dispatchCodexNativeHook(
         turnId || undefined,
       ) ?? await recordSkillActivation({
         stateDir,
+        sourceCwd: cwd,
         text: prompt,
         sessionId: sessionIdForState,
         threadId,

package/src/scripts/codex-native-pre-post.ts

@@ -185,7 +185,10 @@ function resolveOmxParityTarget(toolName: string): { command: OmxParityCommand;
   if (!match) return null;
 
   const [, server, tool] = match;
-  if (server === "state") return { command: "state", tool };
+  if (server === "state") {
+    const stateTool = tool.replace(/^state_/, "").replace(/_/g, "-");
+    return { command: "state", tool: stateTool };
+  }
   if (server === "trace") return { command: "trace", tool };
   if (server === "code_intel") return { command: "code-intel", tool };
   if (server === "memory" && tool.startsWith("notepad_")) {