oh-my-codex 0.16.2 → 0.16.4

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 {
@@ -35,7 +35,7 @@ import {
 } 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,
@@ -71,12 +71,12 @@ import type { HookEventEnvelope } from "../hooks/extensibility/types.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 { 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";
@@ -486,6 +486,12 @@ interface ActiveRalphStopState {
   path: string;
 }
 
+interface RalphCompletionAuditBlockState {
+  state: Record<string, unknown>;
+  path: string;
+  reason: string;
+}
+
 interface RalphStopOwnershipContext {
   sessionId: string;
   payloadSessionId: string;
@@ -560,8 +566,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"
@@ -569,8 +575,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();
@@ -582,7 +588,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?: {
@@ -591,7 +664,6 @@ async function readActiveRalphState(
     tmuxPaneId?: string;
   },
 ): Promise<ActiveRalphStopState | null> {
-  const cwd = resolve(stateDir, "..", "..");
   const [rawSessionInfo, usableSessionInfo] = await Promise.all([
     readSessionState(cwd),
     readUsableSessionState(cwd),
@@ -621,7 +693,7 @@ async function readActiveRalphState(
     if (
       sessionScoped?.active === true
       && isRalphStartingPhase(sessionScoped)
-      && !(await isVisibleRalphActiveForSession(cwd, sessionId))
+      && !(await isVisibleRalphActiveForSession(stateDir, sessionId))
     ) {
       continue;
     }
@@ -635,7 +707,7 @@ async function readActiveRalphState(
         currentNativeSessionId,
         tmuxPaneId: safeString(ownerContext?.tmuxPaneId).trim(),
       })
-      && await hasConsistentRalphSkillActivation(cwd, sessionId)
+      && await hasConsistentRalphSkillActivation(stateDir, sessionId)
     ) {
       return { state: sessionScoped, path: sessionScopedPath };
     }
@@ -1314,6 +1386,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,
@@ -1375,7 +1451,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)
@@ -1387,7 +1463,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,
@@ -1414,7 +1490,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,
@@ -1481,7 +1557,7 @@ async function resolveTeamWorkerStopDecision(
   const blockWorkerStop = (
     reasonCode: string,
     detail: string,
-    stateDirForDecision = join(cwd, ".omx", "state"),
+    stateDirForDecision = getBaseStateDir(cwd),
   ): TeamWorkerStopDecision => ({
     kind: "blocked",
     stateDir: stateDirForDecision,
@@ -1654,7 +1730,10 @@ async function findActiveGoalWorkflowReconciliationRequirement(cwd: string): Pro
     if (!entry.isDirectory()) 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>'`,
@@ -1696,6 +1775,7 @@ async function buildGoalWorkflowReconciliationStopOutput(
 
 async function readTeamModeStateForStop(
   cwd: string,
+  stateDir: string,
   sessionId?: string,
 ): Promise<Record<string, unknown> | null> {
   const normalizedSessionId = safeString(sessionId).trim();
@@ -1703,10 +1783,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();
@@ -1721,7 +1801,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) {
@@ -1779,12 +1859,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;
   }
@@ -1829,8 +1910,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);
 }
 
@@ -1881,11 +1965,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]
@@ -1895,7 +1980,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;
 
@@ -1955,11 +2040,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;
@@ -1967,9 +2053,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;
 
@@ -1995,7 +2082,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;
@@ -2074,12 +2161,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"
@@ -2087,7 +2175,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"
@@ -2098,7 +2186,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"
@@ -2106,7 +2194,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();
@@ -2115,11 +2203,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);
@@ -2131,7 +2220,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"
@@ -2334,9 +2423,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;
 
@@ -2352,12 +2442,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 };
   }
@@ -2395,10 +2485,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);
@@ -2545,17 +2636,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) {
@@ -2665,6 +2780,7 @@ async function buildStopHookOutput(
     if (canonicalSessionId) {
       const deepInterviewQuestionOutput = await buildDeepInterviewQuestionStopOutput(
         cwd,
+        stateDir,
         canonicalSessionId,
         threadId,
       );
@@ -2698,7 +2814,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,
@@ -2728,7 +2844,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
@@ -2814,7 +2930,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);
@@ -2916,6 +3034,7 @@ export async function dispatchCodexNativeHook(
         turnId || undefined,
       ) ?? await recordSkillActivation({
         stateDir,
+        sourceCwd: cwd,
         text: prompt,
         sessionId: sessionIdForState,
         threadId,
@@ -3023,25 +3142,10 @@ export async function dispatchCodexNativeHook(
   }
 
   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"
       ? await buildSessionStartContext(cwd, canonicalSessionId || nativeSessionId, {

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_")) {