oh-my-codex 0.12.4 → 0.12.6

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

@@ -2,24 +2,33 @@ 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, readTeamManifestV2, readTeamPhase, writeTeamLeaderAttention, writeTeamPhase, } from "../team/state.js";
-import { omxNotepadPath, omxProjectMemoryPath, omxStateDir } from "../utils/paths.js";
-import { detectPrimaryKeyword, recordSkillActivation, } from "../hooks/keyword-detector.js";
-import { detectStallPattern, loadAutoNudgeConfig, normalizeAutoNudgeSignatureText, } from "./notify-hook/auto-nudge.js";
+import { omxNotepadPath, omxProjectMemoryPath } from "../utils/paths.js";
+import { getStateFilePath } from "../mcp/state-paths.js";
+import { detectKeywords, detectPrimaryKeyword, recordSkillActivation, } from "../hooks/keyword-detector.js";
+import { detectStallPattern, loadAutoNudgeConfig, normalizeAutoNudgeSignatureText, resolveEffectiveAutoNudgeResponse, } from "./notify-hook/auto-nudge.js";
 import { buildNativePostToolUseOutput, buildNativePreToolUseOutput, detectMcpTransportFailure, } from "./codex-native-pre-post.js";
 import { buildNativeHookEvent, } from "../hooks/extensibility/events.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";
 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,
+];
+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) {
     return typeof value === "string" ? value : "";
 }
@@ -81,16 +90,24 @@ function readPromptText(payload) {
     }
     return "";
 }
+function sanitizePayloadForHookContext(payload, hookEventName) {
+    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, payload, hookEventName) {
     return {
         cwd,
         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),
     };
 }
 async function readJsonIfExists(path) {
@@ -111,22 +128,26 @@ function formatPhase(value, fallback = "active") {
     const phase = safeString(value).trim();
     return phase || fallback;
 }
-async function readActiveRalphState(stateDir) {
-    const sessionInfo = await readJsonIfExists(join(stateDir, "session.json"));
+async function readActiveRalphState(stateDir, preferredSessionId) {
+    const sessionInfo = await readUsableSessionState(resolve(stateDir, "..", ".."));
     const currentOmxSessionId = safeString(sessionInfo?.session_id).trim();
-    if (currentOmxSessionId) {
-        const sessionScoped = await readJsonIfExists(join(stateDir, "sessions", currentOmxSessionId, "ralph-state.json"));
+    const sessionCandidates = [...new Set([
+            safeString(preferredSessionId).trim(),
+            currentOmxSessionId,
+        ].filter(Boolean))];
+    for (const sessionId of sessionCandidates) {
+        const sessionScoped = await readJsonIfExists(join(stateDir, "sessions", sessionId, "ralph-state.json"));
         if (sessionScoped?.active === true
             && !TERMINAL_RALPH_PHASES.has(safeString(sessionScoped.current_phase).trim().toLowerCase())) {
             return sessionScoped;
         }
     }
+    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;
@@ -328,6 +349,10 @@ async function buildSessionStartContext(cwd, sessionId) {
             // best effort only
         }
     }
+    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}`);
@@ -337,29 +362,83 @@ async function buildSessionStartContext(cwd, sessionId) {
 function buildAdditionalContextMessage(prompt, skillState) {
     if (!prompt)
         return null;
+    const matches = detectKeywords(prompt);
     const match = detectPrimaryKeyword(prompt);
     if (!match)
         return null;
-    if (match.skill === "team") {
+    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 (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) {
     const match = /^([a-z0-9][a-z0-9-]{0,29})\/(worker-\d+)$/.exec(rawValue.trim());
@@ -455,8 +534,10 @@ function isStopExempt(payload) {
         || value.includes("compact")
         || value.includes("limit"));
 }
-async function buildModeBasedStopOutput(mode, cwd) {
-    const state = await readModeState(mode, cwd);
+async function buildModeBasedStopOutput(mode, cwd, sessionId) {
+    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);
@@ -467,11 +548,34 @@ async function buildModeBasedStopOutput(mode, cwd) {
         systemMessage: `OMX ${mode} is still active (phase: ${phase}).`,
     };
 }
-async function buildTeamStopOutput(cwd) {
-    const teamState = await readModeState("team", cwd);
+async function readTeamModeStateForStop(cwd, sessionId) {
+    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, sessionId) {
+    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))
@@ -490,6 +594,43 @@ function buildTeamStopOutputForPhase(teamName, phase) {
         systemMessage: `OMX team pipeline is still active at phase ${phase}.`,
     };
 }
+function extractStableFinalRecommendationSummary(message) {
+    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, teamName, summary) {
+    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) {
+    const mode = safeString(payload.mode).trim().toLowerCase();
+    return mode === "release-readiness";
+}
+async function hasReleaseReadinessStopMarker(cwd, sessionId, teamName) {
+    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) {
     return safeString(payload.session_id ?? payload.sessionId).trim();
 }
@@ -499,26 +640,22 @@ function readPayloadThreadId(payload) {
 function readPayloadTurnId(payload) {
     return safeString(payload.turn_id ?? payload.turnId).trim();
 }
-async function isDeepInterviewSuppressedForStop(cwd, sessionId, threadId) {
-    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;
+async function resolveInternalSessionIdForPayload(cwd, payloadSessionId) {
+    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(fileName, cwd, sessionId) {
-    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);
 }
 function matchesSkillStopContext(entry, state, sessionId, threadId) {
@@ -559,6 +696,21 @@ async function readBlockingSkillForStop(cwd, sessionId, threadId, requiredSkill)
     }
     return null;
 }
+async function readStopAutoNudgePhase(cwd, sessionId, threadId) {
+    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, kind, detail = "") {
     const sessionId = readPayloadSessionId(payload) || "no-session";
     const threadId = readPayloadThreadId(payload) || "no-thread";
@@ -586,9 +738,6 @@ function buildRepeatableStopSignature(payload, kind, detail = "") {
         normalizedDetail || "no-detail",
     ].join("|");
 }
-async function readNativeStopState(stateDir) {
-    return await readJsonIfExists(join(stateDir, NATIVE_STOP_STATE_FILE)) ?? {};
-}
 function readNativeStopSessionKey(payload) {
     return readPayloadSessionId(payload) || readPayloadThreadId(payload) || "global";
 }
@@ -600,7 +749,8 @@ function readPreviousNativeStopSignature(state, sessionKey) {
 async function persistNativeStopSignature(stateDir, payload, signature) {
     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] = {
@@ -608,7 +758,8 @@ async function persistNativeStopSignature(stateDir, payload, signature) {
         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));
@@ -618,7 +769,7 @@ async function maybeReturnRepeatableStopOutput(payload, stateDir, signature, out
         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;
@@ -658,6 +809,43 @@ async function findCanonicalActiveTeamForSession(cwd, sessionId) {
     }
     return null;
 }
+async function resolveActiveTeamNameForStop(cwd, sessionId) {
+    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, cwd, stateDir, sessionId) {
+    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, sessionId, threadId) {
     const blocker = await readBlockingSkillForStop(cwd, sessionId, threadId);
     if (!blocker)
@@ -674,7 +862,7 @@ async function buildSkillStopOutput(cwd, sessionId, threadId) {
     };
 }
 async function findActiveTeamForTransportFailure(cwd, sessionId) {
-    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);
@@ -688,8 +876,8 @@ async function findActiveTeamForTransportFailure(cwd, sessionId) {
     return await findCanonicalActiveTeamForSession(cwd, sessionId);
 }
 async function markTeamTransportFailure(cwd, payload) {
-    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();
@@ -725,7 +913,7 @@ async function markTeamTransportFailure(cwd, payload) {
         ],
         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,
@@ -744,7 +932,7 @@ async function markTeamTransportFailure(cwd, payload) {
             current_phase: "failed",
             error: "mcp_transport_dead",
             last_turn_at: nowIso,
-        }, cwd);
+        }, cwd, canonicalSessionId || undefined);
     }
     catch {
         // Canonical team state already carries the preserved failure for coarse-state-missing sessions.
@@ -755,29 +943,33 @@ async function buildStopHookOutput(payload, cwd, stateDir) {
         return null;
     }
     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, canonicalTeam.phase);
                 const canonicalTeamSignature = buildRepeatableStopSignature(payload, "team-stop", `${canonicalTeam.teamName}|${canonicalTeam.phase}`);
@@ -785,19 +977,19 @@ async function buildStopHookOutput(payload, cwd, stateDir) {
                 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();
-        if (!deepInterviewActive
-            && autoNudgeConfig.enabled
-            && detectStallPattern(lastAssistantMessage, autoNudgeConfig.patterns)) {
+        const autoNudgePhase = await readStopAutoNudgePhase(cwd, canonicalSessionId, threadId);
+        if (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.",
             });
@@ -824,21 +1016,28 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
     await mkdir(stateDir, { recursive: true });
     const omxEventName = mapCodexHookEventToOmxEvent(hookEventName);
     let skillState = 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();
-    if (hookEventName === "SessionStart" && sessionId) {
-        await writeSessionStart(cwd, sessionId, {
+    let canonicalSessionId = safeString((await readUsableSessionState(cwd))?.session_id).trim();
+    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,
             });
@@ -846,8 +1045,16 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
         await reconcileHudForPromptSubmit(cwd).catch(() => { });
     }
     if (omxEventName) {
-        const event = buildNativeHookEvent(omxEventName, buildBaseContext(cwd, payload, hookEventName), {
-            session_id: sessionId || undefined,
+        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 = buildNativeHookEvent(omxEventName, baseContext, {
+            session_id: eventSessionId,
             thread_id: threadId || undefined,
             turn_id: turnId || undefined,
             mode: safeString(payload.mode).trim() || undefined,
@@ -857,7 +1064,7 @@ export async function dispatchCodexNativeHook(payload, options = {}) {
     let outputJson = 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 = {
@@ -893,10 +1100,35 @@ async function readStdinJson() {
         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() {
-    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`);