oh-my-codex 0.12.4 → 0.12.6

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

@@ -2,13 +2,14 @@ import { execFileSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { mkdir, readFile, readdir, writeFile } from "fs/promises";
 import { join, resolve } from "path";
-import { readModeState, updateModeState } from "../modes/base.js";
+import { readModeState, readModeStateForSession, updateModeState } from "../modes/base.js";
 import {
   listActiveSkills,
   readVisibleSkillActiveState,
 } from "../state/skill-active.js";
 import { readSubagentSessionSummary } from "../subagents/tracker.js";
 import { resolveCanonicalTeamStateRoot } from "../team/state-root.js";
+import { readUsableSessionState, reconcileNativeSessionStart } from "../hooks/session.js";
 import {
   appendTeamEvent,
   readTeamLeaderAttention,
@@ -17,8 +18,10 @@ import {
   writeTeamLeaderAttention,
   writeTeamPhase,
 } from "../team/state.js";
-import { omxNotepadPath, omxProjectMemoryPath, omxStateDir } from "../utils/paths.js";
+import { omxNotepadPath, omxProjectMemoryPath } from "../utils/paths.js";
+import { getStateFilePath } from "../mcp/state-paths.js";
 import {
+  detectKeywords,
   detectPrimaryKeyword,
   recordSkillActivation,
   type SkillActiveState,
@@ -27,6 +30,7 @@ import {
   detectStallPattern,
   loadAutoNudgeConfig,
   normalizeAutoNudgeSignatureText,
+  resolveEffectiveAutoNudgeResponse,
 } from "./notify-hook/auto-nudge.js";
 import {
   buildNativePostToolUseOutput,
@@ -38,8 +42,8 @@ import {
 } from "../hooks/extensibility/events.js";
 import type { HookEventEnvelope } from "../hooks/extensibility/types.js";
 import { dispatchHookEvent } from "../hooks/extensibility/dispatcher.js";
-import { writeSessionStart } from "../hooks/session.js";
 import { reconcileHudForPromptSubmit } from "../hud/reconcile.js";
+import { onSessionStart as buildWikiSessionStartContext } from "../wiki/lifecycle.js";
 
 type CodexHookEventName =
   | "SessionStart"
@@ -64,9 +68,17 @@ export interface NativeHookDispatchResult {
 
 const TERMINAL_RALPH_PHASES = new Set(["complete", "failed", "cancelled"]);
 const TERMINAL_MODE_PHASES = new Set(["complete", "failed", "cancelled"]);
-const SKILL_STOP_BLOCKERS = new Set(["ralplan", "deep-interview"]);
+const SKILL_STOP_BLOCKERS = new Set(["ralplan"]);
 const TEAM_TERMINAL_TASK_STATUSES = new Set(["completed", "failed"]);
 const NATIVE_STOP_STATE_FILE = "native-stop-state.json";
+const STABLE_FINAL_RECOMMENDATION_PATTERNS = [
+  /^\s*(?:launch|release|ship)-?ready\s*:\s*(?:yes|no)\b[^\n\r]*/im,
+  /^\s*ready to release\s*:\s*(?:yes|no)\b[^\n\r]*/im,
+  /^\s*(?:final\s+)?recommendation\s*:\s*(?:yes|no|ship|hold|release|do not release|proceed|do not proceed)\b[^\n\r]*/im,
+  /^\s*decision\s*:\s*(?:yes|no|ship|hold|release|do not release|proceed|do not proceed)\b[^\n\r]*/im,
+] as const;
+const RELEASE_READINESS_FINALIZE_SYSTEM_MESSAGE =
+  "OMX release-readiness detected a stable final recommendation with no active worker tasks; emit one concise final decision summary and finalize.";
 
 function safeString(value: unknown): string {
   return typeof value === "string" ? value : "";
@@ -138,6 +150,21 @@ function readPromptText(payload: CodexHookPayload): string {
   return "";
 }
 
+function sanitizePayloadForHookContext(
+  payload: CodexHookPayload,
+  hookEventName: CodexHookEventName,
+): CodexHookPayload {
+  if (hookEventName !== "UserPromptSubmit") return payload;
+
+  const sanitized = { ...payload };
+  delete sanitized.prompt;
+  delete sanitized.input;
+  delete sanitized.user_prompt;
+  delete sanitized.userPrompt;
+  delete sanitized.text;
+  return sanitized;
+}
+
 function buildBaseContext(
   cwd: string,
   payload: CodexHookPayload,
@@ -148,10 +175,7 @@ function buildBaseContext(
     project_path: cwd,
     transcript_path: safeString(payload.transcript_path ?? payload.transcriptPath) || null,
     source: safeString(payload.source),
-    payload,
-    ...(hookEventName === "UserPromptSubmit"
-      ? { prompt: readPromptText(payload) }
-      : {}),
+    payload: sanitizePayloadForHookContext(payload, hookEventName),
   };
 }
 
@@ -174,12 +198,20 @@ function formatPhase(value: unknown, fallback = "active"): string {
   return phase || fallback;
 }
 
-async function readActiveRalphState(stateDir: string): Promise<Record<string, unknown> | null> {
-  const sessionInfo = await readJsonIfExists(join(stateDir, "session.json"));
+async function readActiveRalphState(
+  stateDir: string,
+  preferredSessionId?: string,
+): Promise<Record<string, unknown> | null> {
+  const sessionInfo = await readUsableSessionState(resolve(stateDir, "..", ".."));
   const currentOmxSessionId = safeString(sessionInfo?.session_id).trim();
-  if (currentOmxSessionId) {
+  const sessionCandidates = [...new Set([
+    safeString(preferredSessionId).trim(),
+    currentOmxSessionId,
+  ].filter(Boolean))];
+
+  for (const sessionId of sessionCandidates) {
     const sessionScoped = await readJsonIfExists(
-      join(stateDir, "sessions", currentOmxSessionId, "ralph-state.json"),
+      join(stateDir, "sessions", sessionId, "ralph-state.json"),
     );
     if (
       sessionScoped?.active === true
@@ -191,13 +223,13 @@ async function readActiveRalphState(stateDir: string): Promise<Record<string, un
     }
   }
 
+  if (sessionCandidates.length > 0) return null;
+
   const direct = await readJsonIfExists(join(stateDir, "ralph-state.json"));
   if (direct?.active === true && !TERMINAL_RALPH_PHASES.has(safeString(direct.current_phase).trim().toLowerCase())) {
     return direct;
   }
 
-  if (currentOmxSessionId) return null;
-
   const sessionsRoot = join(stateDir, "sessions");
   if (!existsSync(sessionsRoot)) return null;
   const entries = await readdir(sessionsRoot, { withFileTypes: true }).catch(() => []);
@@ -415,6 +447,11 @@ async function buildSessionStartContext(
     }
   }
 
+  const wikiContext = buildWikiSessionStartContext({ cwd });
+  if (wikiContext.additionalContext) {
+    sections.push(wikiContext.additionalContext);
+  }
+
   const subagentSummary = await readSubagentSessionSummary(cwd, sessionId).catch(() => null);
   if (subagentSummary && subagentSummary.activeSubagentThreadIds.length > 0) {
     sections.push(`[Subagents]\n- active subagent threads: ${subagentSummary.activeSubagentThreadIds.length}`);
@@ -425,31 +462,84 @@ async function buildSessionStartContext(
 
 function buildAdditionalContextMessage(prompt: string, skillState?: SkillActiveState | null): string | null {
   if (!prompt) return null;
+  const matches = detectKeywords(prompt);
   const match = detectPrimaryKeyword(prompt);
   if (!match) return null;
+  const detectedKeywordMessage = matches.length > 1
+    ? `OMX native UserPromptSubmit detected workflow keywords ${matches.map((entry) => `"${entry.keyword}" -> ${entry.skill}`).join(", ")}.`
+    : `OMX native UserPromptSubmit detected workflow keyword "${match.keyword}" -> ${match.skill}.`;
+  const activeSkills = Array.isArray(skillState?.active_skills)
+    ? skillState.active_skills.map((entry) => entry.skill)
+    : [];
+  const deferredSkills = Array.isArray(skillState?.deferred_skills)
+    ? skillState.deferred_skills
+    : [];
+  const teamDetected = activeSkills.includes("team");
+  const combinedTransitionMessage = (() => {
+    if (!skillState?.transition_message) return null;
+    if (matches.length <= 1 || activeSkills.length <= 1) return skillState.transition_message;
+    const source = skillState.transition_message.match(/^mode transiting: (.+?) -> /)?.[1];
+    if (!source) return skillState.transition_message;
+    return `mode transiting: ${source} -> ${activeSkills.join(" + ")}`;
+  })();
+
+  if (skillState?.transition_error) {
+    return [
+      `OMX native UserPromptSubmit denied workflow keyword "${match.keyword}" -> ${match.skill}.`,
+      skillState.transition_error,
+      'Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.',
+    ].join(' ');
+  }
+
+  if (skillState?.transition_message) {
+    return [
+      detectedKeywordMessage,
+      combinedTransitionMessage,
+      activeSkills.length > 1 ? `active skills: ${activeSkills.join(", ")}.` : null,
+      deferredSkills.length > 0
+        ? `planning preserved over simultaneous execution follow-up; deferred skills: ${deferredSkills.join(", ")}.`
+        : null,
+      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.`
+        : null,
+      teamDetected
+        ? "Use the durable OMX team runtime via `omx team ...` for coordinated execution; do not replace it with in-process fanout."
+        : null,
+      teamDetected ? "If you need help, run `omx team --help`." : null,
+      'Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.',
+    ].filter(Boolean).join(' ');
+  }
 
-  if (match.skill === "team") {
+  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.`
       : null;
     return [
-      `OMX native UserPromptSubmit detected workflow keyword "${match.keyword}" -> ${match.skill}.`,
+      detectedKeywordMessage,
+      activeSkills.length > 1 ? `active skills: ${activeSkills.join(", ")}.` : null,
+      deferredSkills.length > 0
+        ? `planning preserved over simultaneous execution follow-up; deferred skills: ${deferredSkills.join(", ")}.`
+        : null,
       initializedStateMessage,
       "Use the durable OMX team runtime via `omx team ...` for coordinated execution; do not replace it with in-process fanout.",
       "If you need help, run `omx team --help`.",
-      "Follow AGENTS.md routing and preserve ralplan/ralph execution gates.",
+      "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.",
     ].filter(Boolean).join(" ");
   }
 
   if (skillState?.initialized_mode && skillState.initialized_state_path) {
     return [
-      `OMX native UserPromptSubmit detected workflow keyword "${match.keyword}" -> ${match.skill}.`,
+      detectedKeywordMessage,
+      activeSkills.length > 1 ? `active skills: ${activeSkills.join(", ")}.` : null,
+      deferredSkills.length > 0
+        ? `planning preserved over simultaneous execution follow-up; deferred skills: ${deferredSkills.join(", ")}.`
+        : null,
       `skill: ${skillState.initialized_mode} activated and initial state initialized at ${skillState.initialized_state_path}; write subsequent updates via omx_state MCP.`,
-      "Follow AGENTS.md routing and preserve ralplan/ralph execution gates.",
+      "Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.",
     ].join(" ");
   }
 
-  return `OMX native UserPromptSubmit detected workflow keyword "${match.keyword}" -> ${match.skill}. Follow AGENTS.md routing and preserve ralplan/ralph execution gates.`;
+  return `${detectedKeywordMessage} Follow AGENTS.md routing and preserve workflow transition and planning-safety rules.`;
 }
 
 function parseTeamWorkerEnv(rawValue: string): { teamName: string; workerName: string } | null {
@@ -570,8 +660,11 @@ function isStopExempt(payload: CodexHookPayload): boolean {
 async function buildModeBasedStopOutput(
   mode: "autopilot" | "ultrawork" | "ultraqa",
   cwd: string,
+  sessionId?: string,
 ): Promise<Record<string, unknown> | null> {
-  const state = await readModeState(mode, cwd);
+  const state = sessionId
+    ? await readModeStateForSession(mode, sessionId, cwd)
+    : await readModeState(mode, cwd);
   if (state?.active !== true || !isNonTerminalPhase(state.current_phase)) return null;
   const phase = formatPhase(state.current_phase);
   return {
@@ -582,10 +675,39 @@ async function buildModeBasedStopOutput(
   };
 }
 
-async function buildTeamStopOutput(cwd: string): Promise<Record<string, unknown> | null> {
-  const teamState = await readModeState("team", cwd);
+async function readTeamModeStateForStop(
+  cwd: string,
+  sessionId?: string,
+): Promise<Record<string, unknown> | null> {
+  const normalizedSessionId = safeString(sessionId).trim();
+  if (!normalizedSessionId) {
+    return await readModeState("team", cwd);
+  }
+
+  const scopedState = await readStopSessionPinnedState("team-state.json", cwd, normalizedSessionId);
+  if (scopedState) return scopedState;
+
+  const rootState = await readJsonIfExists(join(cwd, ".omx", "state", "team-state.json"));
+  if (rootState?.active !== true) return null;
+
+  const ownerSessionId = safeString(rootState.session_id).trim();
+  if (ownerSessionId && ownerSessionId !== normalizedSessionId) {
+    return null;
+  }
+
+  return rootState;
+}
+
+async function buildTeamStopOutput(cwd: string, sessionId?: string): Promise<Record<string, unknown> | null> {
+  const teamState = await readTeamModeStateForStop(cwd, sessionId);
   if (teamState?.active !== true) return null;
   const teamName = safeString(teamState.team_name).trim();
+  if (teamName) {
+    const canonicalTeamDir = join(resolveCanonicalTeamStateRoot(cwd), "team", teamName);
+    if (!existsSync(canonicalTeamDir)) {
+      return null;
+    }
+  }
   const coarsePhase = teamState.current_phase;
   const canonicalPhase = teamName ? (await readTeamPhase(teamName, cwd))?.current_phase ?? coarsePhase : coarsePhase;
   if (!isNonTerminalPhase(canonicalPhase)) return null;
@@ -606,6 +728,54 @@ function buildTeamStopOutputForPhase(teamName: string, phase: string): Record<st
   };
 }
 
+function extractStableFinalRecommendationSummary(message: string): string {
+  for (const pattern of STABLE_FINAL_RECOMMENDATION_PATTERNS) {
+    const match = pattern.exec(message);
+    if (!match) continue;
+    const summary = match[0]?.trim().replace(/\s+/g, " ");
+    if (!summary) continue;
+    return /[.!?]$/.test(summary) ? summary : `${summary}.`;
+  }
+  return "";
+}
+
+function buildStableFinalRecommendationStopSignature(
+  payload: CodexHookPayload,
+  teamName: string,
+  summary: string,
+): string {
+  const sessionId = readPayloadSessionId(payload) || "no-session";
+  const threadId = readPayloadThreadId(payload) || "no-thread";
+  const normalizedSummary = normalizeAutoNudgeSignatureText(summary) || summary.toLowerCase();
+  return ["release-readiness-finalize", sessionId, threadId, teamName, normalizedSummary].join("|");
+}
+
+function hasReleaseReadinessMode(payload: CodexHookPayload): boolean {
+  const mode = safeString(payload.mode).trim().toLowerCase();
+  return mode === "release-readiness";
+}
+
+async function hasReleaseReadinessStopMarker(
+  cwd: string,
+  sessionId: string,
+  teamName: string,
+): Promise<boolean> {
+  if (!sessionId) return false;
+
+  const markerState = await readStopSessionPinnedState("release-readiness-state.json", cwd, sessionId);
+  if (markerState?.active !== true || markerState.stable_final_recommendation_emitted !== true) {
+    return false;
+  }
+
+  const markerTeamName = safeString(markerState.team_name).trim();
+  if (markerTeamName && markerTeamName !== teamName) return false;
+
+  const markerSessionId = safeString(markerState.session_id).trim();
+  if (markerSessionId && markerSessionId !== sessionId) return false;
+
+  return true;
+}
+
 function readPayloadSessionId(payload: CodexHookPayload): string {
   return safeString(payload.session_id ?? payload.sessionId).trim();
 }
@@ -618,29 +788,19 @@ function readPayloadTurnId(payload: CodexHookPayload): string {
   return safeString(payload.turn_id ?? payload.turnId).trim();
 }
 
-async function isDeepInterviewSuppressedForStop(
+async function resolveInternalSessionIdForPayload(
   cwd: string,
-  sessionId: string,
-  threadId: string,
-): Promise<boolean> {
-  const scopedModeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId);
-  if (scopedModeState?.active === true) return true;
-
-  const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
-  const deepInterviewEntry = canonicalState
-    ? listActiveSkills(canonicalState).find((entry) => (
-      entry.skill === "deep-interview"
-      && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)
-    ))
-    : null;
-  if (
-    deepInterviewEntry
-    && safeObject(canonicalState?.input_lock).active === true
-  ) {
-    return true;
-  }
-
-  return (await readBlockingSkillForStop(cwd, sessionId, threadId, "deep-interview")) !== null;
+  payloadSessionId: string,
+): Promise<string> {
+  const currentSession = await readUsableSessionState(cwd);
+  const canonicalSessionId = safeString(currentSession?.session_id).trim();
+  if (!canonicalSessionId) return payloadSessionId;
+
+  const nativeSessionId = safeString(currentSession?.native_session_id).trim();
+  if (!payloadSessionId) return canonicalSessionId;
+  if (payloadSessionId === canonicalSessionId) return canonicalSessionId;
+  if (nativeSessionId && payloadSessionId === nativeSessionId) return canonicalSessionId;
+  return payloadSessionId;
 }
 
 async function readStopSessionPinnedState(
@@ -648,10 +808,7 @@ async function readStopSessionPinnedState(
   cwd: string,
   sessionId: string,
 ): Promise<Record<string, unknown> | null> {
-  const stateDir = omxStateDir(cwd);
-  const statePath = sessionId
-    ? join(stateDir, "sessions", sessionId, fileName)
-    : join(stateDir, fileName);
+  const statePath = getStateFilePath(fileName, cwd, sessionId || undefined);
   return readJsonIfExists(statePath);
 }
 
@@ -716,6 +873,28 @@ async function readBlockingSkillForStop(
   return null;
 }
 
+async function readStopAutoNudgePhase(
+  cwd: string,
+  sessionId: string,
+  threadId: string,
+): Promise<string> {
+  if (!sessionId.trim()) return "";
+
+  const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+  const visibleEntries = canonicalState ? listActiveSkills(canonicalState) : [];
+  const deepInterview = visibleEntries.find((entry) => (
+    entry.skill === "deep-interview"
+    && matchesSkillStopContext(entry, canonicalState ?? {}, sessionId, threadId)
+  ));
+  if (!deepInterview) return "";
+
+  const modeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId);
+  if (!modeState || modeState.active !== true) return "";
+
+  const modePhase = safeString(modeState.current_phase).trim().toLowerCase();
+  return modePhase === "intent-first" ? "planning" : "";
+}
+
 function buildRepeatableStopSignature(
   payload: CodexHookPayload,
   kind: string,
@@ -750,10 +929,6 @@ function buildRepeatableStopSignature(
   ].join("|");
 }
 
-async function readNativeStopState(stateDir: string): Promise<Record<string, unknown>> {
-  return await readJsonIfExists(join(stateDir, NATIVE_STOP_STATE_FILE)) ?? {};
-}
-
 function readNativeStopSessionKey(payload: CodexHookPayload): string {
   return readPayloadSessionId(payload) || readPayloadThreadId(payload) || "global";
 }
@@ -773,7 +948,8 @@ async function persistNativeStopSignature(
   signature: string,
 ): Promise<void> {
   if (!signature) return;
-  const state = await readNativeStopState(stateDir);
+  const statePath = join(stateDir, NATIVE_STOP_STATE_FILE);
+  const state = await readJsonIfExists(statePath) ?? {};
   const sessions = safeObject(state.sessions);
   const sessionKey = readNativeStopSessionKey(payload);
   sessions[sessionKey] = {
@@ -781,7 +957,8 @@ async function persistNativeStopSignature(
     last_signature: signature,
     updated_at: new Date().toISOString(),
   };
-  await writeFile(join(stateDir, NATIVE_STOP_STATE_FILE), JSON.stringify({
+  await mkdir(stateDir, { recursive: true });
+  await writeFile(statePath, JSON.stringify({
     ...state,
     sessions,
   }, null, 2));
@@ -796,7 +973,7 @@ async function maybeReturnRepeatableStopOutput(
   if (!output) return null;
   const stopHookActive = payload.stop_hook_active === true || payload.stopHookActive === true;
   if (stopHookActive) {
-    const state = await readNativeStopState(stateDir);
+    const state = await readJsonIfExists(join(stateDir, NATIVE_STOP_STATE_FILE)) ?? {};
     const previousSignature = readPreviousNativeStopSignature(state, readNativeStopSessionKey(payload));
     if (!signature || previousSignature === signature) {
       return null;
@@ -838,6 +1015,66 @@ async function findCanonicalActiveTeamForSession(
   return null;
 }
 
+async function resolveActiveTeamNameForStop(
+  cwd: string,
+  sessionId: string,
+): Promise<string> {
+  const directState = await readTeamModeStateForStop(cwd, sessionId);
+  const directTeamName = safeString(directState?.team_name).trim();
+  if (directState?.active === true && directTeamName) return directTeamName;
+
+  const canonicalTeam = await findCanonicalActiveTeamForSession(cwd, sessionId);
+  return canonicalTeam?.teamName ?? "";
+}
+
+async function maybeBuildReleaseReadinessFinalizeStopOutput(
+  payload: CodexHookPayload,
+  cwd: string,
+  stateDir: string,
+  sessionId: string,
+): Promise<{ matched: boolean; output: Record<string, unknown> | null }> {
+  if (!sessionId) return { matched: false, output: null };
+
+  const teamName = await resolveActiveTeamNameForStop(cwd, sessionId);
+  if (!teamName) return { matched: false, output: null };
+
+  const explicitReleaseReadinessContext =
+    hasReleaseReadinessMode(payload)
+    || await hasReleaseReadinessStopMarker(cwd, sessionId, teamName);
+  if (!explicitReleaseReadinessContext) {
+    return { matched: false, output: null };
+  }
+
+  const summary = extractStableFinalRecommendationSummary(
+    safeString(payload.last_assistant_message ?? payload.lastAssistantMessage),
+  );
+  if (!summary) return { matched: false, output: null };
+
+  const leaderAttention = await readTeamLeaderAttention(teamName, cwd);
+  if (
+    !leaderAttention
+    || leaderAttention.leader_decision_state !== "done_waiting_on_leader"
+    || leaderAttention.work_remaining !== false
+  ) {
+    return { matched: false, output: null };
+  }
+
+  const signature = buildStableFinalRecommendationStopSignature(payload, teamName, summary);
+  const output = await maybeReturnRepeatableStopOutput(
+    payload,
+    stateDir,
+    signature,
+    {
+      decision: "block",
+      reason:
+        `Stable final recommendation already reached with no active worker tasks. Emit exactly one concise final decision summary aligned to "${summary}" with no filler or residual acknowledgements (for example "yes"), then stop.`,
+      stopReason: "release_readiness_auto_finalize",
+      systemMessage: RELEASE_READINESS_FINALIZE_SYSTEM_MESSAGE,
+    },
+  );
+  return { matched: true, output };
+}
+
 async function buildSkillStopOutput(
   cwd: string,
   sessionId: string,
@@ -863,7 +1100,7 @@ async function findActiveTeamForTransportFailure(
   cwd: string,
   sessionId: string,
 ): Promise<{ teamName: string; phase: string } | null> {
-  const teamState = await readModeState("team", cwd);
+  const teamState = await readModeStateForSession("team", sessionId, cwd);
   if (teamState?.active === true) {
     const teamName = safeString(teamState.team_name).trim();
     const coarsePhase = formatPhase(teamState.current_phase);
@@ -882,8 +1119,8 @@ async function markTeamTransportFailure(
   cwd: string,
   payload: CodexHookPayload,
 ): Promise<void> {
-  const sessionId = readPayloadSessionId(payload);
-  const activeTeam = await findActiveTeamForTransportFailure(cwd, sessionId);
+  const canonicalSessionId = await resolveInternalSessionIdForPayload(cwd, readPayloadSessionId(payload));
+  const activeTeam = await findActiveTeamForTransportFailure(cwd, canonicalSessionId);
   if (!activeTeam) return;
 
   const nowIso = new Date().toISOString();
@@ -926,7 +1163,7 @@ async function markTeamTransportFailure(
       ],
       leader_stale: existingAttention?.leader_stale ?? false,
       leader_session_active: existingAttention?.leader_session_active ?? true,
-      leader_session_id: existingAttention?.leader_session_id ?? (sessionId || null),
+      leader_session_id: existingAttention?.leader_session_id ?? (canonicalSessionId || null),
       leader_session_stopped_at: existingAttention?.leader_session_stopped_at ?? null,
       unread_leader_message_count: existingAttention?.unread_leader_message_count ?? 0,
       work_remaining: existingAttention?.work_remaining ?? true,
@@ -957,6 +1194,7 @@ async function markTeamTransportFailure(
         last_turn_at: nowIso,
       },
       cwd,
+      canonicalSessionId || undefined,
     );
   } catch {
     // Canonical team state already carries the preserved failure for coarse-state-missing sessions.
@@ -973,30 +1211,39 @@ async function buildStopHookOutput(
   }
 
   const sessionId = readPayloadSessionId(payload);
+  const canonicalSessionId = await resolveInternalSessionIdForPayload(cwd, sessionId);
   const threadId = readPayloadThreadId(payload);
-  const ralphState = await readActiveRalphState(stateDir);
+  const ralphState = await readActiveRalphState(stateDir, canonicalSessionId);
   const stopHookActive = payload.stop_hook_active === true || payload.stopHookActive === true;
   if (!ralphState) {
     const teamWorkerOutput = await buildTeamWorkerStopOutput(cwd);
     if (!stopHookActive && hasTeamWorkerContext()) return teamWorkerOutput;
 
-    const autopilotOutput = await buildModeBasedStopOutput("autopilot", cwd);
+    const autopilotOutput = await buildModeBasedStopOutput("autopilot", cwd, canonicalSessionId);
     if (!stopHookActive && autopilotOutput) return autopilotOutput;
 
-    const ultraworkOutput = await buildModeBasedStopOutput("ultrawork", cwd);
+    const ultraworkOutput = await buildModeBasedStopOutput("ultrawork", cwd, canonicalSessionId);
     if (!stopHookActive && ultraworkOutput) return ultraworkOutput;
 
-    const ultraqaOutput = await buildModeBasedStopOutput("ultraqa", cwd);
+    const ultraqaOutput = await buildModeBasedStopOutput("ultraqa", cwd, canonicalSessionId);
     if (!stopHookActive && ultraqaOutput) return ultraqaOutput;
 
-    const teamOutput = await buildTeamStopOutput(cwd);
+    const releaseReadinessFinalizeResult = await maybeBuildReleaseReadinessFinalizeStopOutput(
+      payload,
+      cwd,
+      stateDir,
+      canonicalSessionId,
+    );
+    if (releaseReadinessFinalizeResult.matched) return releaseReadinessFinalizeResult.output;
+
+    const teamOutput = await buildTeamStopOutput(cwd, canonicalSessionId);
     if (teamOutput) {
       const teamSignature = buildRepeatableStopSignature(payload, "team-stop", safeString(teamOutput.stopReason));
       return await maybeReturnRepeatableStopOutput(payload, stateDir, teamSignature, teamOutput);
     }
 
-    if (sessionId) {
-      const canonicalTeam = await findCanonicalActiveTeamForSession(cwd, sessionId);
+    if (canonicalSessionId) {
+      const canonicalTeam = await findCanonicalActiveTeamForSession(cwd, canonicalSessionId);
       if (canonicalTeam) {
         const canonicalTeamOutput = buildTeamStopOutputForPhase(
           canonicalTeam.teamName,
@@ -1012,28 +1259,28 @@ async function buildStopHookOutput(
         if (repeatedCanonicalTeamOutput) return repeatedCanonicalTeamOutput;
       }
 
-      const skillOutput = await buildSkillStopOutput(cwd, sessionId, threadId);
+      const skillOutput = await buildSkillStopOutput(cwd, canonicalSessionId, threadId);
       if (!stopHookActive && skillOutput) return skillOutput;
     }
 
-    const deepInterviewActive = await isDeepInterviewSuppressedForStop(cwd, sessionId, threadId);
     const lastAssistantMessage = safeString(
       payload.last_assistant_message ?? payload.lastAssistantMessage,
     );
     const autoNudgeConfig = await loadAutoNudgeConfig();
+    const autoNudgePhase = await readStopAutoNudgePhase(cwd, canonicalSessionId, threadId);
 
     if (
-      !deepInterviewActive
-      && autoNudgeConfig.enabled
-      && detectStallPattern(lastAssistantMessage, autoNudgeConfig.patterns)
+      autoNudgeConfig.enabled
+      && detectStallPattern(lastAssistantMessage, autoNudgeConfig.patterns, autoNudgePhase)
     ) {
+      const effectiveResponse = resolveEffectiveAutoNudgeResponse(autoNudgeConfig.response);
       return await maybeReturnRepeatableStopOutput(
         payload,
         stateDir,
         buildRepeatableStopSignature(payload, "auto-nudge", lastAssistantMessage),
         {
           decision: "block",
-          reason: autoNudgeConfig.response,
+          reason: effectiveResponse,
           stopReason: "auto_nudge",
           systemMessage:
             "OMX native Stop detected a stall/permission-style handoff and continued the turn automatically.",
@@ -1073,23 +1320,30 @@ export async function dispatchCodexNativeHook(
   const omxEventName = mapCodexHookEventToOmxEvent(hookEventName);
   let skillState: SkillActiveState | null = null;
 
-  const sessionId = safeString(payload.session_id ?? payload.sessionId).trim();
+  const nativeSessionId = safeString(payload.session_id ?? payload.sessionId).trim();
   const threadId = safeString(payload.thread_id ?? payload.threadId).trim();
   const turnId = safeString(payload.turn_id ?? payload.turnId).trim();
+  let canonicalSessionId = safeString((await readUsableSessionState(cwd))?.session_id).trim();
 
-  if (hookEventName === "SessionStart" && sessionId) {
-    await writeSessionStart(cwd, sessionId, {
+  if (hookEventName === "SessionStart" && nativeSessionId) {
+    const sessionState = await reconcileNativeSessionStart(cwd, nativeSessionId, {
       pid: options.sessionOwnerPid ?? resolveSessionOwnerPid(payload),
     });
+    canonicalSessionId = safeString(sessionState.session_id).trim();
+  } else if (!canonicalSessionId) {
+    canonicalSessionId = safeString((await readUsableSessionState(cwd))?.session_id).trim();
   }
 
+  const eventSessionId = canonicalSessionId || nativeSessionId || undefined;
+  const sessionIdForState = canonicalSessionId || nativeSessionId;
+
   if (hookEventName === "UserPromptSubmit") {
     const prompt = readPromptText(payload);
     if (prompt) {
       skillState = await recordSkillActivation({
         stateDir,
         text: prompt,
-        sessionId,
+        sessionId: sessionIdForState,
         threadId,
         turnId,
       });
@@ -1098,11 +1352,19 @@ export async function dispatchCodexNativeHook(
   }
 
   if (omxEventName) {
+    const baseContext = buildBaseContext(cwd, payload, hookEventName!);
+    if (nativeSessionId) {
+      baseContext.native_session_id = nativeSessionId;
+      baseContext.codex_session_id = nativeSessionId;
+    }
+    if (canonicalSessionId) {
+      baseContext.omx_session_id = canonicalSessionId;
+    }
     const event: HookEventEnvelope = buildNativeHookEvent(
       omxEventName,
-      buildBaseContext(cwd, payload, hookEventName!),
+      baseContext,
       {
-        session_id: sessionId || undefined,
+        session_id: eventSessionId,
         thread_id: threadId || undefined,
         turn_id: turnId || undefined,
         mode: safeString(payload.mode).trim() || undefined,
@@ -1114,7 +1376,7 @@ export async function dispatchCodexNativeHook(
   let outputJson: Record<string, unknown> | null = null;
   if (hookEventName === "SessionStart" || hookEventName === "UserPromptSubmit") {
     const additionalContext = hookEventName === "SessionStart"
-      ? await buildSessionStartContext(cwd, sessionId)
+      ? await buildSessionStartContext(cwd, canonicalSessionId || nativeSessionId)
       : buildAdditionalContextMessage(readPromptText(payload), skillState);
     if (additionalContext) {
       outputJson = {
@@ -1143,17 +1405,49 @@ export async function dispatchCodexNativeHook(
   };
 }
 
-async function readStdinJson(): Promise<CodexHookPayload> {
+interface NativeHookCliReadResult {
+  payload: CodexHookPayload;
+  parseError: Error | null;
+}
+
+async function readStdinJson(): Promise<NativeHookCliReadResult> {
   const chunks: Buffer[] = [];
   for await (const chunk of process.stdin) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
   }
   const raw = Buffer.concat(chunks).toString("utf-8").trim();
-  return raw ? safeObject(JSON.parse(raw)) : {};
+  if (!raw) {
+    return { payload: {}, parseError: null };
+  }
+
+  try {
+    return {
+      payload: safeObject(JSON.parse(raw)),
+      parseError: null,
+    };
+  } catch (error) {
+    return {
+      payload: {},
+      parseError: error instanceof Error ? error : new Error(String(error)),
+    };
+  }
 }
 
 export async function runCodexNativeHookCli(): Promise<void> {
-  const payload = await readStdinJson();
+  const { payload, parseError } = await readStdinJson();
+  if (parseError) {
+    process.stdout.write(`${JSON.stringify({
+      decision: "block",
+      reason: "OMX native hook received malformed JSON input. Preserve runtime state and inspect the emitting hook payload before retrying.",
+      hookSpecificOutput: {
+        hookEventName: "Unknown",
+        additionalContext:
+          `stdin JSON parsing failed inside codex-native-hook: ${parseError.message}. Emit valid JSON from the native hook caller before retrying.`,
+      },
+    })}\n`);
+    return;
+  }
+
   const result = await dispatchCodexNativeHook(payload);
   if (result.outputJson) {
     process.stdout.write(`${JSON.stringify(result.outputJson)}\n`);