oh-my-codex 0.12.3 → 0.12.4

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

@@ -2,12 +2,22 @@ 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 } from "../modes/base.js";
-import { getReadScopedStateDirs } from "../mcp/state-paths.js";
+import { readModeState, 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 { readTeamManifestV2, readTeamPhase } from "../team/state.js";
-import { omxNotepadPath, omxProjectMemoryPath } from "../utils/paths.js";
+import {
+  appendTeamEvent,
+  readTeamLeaderAttention,
+  readTeamManifestV2,
+  readTeamPhase,
+  writeTeamLeaderAttention,
+  writeTeamPhase,
+} from "../team/state.js";
+import { omxNotepadPath, omxProjectMemoryPath, omxStateDir } from "../utils/paths.js";
 import {
   detectPrimaryKeyword,
   recordSkillActivation,
@@ -15,14 +25,13 @@ import {
 } from "../hooks/keyword-detector.js";
 import {
   detectStallPattern,
-  isDeepInterviewInputLockActive,
-  isDeepInterviewStateActive,
   loadAutoNudgeConfig,
   normalizeAutoNudgeSignatureText,
 } from "./notify-hook/auto-nudge.js";
 import {
   buildNativePostToolUseOutput,
   buildNativePreToolUseOutput,
+  detectMcpTransportFailure,
 } from "./codex-native-pre-post.js";
 import {
   buildNativeHookEvent,
@@ -30,6 +39,7 @@ import {
 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";
 
 type CodexHookEventName =
   | "SessionStart"
@@ -154,19 +164,6 @@ async function readJsonIfExists(path: string): Promise<Record<string, unknown> |
   }
 }
 
-async function readScopedJsonState(
-  fileName: string,
-  cwd: string,
-  sessionId?: string,
-): Promise<Record<string, unknown> | null> {
-  const dirs = await getReadScopedStateDirs(cwd, sessionId);
-  for (const dir of dirs) {
-    const candidate = await readJsonIfExists(join(dir, fileName));
-    if (candidate) return candidate;
-  }
-  return null;
-}
-
 function isNonTerminalPhase(value: unknown): boolean {
   const phase = safeString(value).trim().toLowerCase();
   return phase !== "" && !TERMINAL_MODE_PHASES.has(phase);
@@ -178,26 +175,28 @@ function formatPhase(value: unknown, fallback = "active"): string {
 }
 
 async function readActiveRalphState(stateDir: string): Promise<Record<string, unknown> | null> {
+  const sessionInfo = await readJsonIfExists(join(stateDir, "session.json"));
+  const currentOmxSessionId = safeString(sessionInfo?.session_id).trim();
+  if (currentOmxSessionId) {
+    const sessionScoped = await readJsonIfExists(
+      join(stateDir, "sessions", currentOmxSessionId, "ralph-state.json"),
+    );
+    if (
+      sessionScoped?.active === true
+      && !TERMINAL_RALPH_PHASES.has(
+        safeString(sessionScoped.current_phase).trim().toLowerCase(),
+      )
+    ) {
+      return sessionScoped;
+    }
+  }
+
   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;
   }
 
-  const sessionInfo = await readJsonIfExists(join(stateDir, "session.json"));
-  const currentOmxSessionId = safeString(sessionInfo?.session_id).trim();
-  if (!currentOmxSessionId) return null;
-
-  const sessionScoped = await readJsonIfExists(
-    join(stateDir, "sessions", currentOmxSessionId, "ralph-state.json"),
-  );
-  if (
-    sessionScoped?.active === true
-    && !TERMINAL_RALPH_PHASES.has(
-      safeString(sessionScoped.current_phase).trim().toLowerCase(),
-    )
-  ) {
-    return sessionScoped;
-  }
+  if (currentOmxSessionId) return null;
 
   const sessionsRoot = join(stateDir, "sessions");
   if (!existsSync(sessionsRoot)) return null;
@@ -621,22 +620,100 @@ function readPayloadTurnId(payload: CodexHookPayload): string {
 
 async function isDeepInterviewSuppressedForStop(
   cwd: string,
-  stateDir: string,
   sessionId: string,
+  threadId: string,
 ): Promise<boolean> {
-  if (await isDeepInterviewStateActive(stateDir)) return true;
-  if (await isDeepInterviewInputLockActive(stateDir)) return true;
-
-  const scopedModeState = sessionId
-    ? await readScopedJsonState("deep-interview-state.json", cwd, sessionId)
-    : null;
+  const scopedModeState = await readStopSessionPinnedState("deep-interview-state.json", cwd, sessionId);
   if (scopedModeState?.active === true) return true;
 
-  const scopedSkillState = sessionId
-    ? await readScopedJsonState("skill-active-state.json", cwd, sessionId)
+  const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+  const deepInterviewEntry = canonicalState
+    ? listActiveSkills(canonicalState).find((entry) => (
+      entry.skill === "deep-interview"
+      && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)
+    ))
     : null;
-  if (!scopedSkillState || scopedSkillState.active !== true) return false;
-  return safeString(scopedSkillState.skill).trim() === "deep-interview";
+  if (
+    deepInterviewEntry
+    && safeObject(canonicalState?.input_lock).active === true
+  ) {
+    return true;
+  }
+
+  return (await readBlockingSkillForStop(cwd, sessionId, threadId, "deep-interview")) !== null;
+}
+
+async function readStopSessionPinnedState(
+  fileName: string,
+  cwd: string,
+  sessionId: string,
+): Promise<Record<string, unknown> | null> {
+  const stateDir = omxStateDir(cwd);
+  const statePath = sessionId
+    ? join(stateDir, "sessions", sessionId, fileName)
+    : join(stateDir, fileName);
+  return readJsonIfExists(statePath);
+}
+
+function matchesSkillStopContext(
+  entry: { session_id?: string; thread_id?: string },
+  state: { session_id?: string; thread_id?: string },
+  sessionId: string,
+  threadId: string,
+): boolean {
+  const entrySessionId = safeString(entry.session_id ?? state.session_id).trim();
+  const entryThreadId = safeString(entry.thread_id ?? state.thread_id).trim();
+  if (sessionId && entrySessionId && entrySessionId !== sessionId) return false;
+  if (sessionId && !entrySessionId && threadId && entryThreadId && entryThreadId !== threadId) {
+    return false;
+  }
+  return true;
+}
+
+async function readBlockingSkillForStop(
+  cwd: string,
+  sessionId: string,
+  threadId: string,
+  requiredSkill?: string,
+): Promise<{ skill: string; phase: string } | null> {
+  const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+  const visibleEntries = canonicalState ? listActiveSkills(canonicalState) : [];
+  const candidateSkills = requiredSkill
+    ? [requiredSkill]
+    : [...SKILL_STOP_BLOCKERS];
+
+  for (const skill of candidateSkills) {
+    const modeState = await readStopSessionPinnedState(`${skill}-state.json`, cwd, sessionId);
+    if (!modeState || modeState.active !== true) continue;
+
+    const phase = formatPhase(
+      modeState.current_phase,
+      formatPhase(
+        visibleEntries.find((entry) => entry.skill === skill)?.phase,
+        "planning",
+      ),
+    );
+    if (TERMINAL_MODE_PHASES.has(phase.toLowerCase()) || phase === "completing") {
+      continue;
+    }
+
+    if (!canonicalState) {
+      return { skill, phase };
+    }
+
+    const blocker = visibleEntries.find((entry) => (
+      entry.skill === skill
+      && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)
+    ));
+    if (!blocker) continue;
+
+    return {
+      skill,
+      phase: formatPhase(modeState.current_phase ?? blocker.phase ?? canonicalState.phase, "planning"),
+    };
+  }
+
+  return null;
 }
 
 function buildRepeatableStopSignature(
@@ -766,17 +843,8 @@ async function buildSkillStopOutput(
   sessionId: string,
   threadId: string,
 ): Promise<Record<string, unknown> | null> {
-  const state = await readScopedJsonState("skill-active-state.json", cwd, sessionId);
-  if (!state || state.active !== true) return null;
-  const stateSessionId = safeString(state.session_id).trim();
-  const stateThreadId = safeString(state.thread_id).trim();
-  if (sessionId && stateSessionId && stateSessionId !== sessionId) return null;
-  if (sessionId && !stateSessionId && threadId && stateThreadId && stateThreadId !== threadId) {
-    return null;
-  }
-  const skill = safeString(state.skill).trim();
-  const phase = formatPhase(state.phase, "planning");
-  if (!SKILL_STOP_BLOCKERS.has(skill) || phase === "completing") return null;
+  const blocker = await readBlockingSkillForStop(cwd, sessionId, threadId);
+  if (!blocker) return null;
 
   const subagentSummary = await readSubagentSessionSummary(cwd, sessionId).catch(() => null);
   if (subagentSummary && subagentSummary.activeSubagentThreadIds.length > 0) {
@@ -785,12 +853,116 @@ async function buildSkillStopOutput(
 
   return {
     decision: "block",
-    reason: `OMX skill ${skill} is still active (phase: ${phase}); continue until the current ${skill} workflow reaches a terminal state.`,
-    stopReason: `skill_${skill}_${phase}`,
-    systemMessage: `OMX skill ${skill} is still active (phase: ${phase}).`,
+    reason: `OMX skill ${blocker.skill} is still active (phase: ${blocker.phase}); continue until the current ${blocker.skill} workflow reaches a terminal state.`,
+    stopReason: `skill_${blocker.skill}_${blocker.phase}`,
+    systemMessage: `OMX skill ${blocker.skill} is still active (phase: ${blocker.phase}).`,
   };
 }
 
+async function findActiveTeamForTransportFailure(
+  cwd: string,
+  sessionId: string,
+): Promise<{ teamName: string; phase: string } | null> {
+  const teamState = await readModeState("team", cwd);
+  if (teamState?.active === true) {
+    const teamName = safeString(teamState.team_name).trim();
+    const coarsePhase = formatPhase(teamState.current_phase);
+    if (teamName) {
+      const canonicalPhase = (await readTeamPhase(teamName, cwd))?.current_phase ?? coarsePhase;
+      if (isNonTerminalPhase(canonicalPhase)) {
+        return { teamName, phase: formatPhase(canonicalPhase) };
+      }
+    }
+  }
+
+  return await findCanonicalActiveTeamForSession(cwd, sessionId);
+}
+
+async function markTeamTransportFailure(
+  cwd: string,
+  payload: CodexHookPayload,
+): Promise<void> {
+  const sessionId = readPayloadSessionId(payload);
+  const activeTeam = await findActiveTeamForTransportFailure(cwd, sessionId);
+  if (!activeTeam) return;
+
+  const nowIso = new Date().toISOString();
+  const existingPhase = await readTeamPhase(activeTeam.teamName, cwd);
+  const currentPhase = existingPhase?.current_phase ?? activeTeam.phase;
+  if (!isNonTerminalPhase(currentPhase)) return;
+
+  await writeTeamPhase(
+    activeTeam.teamName,
+    {
+      current_phase: "failed",
+      max_fix_attempts: existingPhase?.max_fix_attempts ?? 3,
+      current_fix_attempt: existingPhase?.current_fix_attempt ?? 0,
+      transitions: [
+        ...(existingPhase?.transitions ?? []),
+        {
+          from: formatPhase(currentPhase),
+          to: "failed",
+          at: nowIso,
+          reason: "mcp_transport_dead",
+        },
+      ],
+      updated_at: nowIso,
+    },
+    cwd,
+  );
+
+  const existingAttention = await readTeamLeaderAttention(activeTeam.teamName, cwd);
+  await writeTeamLeaderAttention(
+    activeTeam.teamName,
+    {
+      team_name: activeTeam.teamName,
+      updated_at: nowIso,
+      source: "notify_hook",
+      leader_decision_state: existingAttention?.leader_decision_state ?? "still_actionable",
+      leader_attention_pending: true,
+      leader_attention_reason: "mcp_transport_dead",
+      attention_reasons: [
+        ...new Set([...(existingAttention?.attention_reasons ?? []), "mcp_transport_dead"]),
+      ],
+      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_stopped_at: existingAttention?.leader_session_stopped_at ?? null,
+      unread_leader_message_count: existingAttention?.unread_leader_message_count ?? 0,
+      work_remaining: existingAttention?.work_remaining ?? true,
+      stalled_for_ms: existingAttention?.stalled_for_ms ?? null,
+    },
+    cwd,
+  );
+
+  await appendTeamEvent(
+    activeTeam.teamName,
+    {
+      type: "leader_attention",
+      worker: "leader-fixed",
+      reason: "mcp_transport_dead",
+      metadata: {
+        phase_before: formatPhase(currentPhase),
+      },
+    },
+    cwd,
+  ).catch(() => {});
+
+  try {
+    await updateModeState(
+      "team",
+      {
+        current_phase: "failed",
+        error: "mcp_transport_dead",
+        last_turn_at: nowIso,
+      },
+      cwd,
+    );
+  } catch {
+    // Canonical team state already carries the preserved failure for coarse-state-missing sessions.
+  }
+}
+
 async function buildStopHookOutput(
   payload: CodexHookPayload,
   cwd: string,
@@ -844,7 +1016,7 @@ async function buildStopHookOutput(
       if (!stopHookActive && skillOutput) return skillOutput;
     }
 
-    const deepInterviewActive = await isDeepInterviewSuppressedForStop(cwd, stateDir, sessionId);
+    const deepInterviewActive = await isDeepInterviewSuppressedForStop(cwd, sessionId, threadId);
     const lastAssistantMessage = safeString(
       payload.last_assistant_message ?? payload.lastAssistantMessage,
     );
@@ -922,6 +1094,7 @@ export async function dispatchCodexNativeHook(
         turnId,
       });
     }
+    await reconcileHudForPromptSubmit(cwd).catch(() => {});
   }
 
   if (omxEventName) {
@@ -954,6 +1127,9 @@ export async function dispatchCodexNativeHook(
   } else if (hookEventName === "PreToolUse") {
     outputJson = buildNativePreToolUseOutput(payload);
   } else if (hookEventName === "PostToolUse") {
+    if (detectMcpTransportFailure(payload)) {
+      await markTeamTransportFailure(cwd, payload);
+    }
     outputJson = buildNativePostToolUseOutput(payload);
   } else if (hookEventName === "Stop") {
     outputJson = await buildStopHookOutput(payload, cwd, stateDir);

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

@@ -21,6 +21,11 @@ export interface NormalizedPostToolUsePayload {
   stderrText: string;
 }
 
+export interface McpTransportFailureSignal {
+  toolName: string;
+  summary: string;
+}
+
 function safeString(value: unknown): string {
   return typeof value === "string" ? value : "";
 }
@@ -101,6 +106,88 @@ function matchesDestructiveFixture(command: string): boolean {
   return /^\s*rm\s+-rf\s+dist(?:\s|$)/.test(command);
 }
 
+function isMcpLikeToolName(toolName: string): boolean {
+  return /^(mcp__|omx_(?:state|memory|trace|code_intel)\b|state_|project_memory_|notepad_|trace_)/i.test(toolName);
+}
+
+const MCP_TRANSPORT_FAILURE_PATTERNS = [
+  /transport (?:closed|error|failed)/i,
+  /server disconnected/i,
+  /connection (?:closed|reset|lost)/i,
+  /\beconnreset\b/i,
+  /\bepipe\b/i,
+  /broken pipe/i,
+  /stream ended unexpectedly/i,
+  /stdio .*closed/i,
+  /pipe closed/i,
+  /mcp(?: server)? .*closed/i,
+];
+
+type OmxParityCommand =
+  | "state"
+  | "notepad"
+  | "project-memory"
+  | "trace"
+  | "code-intel";
+
+export function detectMcpTransportFailure(
+  payload: CodexHookPayload,
+): McpTransportFailureSignal | null {
+  const normalized = normalizePostToolUsePayload(payload);
+  const combined = [
+    normalized.stderrText,
+    normalized.stdoutText,
+    safeString(normalized.parsedToolResponse?.error),
+    safeString(normalized.parsedToolResponse?.message),
+    safeString(normalized.parsedToolResponse?.details),
+  ]
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+
+  const mcpContextDetected = isMcpLikeToolName(normalized.toolName)
+    || /\bmcp\b/i.test(combined)
+    || /\bomx-(?:state|memory|trace|code-intel)-server\b/i.test(combined);
+  if (!mcpContextDetected) return null;
+  if (!combined) return null;
+  if (!MCP_TRANSPORT_FAILURE_PATTERNS.some((pattern) => pattern.test(combined))) {
+    return null;
+  }
+
+  return {
+    toolName: normalized.toolName,
+    summary: combined,
+  };
+}
+
+function resolveOmxParityTarget(toolName: string): { command: OmxParityCommand; tool: string } | null {
+  const match = toolName.match(/^mcp__omx_(state|memory|trace|code_intel)__([a-z0-9_]+)$/i);
+  if (!match) return null;
+
+  const [, server, tool] = match;
+  if (server === "state") return { command: "state", tool };
+  if (server === "trace") return { command: "trace", tool };
+  if (server === "code_intel") return { command: "code-intel", tool };
+  if (server === "memory" && tool.startsWith("notepad_")) {
+    return { command: "notepad", tool };
+  }
+  if (server === "memory" && tool.startsWith("project_memory_")) {
+    return { command: "project-memory", tool };
+  }
+  return null;
+}
+
+function shellSingleQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+
+function buildOmxParityFallbackCommand(payload: CodexHookPayload, toolName: string): string | null {
+  const target = resolveOmxParityTarget(toolName);
+  if (!target) return null;
+  const input = safeObject(payload.tool_input) ?? {};
+  return `omx ${target.command} ${target.tool} --input ${shellSingleQuote(JSON.stringify(input))} --json`;
+}
+
 export function buildNativePreToolUseOutput(
   payload: CodexHookPayload,
 ): Record<string, unknown> | null {
@@ -124,6 +211,23 @@ function containsHardFailure(text: string): boolean {
 export function buildNativePostToolUseOutput(
   payload: CodexHookPayload,
 ): Record<string, unknown> | null {
+  const mcpTransportFailure = detectMcpTransportFailure(payload);
+  if (mcpTransportFailure) {
+    const fallbackCommand = buildOmxParityFallbackCommand(payload, mcpTransportFailure.toolName);
+    const fallbackText = fallbackCommand
+      ? `Retry via CLI parity with \`${fallbackCommand}\`.`
+      : "Retry via the matching OMX CLI parity surface instead of retrying the MCP transport blindly.";
+    return {
+      decision: "block",
+      reason: "The MCP tool appears to have lost its transport/server connection. Preserve state, debug the transport failure, and use OMX CLI/file-backed fallbacks instead of retrying blindly.",
+      hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext:
+          `Clear MCP transport-death signal detected. Preserve current team/runtime state. ${fallbackText} OMX MCP servers are plain Node stdio processes, so they still shut down when stdin/transport closes. If this happened during team runtime, inspect first with \`omx team status <team>\` or \`omx team api read-stall-state --input '{"team_name":"<team>"}' --json\`, and only force cleanup after capturing needed state. For root-cause debugging, rerun with \`OMX_MCP_TRANSPORT_DEBUG=1\` to log why the stdio transport closed.`,
+      },
+    };
+  }
+
   const normalized = normalizePostToolUsePayload(payload);
   if (!normalized.isBash) return null;
 

package/src/scripts/notify-hook/operational-events.ts

@@ -70,8 +70,12 @@ function buildTmuxSessionName(cwd: any, sessionId: any): string {
   const branch = gitValue(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
   const branchToken = branch ? sanitizeTmuxToken(branch) : 'detached';
   const sessionToken = sanitizeTmuxToken(safeString(sessionId).replace(/^omx-/, ''));
-  const name = `omx-${dirToken}-${branchToken}-${sessionToken}`;
-  return name.length > 120 ? name.slice(0, 120) : name;
+  const prefix = `omx-${dirToken}-${branchToken}`;
+  const name = `${prefix}-${sessionToken}`;
+  if (name.length <= 120) return name;
+  const prefixBudget = Math.max(4, 120 - sessionToken.length - 1);
+  const trimmedPrefix = prefix.slice(0, prefixBudget).replace(/-+$/g, '');
+  return `${trimmedPrefix}-${sessionToken}`.slice(0, 120);
 }
 
 export function resolveOperationalSessionName(cwd: any, sessionId = '', sessionName = ''): string | undefined {