oh-my-codex 0.11.12 → 0.11.13

package/src/scripts/notify-hook/managed-tmux.ts

@@ -0,0 +1,324 @@
+import { execFileSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { basename, dirname, resolve as resolvePath } from 'path';
+import { readSessionState, isSessionStale } from '../../hooks/session.js';
+import { runProcess } from './process-runner.js';
+import { safeString } from './utils.js';
+
+function sanitizeTmuxToken(value: string): string {
+  const cleaned = safeString(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return cleaned || 'unknown';
+}
+
+export function buildExpectedManagedTmuxSessionName(cwd: string, sessionId: string): string {
+  const parentPath = dirname(cwd);
+  const parentDir = basename(parentPath);
+  const dirName = basename(cwd);
+  const grandparentPath = dirname(parentPath);
+  const grandparentDir = basename(grandparentPath);
+  const repoDir = parentDir.endsWith('.omx-worktrees')
+    ? parentDir.slice(0, -'.omx-worktrees'.length)
+    : parentDir === 'worktrees' && grandparentDir === '.omx'
+      ? basename(dirname(grandparentPath))
+      : null;
+  const dirToken = repoDir
+    ? sanitizeTmuxToken(`${repoDir}-${dirName}`)
+    : sanitizeTmuxToken(dirName);
+  let branchToken = 'detached';
+  try {
+    const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2000,
+      windowsHide: true,
+    }).trim();
+    if (branch) branchToken = sanitizeTmuxToken(branch);
+  } catch {
+    // best effort only
+  }
+  const sessionToken = sanitizeTmuxToken(sessionId.replace(/^omx-/, ''));
+  const name = `omx-${dirToken}-${branchToken}-${sessionToken}`;
+  return name.length > 120 ? name.slice(0, 120) : name;
+}
+
+export function resolveInvocationSessionId(payload: any): string {
+  return safeString(
+    payload?.session_id
+    || payload?.['session-id']
+    || process.env.OMX_SESSION_ID
+    || process.env.CODEX_SESSION_ID
+    || process.env.SESSION_ID
+    || '',
+  ).trim();
+}
+
+function readCurrentTmuxSessionName(): string {
+  if (!process.env.TMUX) return '';
+  try {
+    return execFileSync('tmux', ['display-message', '-p', '#S'], {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2000,
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function readParentPid(pid: number): number | null {
+  if (!Number.isInteger(pid) || pid <= 1) return null;
+  try {
+    if (process.platform === 'linux') {
+      const stat = readFileSync(`/proc/${pid}/stat`, 'utf-8');
+      const commandEnd = stat.lastIndexOf(')');
+      if (commandEnd === -1) return null;
+      const remainder = stat.slice(commandEnd + 1).trim();
+      const fields = remainder.split(/\s+/);
+      if (fields.length === 0) return null;
+      const ppid = Number(fields[1]);
+      return Number.isFinite(ppid) && ppid > 0 ? ppid : null;
+    }
+    const raw = execFileSync('ps', ['-o', 'ppid=', '-p', String(pid)], {
+      encoding: 'utf-8',
+      timeout: 2000,
+    }).trim();
+    const ppid = Number(raw);
+    return Number.isFinite(ppid) && ppid > 0 ? ppid : null;
+  } catch {
+    return null;
+  }
+}
+
+function processHasAncestorPid(targetPid: number, currentPid = process.pid): boolean {
+  if (!Number.isInteger(targetPid) || targetPid <= 1) return false;
+  let pid = Number.isInteger(currentPid) && currentPid > 1 ? currentPid : process.pid;
+  for (let depth = 0; depth < 64 && pid > 1; depth += 1) {
+    if (pid === targetPid) return true;
+    const parent = readParentPid(pid);
+    if (!parent || parent === pid) break;
+    pid = parent;
+  }
+  return false;
+}
+
+export async function resolveManagedSessionContext(cwd: string, payload: any, { allowTeamWorker = true } = {}): Promise<any> {
+  if (allowTeamWorker && safeString(process.env.OMX_TEAM_WORKER || '').trim() !== '') {
+    return {
+      managed: true,
+      reason: 'team_worker',
+      invocationSessionId: '',
+      sessionState: null,
+      expectedTmuxSessionName: '',
+      currentTmuxSessionName: '',
+    };
+  }
+
+  const invocationSessionId = resolveInvocationSessionId(payload);
+  if (!invocationSessionId) {
+    return {
+      managed: false,
+      reason: 'missing_session_id',
+      invocationSessionId: '',
+      sessionState: null,
+      expectedTmuxSessionName: '',
+      currentTmuxSessionName: '',
+    };
+  }
+
+  try {
+    const sessionState = await readSessionState(cwd);
+    if (!sessionState) {
+      return { managed: false, reason: 'missing_session_state', invocationSessionId, sessionState: null, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
+    }
+    if (resolvePath(safeString(sessionState.cwd || cwd)) !== resolvePath(cwd)) {
+      return { managed: false, reason: 'cwd_mismatch', invocationSessionId, sessionState, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
+    }
+    if (safeString(sessionState.session_id).trim() !== invocationSessionId) {
+      return { managed: false, reason: 'session_id_mismatch', invocationSessionId, sessionState, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
+    }
+    if (isSessionStale(sessionState)) {
+      return { managed: false, reason: 'stale_session', invocationSessionId, sessionState, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
+    }
+
+    const expectedTmuxSessionName = buildExpectedManagedTmuxSessionName(cwd, invocationSessionId);
+    const currentTmuxSessionName = readCurrentTmuxSessionName();
+    if (currentTmuxSessionName && currentTmuxSessionName === expectedTmuxSessionName) {
+      return {
+        managed: true,
+        reason: 'tmux_session_match',
+        invocationSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName,
+      };
+    }
+
+    if (processHasAncestorPid(sessionState.pid)) {
+      return {
+        managed: true,
+        reason: currentTmuxSessionName ? 'pid_ancestry_match_tmux_mismatch' : 'pid_ancestry_match',
+        invocationSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName: '',
+      };
+    }
+
+    return {
+      managed: false,
+      reason: currentTmuxSessionName ? 'tmux_session_mismatch' : 'pid_ancestry_mismatch',
+      invocationSessionId,
+      sessionState,
+      expectedTmuxSessionName,
+      currentTmuxSessionName,
+    };
+  } catch {
+    return {
+      managed: false,
+      reason: 'session_check_failed',
+      invocationSessionId,
+      sessionState: null,
+      expectedTmuxSessionName: '',
+      currentTmuxSessionName: '',
+    };
+  }
+}
+
+export async function isManagedOmxSession(cwd: string, payload: any, options: { allowTeamWorker?: boolean } = {}): Promise<boolean> {
+  const context = await resolveManagedSessionContext(cwd, payload, options);
+  return context.managed === true;
+}
+
+export async function verifyManagedPaneTarget(paneId: string, cwd: string, payload: any, { allowTeamWorker = true } = {}): Promise<any> {
+  const paneTarget = safeString(paneId).trim();
+  if (!paneTarget) {
+    return { ok: false, reason: 'missing_pane_target', paneTarget: '' };
+  }
+
+  const managedContext = await resolveManagedSessionContext(cwd, payload, { allowTeamWorker });
+  if (!managedContext.managed) {
+    return { ok: false, reason: managedContext.reason || 'unmanaged_session', paneTarget, managedContext };
+  }
+
+  if (managedContext.reason === 'team_worker') {
+    return { ok: true, reason: 'ok', paneTarget, managedContext };
+  }
+
+  const expectedSession = safeString(managedContext.expectedTmuxSessionName).trim();
+  if (!expectedSession) {
+    return { ok: false, reason: 'missing_expected_tmux_session', paneTarget, managedContext };
+  }
+
+  try {
+    const sessionResult = await runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#S'], 2000);
+    const paneSessionName = safeString(sessionResult.stdout).trim();
+    if (!paneSessionName) {
+      return { ok: false, reason: 'pane_session_missing', paneTarget, managedContext };
+    }
+    if (paneSessionName !== expectedSession) {
+      return { ok: false, reason: 'pane_not_managed_session', paneTarget, paneSessionName, managedContext };
+    }
+    return { ok: true, reason: 'ok', paneTarget, paneSessionName, managedContext };
+  } catch {
+    return { ok: false, reason: 'pane_session_lookup_failed', paneTarget, managedContext };
+  }
+}
+
+
+async function readManagedPaneCommandState(paneTarget: string): Promise<{ currentCommand: string; startCommand: string }> {
+  try {
+    const [currentResult, startResult] = await Promise.all([
+      runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#{pane_current_command}'], 2000),
+      runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#{pane_start_command}'], 2000),
+    ]);
+    return {
+      currentCommand: safeString(currentResult.stdout).trim().toLowerCase(),
+      startCommand: safeString(startResult.stdout).trim().toLowerCase(),
+    };
+  } catch {
+    return { currentCommand: '', startCommand: '' };
+  }
+}
+
+function paneLooksLikeManagedAgent({ currentCommand, startCommand }: { currentCommand: string; startCommand: string }): boolean {
+  if (/\bomx\b.*\bhud\b.*--watch/i.test(startCommand)) return false;
+  if (startCommand.includes('codex')) return true;
+  return currentCommand === 'codex' || currentCommand === 'node' || currentCommand === 'npx';
+}
+export async function resolveManagedCurrentPane(cwd: string, payload: any, { allowTeamWorker = false } = {}): Promise<string> {
+  const paneTarget = safeString(process.env.TMUX_PANE || '').trim();
+  if (!paneTarget) return '';
+  const verdict = await verifyManagedPaneTarget(paneTarget, cwd, payload, { allowTeamWorker });
+  if (!verdict.ok) return '';
+  const commandState = await readManagedPaneCommandState(paneTarget);
+  return paneLooksLikeManagedAgent(commandState) ? paneTarget : '';
+}
+
+export async function resolveManagedSessionPane(cwd: string, payload: any): Promise<string> {
+  const managedContext = await resolveManagedSessionContext(cwd, payload, { allowTeamWorker: false });
+  if (!managedContext.managed) return '';
+  const expectedSession = safeString(managedContext.expectedTmuxSessionName).trim();
+  if (!expectedSession) return '';
+
+  try {
+    const panesResult = await runProcess(
+      'tmux',
+      ['list-panes', '-s', '-t', expectedSession, '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}'],
+      2000,
+    );
+    const panes = safeString(panesResult.stdout)
+      .trim()
+      .split('\n')
+      .filter(Boolean);
+    for (const line of panes) {
+      const [candidatePaneId, rawCurrentCommand = '', rawStartCommand = ''] = line.split('\t');
+      const startCommand = safeString(rawStartCommand).toLowerCase();
+      const currentCommand = safeString(rawCurrentCommand).trim().toLowerCase();
+      if (!candidatePaneId) continue;
+      if (/\bomx\b.*\bhud\b.*--watch/i.test(startCommand)) continue;
+      if (startCommand.includes('codex')) return candidatePaneId;
+      if (currentCommand === 'codex') return candidatePaneId;
+    }
+  } catch {
+    // best effort only
+  }
+
+  return '';
+}
+
+export async function resolveManagedPaneFromAnchor(anchorPane: string, cwd: string, payload: any, { allowTeamWorker = false } = {}): Promise<string> {
+  const paneTarget = safeString(anchorPane).trim();
+  if (!paneTarget) return '';
+  const verdict = await verifyManagedPaneTarget(paneTarget, cwd, payload, { allowTeamWorker });
+  if (!verdict.ok) return '';
+
+  try {
+    const sessionResult = await runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#S'], 2000);
+    const sessionName = safeString(sessionResult.stdout).trim();
+    if (!sessionName) return paneTarget;
+
+    const panesResult = await runProcess(
+      'tmux',
+      ['list-panes', '-s', '-t', sessionName, '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}'],
+      2000,
+    );
+    const panes = safeString(panesResult.stdout).trim().split('\n').filter(Boolean);
+    for (const line of panes) {
+      const [candidatePaneId, rawCurrentCommand = '', rawStartCommand = ''] = line.split('\t');
+      const startCommand = safeString(rawStartCommand).toLowerCase();
+      const currentCommand = safeString(rawCurrentCommand).trim().toLowerCase();
+      if (!candidatePaneId) continue;
+      if (/\bomx\b.*\bhud\b.*--watch/i.test(startCommand)) continue;
+      if (startCommand.includes('codex')) return candidatePaneId;
+      if (currentCommand === 'codex') return candidatePaneId;
+    }
+  } catch {
+    // best effort only
+  }
+
+  return paneTarget;
+}

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

@@ -0,0 +1,337 @@
+import { existsSync } from 'fs';
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { captureTmuxPaneFromEnv } from '../../state/mode-state-context.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(['complete', 'failed', 'cancelled']);
+const RALPH_RESUME_LOCK_STALE_MS = 10_000;
+const RALPH_RESUME_LOCK_TIMEOUT_MS = 5_000;
+const RALPH_RESUME_LOCK_RETRY_MS = 25;
+
+interface RalphSessionResumeHooks {
+  afterLockAcquired?: () => Promise<void> | void;
+  afterTargetWrite?: () => Promise<void> | void;
+}
+
+interface RalphSessionResumeParams {
+  stateDir: string;
+  payloadSessionId: string;
+  payloadThreadId?: string;
+  env?: NodeJS.ProcessEnv;
+  hooks?: RalphSessionResumeHooks;
+}
+
+export interface RalphSessionResumeResult {
+  currentOmxSessionId: string;
+  resumed: boolean;
+  updatedCurrentOwner: boolean;
+  reason: string;
+  sourcePath?: string;
+  targetPath?: string;
+}
+
+interface RalphStateCandidate {
+  sessionId: string;
+  path: string;
+  state: Record<string, unknown>;
+}
+
+function lockOwnerToken(): string {
+  return `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+}
+
+async function sleep(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function maybeRecoverStaleLock(lockDir: string): Promise<boolean> {
+  try {
+    const info = await stat(lockDir);
+    if (Date.now() - info.mtimeMs <= RALPH_RESUME_LOCK_STALE_MS) {
+      return false;
+    }
+    await rm(lockDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function withRalphResumeLock<T>(
+  stateDir: string,
+  fn: () => Promise<T>,
+): Promise<T | null> {
+  const lockDir = join(stateDir, '.lock.ralph-session-resume');
+  const ownerPath = join(lockDir, 'owner');
+  const ownerToken = lockOwnerToken();
+  const deadline = Date.now() + RALPH_RESUME_LOCK_TIMEOUT_MS;
+  await mkdir(dirname(lockDir), { recursive: true }).catch(() => {});
+
+  while (true) {
+    try {
+      await mkdir(lockDir, { recursive: false });
+      try {
+        await writeFile(ownerPath, ownerToken, 'utf8');
+      } catch (error) {
+        await rm(lockDir, { recursive: true, force: true }).catch(() => {});
+        throw error;
+      }
+      break;
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      if (err.code !== 'EEXIST') throw error;
+      if (await maybeRecoverStaleLock(lockDir)) continue;
+      if (Date.now() > deadline) return null;
+      await sleep(RALPH_RESUME_LOCK_RETRY_MS);
+    }
+  }
+
+  try {
+    return await fn();
+  } finally {
+    try {
+      const currentOwner = await readFile(ownerPath, 'utf8');
+      if (currentOwner.trim() === ownerToken) {
+        await rm(lockDir, { recursive: true, force: true });
+      }
+    } catch {
+      // Lock may already be gone after stale recovery or process interruption.
+    }
+  }
+}
+
+async function readJson(path: string): Promise<Record<string, unknown> | null> {
+  try {
+    return JSON.parse(await readFile(path, 'utf-8')) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+async function writeJsonAtomic(path: string, value: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true }).catch(() => {});
+  const tempPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  await writeFile(tempPath, JSON.stringify(value, null, 2));
+  await rename(tempPath, path);
+}
+
+function isTerminalRalphPhase(value: unknown): boolean {
+  return RALPH_TERMINAL_PHASES.has(safeString(value).trim().toLowerCase());
+}
+
+function isActiveRalphCandidate(state: Record<string, unknown> | null): state is Record<string, unknown> {
+  if (!state || typeof state !== 'object') return false;
+  return state.active === true && !isTerminalRalphPhase(state.current_phase);
+}
+
+async function readCurrentOmxSessionId(stateDir: string): Promise<string> {
+  const session = await readJson(join(stateDir, 'session.json'));
+  const sessionId = safeString(session?.session_id).trim();
+  return SESSION_ID_PATTERN.test(sessionId) ? sessionId : '';
+}
+
+function resolveResumePane(env: NodeJS.ProcessEnv = process.env): string {
+  const injectedPane = captureTmuxPaneFromEnv(env);
+  if (env !== process.env && injectedPane) return injectedPane;
+  return resolveCodexPane() || injectedPane || '';
+}
+
+function bindCurrentPane(state: Record<string, unknown>, nowIso: string, env: NodeJS.ProcessEnv = process.env): Record<string, unknown> {
+  const paneId = resolveResumePane(env);
+  if (!paneId) return state;
+
+  return {
+    ...state,
+    tmux_pane_id: paneId,
+    tmux_pane_set_at: nowIso,
+  };
+}
+
+async function scanMatchingRalphCandidates(
+  stateDir: string,
+  currentOmxSessionId: string,
+  payloadSessionId: string,
+  payloadThreadId: string,
+): Promise<RalphStateCandidate[]> {
+  const sessionsRoot = join(stateDir, 'sessions');
+  if (!existsSync(sessionsRoot)) return [];
+
+  const entries = await readdir(sessionsRoot, { withFileTypes: true }).catch(() => []);
+  const matches: RalphStateCandidate[] = [];
+  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');
+    if (!existsSync(path)) continue;
+    const state = await readJson(path);
+    if (!isActiveRalphCandidate(state)) continue;
+    const ownerSessionId = safeString(state.owner_codex_session_id).trim();
+    const ownerThreadId = safeString(state.owner_codex_thread_id).trim();
+    if (ownerSessionId) {
+      if (!payloadSessionId || ownerSessionId !== payloadSessionId) continue;
+    } else if (!payloadThreadId || !ownerThreadId || ownerThreadId !== payloadThreadId) {
+      continue;
+    }
+    matches.push({
+      sessionId: entry.name,
+      path,
+      state,
+    });
+  }
+  return matches;
+}
+
+export async function reconcileRalphSessionResume({
+  stateDir,
+  payloadSessionId,
+  payloadThreadId = '',
+  env = process.env,
+  hooks,
+}: RalphSessionResumeParams): Promise<RalphSessionResumeResult> {
+  const lockedResult = await withRalphResumeLock(stateDir, async () => {
+    await hooks?.afterLockAcquired?.();
+
+    const currentOmxSessionId = await readCurrentOmxSessionId(stateDir);
+    if (!currentOmxSessionId) {
+      return {
+        currentOmxSessionId: '',
+        resumed: false,
+        updatedCurrentOwner: false,
+        reason: 'current_omx_session_missing',
+      };
+    }
+
+    const currentSessionDir = join(stateDir, 'sessions', currentOmxSessionId);
+    const currentRalphPath = join(currentSessionDir, 'ralph-state.json');
+    const currentRalphExists = existsSync(currentRalphPath);
+    const currentRalphState = currentRalphExists
+      ? await readJson(currentRalphPath)
+      : null;
+    const nowIso = new Date().toISOString();
+
+    if (currentRalphState && currentRalphState.active === true) {
+      let changed = false;
+      const updated: Record<string, unknown> = { ...currentRalphState };
+      if (safeString(updated.owner_omx_session_id).trim() !== currentOmxSessionId) {
+        updated.owner_omx_session_id = currentOmxSessionId;
+        changed = true;
+      }
+      if (payloadSessionId && !safeString(updated.owner_codex_session_id).trim()) {
+        updated.owner_codex_session_id = payloadSessionId;
+        changed = true;
+      }
+      if (
+        typeof updated.owner_codex_thread_id === 'string'
+        && safeString(updated.owner_codex_session_id).trim()
+      ) {
+        delete updated.owner_codex_thread_id;
+        changed = true;
+      }
+      const currentPaneId = resolveResumePane(env);
+      const currentStatePaneId = safeString(updated.tmux_pane_id).trim();
+      if (currentPaneId && currentPaneId !== currentStatePaneId) {
+        Object.assign(updated, bindCurrentPane(updated, nowIso, env));
+        changed = true;
+      }
+      if (changed) {
+        await writeJsonAtomic(currentRalphPath, updated);
+      }
+      return {
+        currentOmxSessionId,
+        resumed: false,
+        updatedCurrentOwner: changed,
+        reason: 'current_ralph_active',
+        targetPath: currentRalphPath,
+      };
+    }
+
+    if (currentRalphExists) {
+      return {
+        currentOmxSessionId,
+        resumed: false,
+        updatedCurrentOwner: false,
+        reason: currentRalphState ? 'current_ralph_present' : 'current_ralph_unreadable',
+        targetPath: currentRalphPath,
+      };
+    }
+
+    const normalizedPayloadSessionId = safeString(payloadSessionId).trim();
+    const normalizedPayloadThreadId = safeString(payloadThreadId).trim();
+    if (!normalizedPayloadSessionId && !normalizedPayloadThreadId) {
+      return {
+        currentOmxSessionId,
+        resumed: false,
+        updatedCurrentOwner: false,
+        reason: 'payload_codex_identity_missing',
+      };
+    }
+
+    const candidates = await scanMatchingRalphCandidates(
+      stateDir,
+      currentOmxSessionId,
+      normalizedPayloadSessionId,
+      normalizedPayloadThreadId,
+    );
+    if (candidates.length !== 1) {
+      return {
+        currentOmxSessionId,
+        resumed: false,
+        updatedCurrentOwner: false,
+        reason: candidates.length === 0 ? 'no_matching_prior_ralph' : 'multiple_matching_prior_ralphs',
+      };
+    }
+
+    const source = candidates[0];
+    await mkdir(currentSessionDir, { recursive: true });
+
+    const nextState = bindCurrentPane({
+      ...source.state,
+      owner_omx_session_id: currentOmxSessionId,
+      ...(normalizedPayloadSessionId ? { owner_codex_session_id: normalizedPayloadSessionId } : {}),
+    }, nowIso, env);
+    if (safeString(nextState.owner_codex_session_id).trim()) {
+      delete nextState.owner_codex_thread_id;
+    }
+    delete nextState.completed_at;
+    delete nextState.stop_reason;
+
+    const previousState: Record<string, unknown> = {
+      ...source.state,
+      active: false,
+      current_phase: 'cancelled',
+      completed_at: nowIso,
+      stop_reason: 'ownership_transferred',
+    };
+
+    await writeJsonAtomic(currentRalphPath, nextState);
+    try {
+      await hooks?.afterTargetWrite?.();
+      await writeJsonAtomic(source.path, previousState);
+    } catch (error) {
+      await rm(currentRalphPath, { force: true }).catch(() => {});
+      throw error;
+    }
+
+    return {
+      currentOmxSessionId,
+      resumed: true,
+      updatedCurrentOwner: false,
+      reason: 'resumed_same_codex_session',
+      sourcePath: source.path,
+      targetPath: currentRalphPath,
+    };
+  });
+
+  if (lockedResult) {
+    return lockedResult;
+  }
+
+  return {
+    currentOmxSessionId: '',
+    resumed: false,
+    updatedCurrentOwner: false,
+    reason: 'resume_lock_timeout',
+  };
+}

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

@@ -3,7 +3,6 @@
  */
 
 import { readFile, readdir } from 'fs/promises';
-import { existsSync } from 'fs';
 import { join } from 'path';
 import { asNumber, safeString } from './utils.js';
 
@@ -17,20 +16,13 @@ export function readJsonIfExists(path: string, fallback: any): Promise<any> {
     .catch(() => fallback);
 }
 
-export async function getScopedStateDirsForCurrentSession(baseStateDir: string, payloadSessionId?: any): Promise<string[]> {
-  const explicitSessionId = safeString(payloadSessionId || '');
-  if (SESSION_ID_PATTERN.test(explicitSessionId)) {
-    const sessionDir = join(baseStateDir, 'sessions', explicitSessionId);
-    return [sessionDir];
-  }
-
+export async function getScopedStateDirsForCurrentSession(baseStateDir: string): Promise<string[]> {
   const sessionPath = join(baseStateDir, 'session.json');
   try {
     const session = JSON.parse(await readFile(sessionPath, 'utf-8'));
     const sessionId = safeString(session && session.session_id ? session.session_id : '');
     if (SESSION_ID_PATTERN.test(sessionId)) {
-      const sessionDir = join(baseStateDir, 'sessions', sessionId);
-      if (existsSync(sessionDir)) return [sessionDir];
+      return [join(baseStateDir, 'sessions', sessionId)];
     }
   } catch {
     // No session file or malformed - fall back to global only