oh-my-codex 0.16.2 → 0.16.3

package/src/scripts/notify-hook/ralph-session-resume.ts

@@ -2,12 +2,13 @@ import { existsSync } from 'fs';
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
 import { dirname, join, resolve } from 'path';
 import { captureTmuxPaneFromEnv } from '../../state/mode-state-context.js';
-import { readUsableSessionState } from '../../hooks/session.js';
+import { isSessionStateUsable } from '../../hooks/session.js';
 import { resolveCodexPane } from '../tmux-hook-engine.js';
 import { safeString } from './utils.js';
 
 const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
-const RALPH_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled']);
+const RALPH_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled', 'interrupted']);
+const DEFAULT_RALPH_ACTIVE_STATE_STALE_MS = 24 * 60 * 60 * 1000;
 const RALPH_RESUME_LOCK_STALE_MS = 10_000;
 const RALPH_RESUME_LOCK_TIMEOUT_MS = 5_000;
 const RALPH_RESUME_LOCK_RETRY_MS = 25;
@@ -40,6 +41,14 @@ interface RalphStateCandidate {
   state: Record<string, unknown>;
 }
 
+interface RalphStateFreshness {
+  stale: boolean;
+  ageMs: number;
+  checkedAtMs: number;
+  staleThresholdMs: number;
+  timestampSource: string;
+}
+
 function lockOwnerToken(): string {
   return `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
 }
@@ -128,6 +137,80 @@ function isActiveRalphCandidate(state: Record<string, unknown> | null): state is
   return state.active === true && !isTerminalRalphPhase(state.current_phase);
 }
 
+function parsePositiveInteger(value: unknown): number | null {
+  const parsed = Number.parseInt(safeString(value).trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function resolveActiveStateStaleThresholdMs(env: NodeJS.ProcessEnv = process.env): number {
+  return parsePositiveInteger(env.OMX_RALPH_ACTIVE_STATE_STALE_MS)
+    ?? parsePositiveInteger(env.OMX_RALPH_RESUME_STALE_MS)
+    ?? DEFAULT_RALPH_ACTIVE_STATE_STALE_MS;
+}
+
+function parseTimestampMs(value: unknown): number | null {
+  const raw = safeString(value).trim();
+  if (!raw) return null;
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function stateActivityTimestampMs(state: Record<string, unknown>): { ms: number; source: string } | null {
+  let newest: { ms: number; source: string } | null = null;
+  for (const key of ['updated_at', 'last_turn_at', 'tmux_pane_set_at']) {
+    const ms = parseTimestampMs(state[key]);
+    if (ms !== null && (!newest || ms > newest.ms)) {
+      newest = { ms, source: key };
+    }
+  }
+  return newest;
+}
+
+async function readRalphStateFreshness(
+  path: string,
+  state: Record<string, unknown>,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<RalphStateFreshness> {
+  const checkedAtMs = Date.now();
+  const threshold = resolveActiveStateStaleThresholdMs(env);
+  let timestamp = stateActivityTimestampMs(state);
+  if (!timestamp) {
+    try {
+      const info = await stat(path);
+      timestamp = { ms: info.mtimeMs, source: 'mtime' };
+    } catch {
+      timestamp = { ms: checkedAtMs, source: 'missing_mtime' };
+    }
+  }
+  const ageMs = Math.max(0, checkedAtMs - timestamp.ms);
+  return {
+    stale: ageMs > threshold,
+    ageMs,
+    checkedAtMs,
+    staleThresholdMs: threshold,
+    timestampSource: timestamp.source,
+  };
+}
+
+async function markRalphStateAbandoned(
+  path: string,
+  state: Record<string, unknown>,
+  freshness: RalphStateFreshness,
+): Promise<void> {
+  const nowIso = new Date(freshness.checkedAtMs).toISOString();
+  await writeJsonAtomic(path, {
+    ...state,
+    active: false,
+    current_phase: 'cancelled',
+    completed_at: nowIso,
+    abandoned_at: nowIso,
+    stop_reason: 'stale_active_state',
+    stale_resume_age_ms: freshness.ageMs,
+    stale_resume_threshold_ms: freshness.staleThresholdMs,
+    stale_resume_timestamp_source: freshness.timestampSource,
+  });
+}
+
 function readSessionIdFromEnvironment(env: NodeJS.ProcessEnv = process.env): string {
   const candidates = [env.OMX_SESSION_ID, env.CODEX_SESSION_ID, env.SESSION_ID];
   for (const candidate of candidates) {
@@ -144,7 +227,10 @@ async function readCurrentOmxSessionId(stateDir: string, env: NodeJS.ProcessEnv
     if (existsSync(envScopedDir)) return envSessionId;
   }
 
-  const session = await readUsableSessionState(resolve(stateDir, '..', '..'));
+  const cwd = resolve(stateDir, '..', '..');
+  const session = await readJson(join(stateDir, 'session.json'));
+  if (!session || typeof session !== 'object') return '';
+  if (!isSessionStateUsable(session as any, cwd)) return '';
   const sessionId = safeString(session?.session_id).trim();
   return SESSION_ID_PATTERN.test(sessionId) ? sessionId : '';
 }
@@ -171,12 +257,14 @@ async function scanMatchingRalphCandidates(
   currentOmxSessionId: string,
   payloadSessionId: string,
   payloadThreadId: string,
-): Promise<RalphStateCandidate[]> {
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<{ candidates: RalphStateCandidate[]; abandonedCount: number }> {
   const sessionsRoot = join(stateDir, 'sessions');
-  if (!existsSync(sessionsRoot)) return [];
+  if (!existsSync(sessionsRoot)) return { candidates: [], abandonedCount: 0 };
 
   const entries = await readdir(sessionsRoot, { withFileTypes: true }).catch(() => []);
   const matches: RalphStateCandidate[] = [];
+  let abandonedCount = 0;
   for (const entry of entries) {
     if (!entry.isDirectory() || !SESSION_ID_PATTERN.test(entry.name) || entry.name === currentOmxSessionId) continue;
     const path = join(sessionsRoot, entry.name, 'ralph-state.json');
@@ -190,13 +278,19 @@ async function scanMatchingRalphCandidates(
     } else if (!payloadThreadId || !ownerThreadId || ownerThreadId !== payloadThreadId) {
       continue;
     }
+    const freshness = await readRalphStateFreshness(path, state, env);
+    if (freshness.stale) {
+      await markRalphStateAbandoned(path, state, freshness);
+      abandonedCount += 1;
+      continue;
+    }
     matches.push({
       sessionId: entry.name,
       path,
       state,
     });
   }
-  return matches;
+  return { candidates: matches, abandonedCount };
 }
 
 export async function reconcileRalphSessionResume({
@@ -228,6 +322,18 @@ export async function reconcileRalphSessionResume({
     const nowIso = new Date().toISOString();
 
     if (currentRalphState && currentRalphState.active === true) {
+      const freshness = await readRalphStateFreshness(currentRalphPath, currentRalphState, env);
+      if (freshness.stale) {
+        await markRalphStateAbandoned(currentRalphPath, currentRalphState, freshness);
+        return {
+          currentOmxSessionId,
+          resumed: false,
+          updatedCurrentOwner: false,
+          reason: 'current_ralph_abandoned_stale',
+          targetPath: currentRalphPath,
+        };
+      }
+
       let changed = false;
       const updated: Record<string, unknown> = { ...currentRalphState };
       const normalizedPayloadThreadId = safeString(payloadThreadId).trim();
@@ -293,18 +399,21 @@ export async function reconcileRalphSessionResume({
       };
     }
 
-    const candidates = await scanMatchingRalphCandidates(
+    const { candidates, abandonedCount } = await scanMatchingRalphCandidates(
       stateDir,
       currentOmxSessionId,
       normalizedPayloadSessionId,
       normalizedPayloadThreadId,
+      env,
     );
     if (candidates.length !== 1) {
       return {
         currentOmxSessionId,
         resumed: false,
         updatedCurrentOwner: false,
-        reason: candidates.length === 0 ? 'no_matching_prior_ralph' : 'multiple_matching_prior_ralphs',
+        reason: candidates.length === 0
+          ? (abandonedCount > 0 ? 'matching_prior_ralph_abandoned_stale' : 'no_matching_prior_ralph')
+          : 'multiple_matching_prior_ralphs',
       };
     }
 

package/src/scripts/notify-hook/state-io.ts

@@ -5,7 +5,7 @@
 import { mkdir, readFile, readdir, writeFile } from 'fs/promises';
 import { dirname, join, resolve } from 'path';
 import { existsSync } from 'fs';
-import { readUsableSessionState } from '../../hooks/session.js';
+import { isSessionStateUsable } from '../../hooks/session.js';
 import { asNumber, safeString } from './utils.js';
 
 const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
@@ -43,7 +43,9 @@ export async function readCurrentSessionId(baseStateDir: string): Promise<string
   }
 
   const cwd = resolve(baseStateDir, '..', '..');
-  const session = await readUsableSessionState(cwd);
+  const session = await readJsonIfExists(join(baseStateDir, 'session.json'), null);
+  if (!session || typeof session !== 'object') return undefined;
+  if (!isSessionStateUsable(session, cwd)) return undefined;
   const sessionId = safeString(session?.session_id);
   return SESSION_ID_PATTERN.test(sessionId) ? sessionId : undefined;
 }

package/src/scripts/notify-hook/visual-verdict.ts

@@ -38,7 +38,7 @@ function extractJsonCandidates(rawMessage: any): string[] {
   return candidates;
 }
 
-async function maybePersistRuntimeVisualFeedback({ cwd, output, sessionId }: any): Promise<void> {
+async function maybePersistRuntimeVisualFeedback({ cwd, output, sessionId, stateDir }: any): Promise<void> {
   if (!cwd || !output) return;
 
   const candidates = extractJsonCandidates(output);
@@ -51,7 +51,7 @@ async function maybePersistRuntimeVisualFeedback({ cwd, output, sessionId }: any
     try {
       const parsed = JSON.parse(candidate);
       const feedback = buildVisualLoopFeedback(parsed);
-      await recordRalphVisualFeedback(cwd, feedback, sessionId || undefined);
+      await recordRalphVisualFeedback(cwd, feedback, sessionId || undefined, stateDir || undefined);
       return;
     } catch {
       // Try next candidate
@@ -93,7 +93,7 @@ export async function maybePersistVisualVerdict({ cwd, payload, stateDir, logsDi
   // Runtime visual feedback (JSON/fenced JSON) for ralph-progress persistence.
   // Non-fatal and observable via warn-level structured logging.
   try {
-    await maybePersistRuntimeVisualFeedback({ cwd, output, sessionId });
+    await maybePersistRuntimeVisualFeedback({ cwd, output, sessionId, stateDir });
   } catch (err: any) {
     await logNotifyHookEvent(logsDir, {
       timestamp: new Date().toISOString(),

package/src/scripts/notify-hook.ts

@@ -21,6 +21,7 @@
 import { writeFile, appendFile, mkdir, readFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { dirname, join, resolve } from 'path';
+import { isSessionStateUsable } from '../hooks/session.js';
 
 import { safeString, asNumber } from './notify-hook/utils.js';
 import {
@@ -65,6 +66,7 @@ import {
   maybeNotifyLeaderWorkerIdle,
 } from './notify-hook/team-worker.js';
 import { DEFAULT_MARKER } from './tmux-hook-engine.js';
+import { sameFilePath } from '../utils/paths.js';
 
 const RALPH_ACTIVE_PROGRESS_PHASES = new Set([
   'start',
@@ -82,6 +84,117 @@ const RALPH_ACTIVE_PROGRESS_PHASES = new Set([
 
 const IDLE_NOTIFICATION_SUMMARY_MAX_LENGTH = 240;
 
+async function readJsonFileIfObject(path: string): Promise<Record<string, unknown> | null> {
+  try {
+    const raw = await readFile(path, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function hasOmxRuntimeStateMarker(value: Record<string, unknown> | null): boolean {
+  if (!value) return false;
+  return typeof value.active === 'boolean'
+    || typeof value.team_name === 'string'
+    || typeof value.current_phase === 'string'
+    || typeof value.lifecycle_outcome === 'string'
+    || typeof value.run_outcome === 'string';
+}
+
+async function hasManagedTeamStateTree(cwd: string): Promise<boolean> {
+  const teamStateRoot = join(cwd, '.omx', 'state', 'team');
+  if (!existsSync(teamStateRoot)) return false;
+  let entries: string[] = [];
+  try {
+    entries = await readdir(teamStateRoot);
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry.startsWith('.')) continue;
+    const teamDir = join(teamStateRoot, entry);
+    if (existsSync(join(teamDir, 'manifest.v2.json')) || existsSync(join(teamDir, 'config.json'))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+async function isOmxManagedCwd(cwd: string): Promise<boolean> {
+  const trustedInternalCwd = safeString(process.env.OMX_NOTIFY_HOOK_TRUSTED_MANAGED_CWD || '').trim();
+  if (trustedInternalCwd && sameFilePath(trustedInternalCwd, cwd)) return true;
+  if (existsSync(join(cwd, '.omx', 'setup-scope.json'))) return true;
+  if (existsSync(join(cwd, '.omx', 'managed'))) return true;
+  const sessionStatePath = join(cwd, '.omx', 'state', 'session.json');
+  if (existsSync(sessionStatePath)) {
+    try {
+      const sessionState = JSON.parse(await readFile(sessionStatePath, 'utf-8'));
+      if (isSessionStateUsable(sessionState, cwd)) return true;
+    } catch {
+      // Continue checking other managed markers.
+    }
+  }
+  const teamState = await readJsonFileIfObject(join(cwd, '.omx', 'state', 'team-state.json'));
+  if (hasOmxRuntimeStateMarker(teamState)) return true;
+  const hudState = await readJsonFileIfObject(join(cwd, '.omx', 'state', 'hud-state.json'));
+  if (hudState && (typeof hudState.last_turn_at === 'string' || typeof hudState.turn_count === 'number')) return true;
+  if (await hasManagedTeamStateTree(cwd)) return true;
+  const teamWorkerEnv = safeString(process.env.OMX_TEAM_INTERNAL_WORKER || process.env.OMX_TEAM_WORKER || '').trim();
+  if (teamWorkerEnv) {
+    const [teamName = '', workerName = ''] = teamWorkerEnv.split('/');
+    if (teamName && workerName) {
+      const candidateStateRoots = [
+        safeString(process.env.OMX_TEAM_STATE_ROOT || '').trim(),
+        safeString(process.env.OMX_TEAM_LEADER_CWD || '').trim()
+          ? join(resolve(cwd, safeString(process.env.OMX_TEAM_LEADER_CWD || '').trim()), '.omx', 'state')
+          : '',
+        join(cwd, '.omx', 'state'),
+      ].filter((value, index, values) => value && values.indexOf(value) === index);
+      for (const candidateStateRoot of candidateStateRoots) {
+        const identityPath = join(candidateStateRoot, 'team', teamName, 'workers', workerName, 'identity.json');
+        if (!existsSync(identityPath)) continue;
+        try {
+          const raw = await readFile(identityPath, 'utf-8');
+          const identity = JSON.parse(raw);
+          const worktreePath = safeString(identity?.worktree_path || '').trim();
+          const stateRoot = safeString(identity?.team_state_root || '').trim();
+          if (
+            (!worktreePath || sameFilePath(worktreePath, cwd))
+            && (!stateRoot || sameFilePath(stateRoot, candidateStateRoot))
+          ) {
+            return true;
+          }
+        } catch {
+          return false;
+        }
+      }
+      // A worker notify hook with an explicit runtime root hint is OMX-scoped
+      // even when the hint fails validation. Let the main worker path log the
+      // unresolved-root warning and fail closed without inventing local state.
+      if (
+        safeString(process.env.OMX_TEAM_STATE_ROOT || '').trim()
+        || safeString(process.env.OMX_TEAM_LEADER_CWD || '').trim()
+      ) {
+        return true;
+      }
+    }
+  }
+  const hooksPath = join(cwd, '.codex', 'hooks.json');
+  if (existsSync(hooksPath)) {
+    try {
+      const raw = await readFile(hooksPath, 'utf-8');
+      return /(?:^|[\\/])codex-native-hook\.js(?:["'\s]|$)/.test(raw);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
 function summarizeIdleNotificationMessage(message: unknown): string {
   const source = safeString(message)
     .split('\n')
@@ -172,6 +285,9 @@ async function main() {
   }
 
   const cwd = payload.cwd || payload['cwd'] || process.cwd();
+  if (!(await isOmxManagedCwd(cwd))) {
+    process.exit(0);
+  }
   const payloadSessionId = safeString(payload.session_id || payload['session-id'] || '');
   const payloadThreadId = safeString(payload['thread-id'] || payload.thread_id || '');
   const inputMessages = normalizeInputMessages(payload);