oh-my-codex 0.20.1 → 0.20.3

package/src/scripts/notify-hook/auto-nudge.ts

@@ -25,12 +25,17 @@ import { readAutoresearchCompletionStatus } from '../../autoresearch/skill-valid
 import { persistDeepInterviewModeState } from '../../hooks/keyword-detector.js';
 import {
   isManagedOmxSession,
+  isManagedOmxSessionAtPromptContext,
   resolveManagedCurrentPane,
+  resolveManagedCurrentPaneAtPromptContext,
   resolveManagedPaneFromAnchor,
+  resolveManagedPaneFromAnchorAtPromptContext,
   resolveManagedSessionPane,
+  resolveManagedSessionPaneAtPromptContext,
   resolveInvocationSessionId,
   verifyManagedPaneTarget,
 } from './managed-tmux.js';
+import type { PromptMutationAuthorization, ResolvedPromptTurnContext } from '../../hooks/prompt-session-provenance.js';
 
 export const SKILL_ACTIVE_STATE_FILE = 'skill-active-state.json';
 export const DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS = ['yes', 'y', 'proceed', 'continue', 'ok', 'sure', 'go ahead', 'next i should'];
@@ -161,6 +166,7 @@ export function normalizeSkillActiveState(raw) {
     activated_at: safeString(raw.activated_at),
     updated_at: safeString(raw.updated_at),
     source: safeString(raw.source),
+    owner_codex_session_id: safeString(raw.owner_codex_session_id),
     input_lock: normalizeInputLock(raw.input_lock),
   };
 }
@@ -210,16 +216,28 @@ function cloneSkillActiveState(state) {
   };
 }
 
-export async function syncSkillStateFromTurn(stateDir, payload) {
+export async function syncSkillStateFromTurn(stateDir, payload, invocationSessionIdOverride = '', authorization: PromptMutationAuthorization | null = null) {
   const lastMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
   const latestUserInput = latestUserInputFromPayload(payload);
-  const invocationSessionId = resolveInvocationSessionId(payload);
+  const invocationSessionId = invocationSessionIdOverride || resolveInvocationSessionId(payload);
   let skillState = await loadSkillActiveState(stateDir, invocationSessionId);
   let releaseReason = null;
 
   if (!skillState) {
     return { invocationSessionId, skillState: null, releaseReason };
   }
+  if (authorization) {
+    const allowedOwners = Array.isArray(authorization.allowedOwnerCodexSessionIds)
+      ? authorization.allowedOwnerCodexSessionIds
+      : [];
+    const existingOwner = safeString(skillState.owner_codex_session_id).trim();
+    if (existingOwner && !allowedOwners.includes(existingOwner)) {
+      return { invocationSessionId, skillState: null, releaseReason: 'owner_conflict' };
+    }
+    if (authorization.ownerCodexSessionId) {
+      skillState.owner_codex_session_id = authorization.ownerCodexSessionId;
+    }
+  }
 
   const previousSkillState = cloneSkillActiveState(skillState);
   const previousPhase = normalizeSkillPhase(skillState.phase);
@@ -541,12 +559,50 @@ export async function capturePane(paneId, lines = 10) {
   }
 }
 
-export async function resolveNudgePaneTarget(stateDir: any, cwd = '', payload: any = undefined) {
+async function resolveTeamWorkerNudgeBinding(stateDir: string): Promise<{
+  paneId: string;
+  panePid: number;
+  paneOwnerId: string;
+  hudPaneId: string;
+} | null> {
+  const workerContext = safeString(process.env.OMX_TEAM_WORKER || '').trim();
+  if (!workerContext) return null;
+  const match = /^([A-Za-z0-9][A-Za-z0-9_-]*)\/(worker-[1-9]\d*)$/.exec(workerContext);
+  if (!match) return null;
+  const [, teamName, workerName] = match;
+  const teamDir = join(stateDir, 'team', teamName);
+  try {
+    const manifestPath = join(teamDir, 'manifest.v2.json');
+    const configPath = join(teamDir, 'config.json');
+    let raw: any;
+    try {
+      raw = JSON.parse(await readFile(manifestPath, 'utf-8'));
+    } catch {
+      raw = JSON.parse(await readFile(configPath, 'utf-8'));
+    }
+    if (safeString(raw?.name).trim() !== teamName || !Array.isArray(raw?.workers)) return null;
+    const worker = raw.workers.find((entry: any) => safeString(entry?.name).trim() === workerName);
+    const paneId = safeString(worker?.pane_id).trim();
+    const panePid = asNumber(worker?.pid);
+    const hudPaneId = safeString(raw?.hud_pane_id).trim();
+    const paneOwnerId = typeof raw?.tmux_pane_owner_id === 'string' ? raw.tmux_pane_owner_id.trim() : '';
+    if (!/^%\d+$/.test(paneId) || !Number.isInteger(panePid) || panePid <= 0 || !paneOwnerId || paneId === hudPaneId) return null;
+    return { paneId, panePid, paneOwnerId, hudPaneId };
+  } catch {
+    return null;
+  }
+}
+
+export async function resolveNudgePaneTarget(stateDir: any, cwd = '', payload: any = undefined, context: ResolvedPromptTurnContext | null = null) {
   const allowTeamWorker = safeString(process.env.OMX_TEAM_WORKER || '').trim() !== '';
-  const managedCurrentPane = await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker });
+  const managedCurrentPane = context
+    ? await resolveManagedCurrentPaneAtPromptContext(cwd, context)
+    : await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker });
   if (managedCurrentPane) return managedCurrentPane;
 
-  const invocationSessionId = resolveInvocationSessionId(payload);
+  const invocationSessionId = context?.status === 'authorized'
+    ? context.authorization.targetSessionId
+    : resolveInvocationSessionId(payload);
   const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir, invocationSessionId).catch(() => []);
   for (const dir of scopedDirs) {
     const files = await readdir(dir).catch(() => []);
@@ -558,9 +614,11 @@ export async function resolveNudgePaneTarget(stateDir: any, cwd = '', payload: a
         if (!state || !state.active || !state.tmux_pane_id) continue;
         const anchoredPane = safeString(state.tmux_pane_id).trim();
         if (!anchoredPane) continue;
-        const managedPane = await resolveManagedPaneFromAnchor(anchoredPane, cwd, payload, { allowTeamWorker });
+        const managedPane = context
+          ? await resolveManagedPaneFromAnchorAtPromptContext(anchoredPane, cwd, context)
+          : await resolveManagedPaneFromAnchor(anchoredPane, cwd, payload, { allowTeamWorker });
         if (managedPane) return managedPane;
-        if (allowTeamWorker) {
+        if (allowTeamWorker && !context) {
           const verdict = await verifyManagedPaneTarget(anchoredPane, cwd, payload, { allowTeamWorker });
           if (verdict.ok) return anchoredPane;
         }
@@ -570,10 +628,12 @@ export async function resolveNudgePaneTarget(stateDir: any, cwd = '', payload: a
     }
   }
 
-  return await resolveManagedSessionPane(cwd, payload);
+  return context
+    ? await resolveManagedSessionPaneAtPromptContext(cwd, context)
+    : await resolveManagedSessionPane(cwd, payload);
 }
 
-export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
+export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload, context = null, syncResult = null }: { cwd: string; stateDir: string; logsDir: string; payload: any; context?: ResolvedPromptTurnContext | null; syncResult?: any }) {
   const config = await loadAutoNudgeConfig();
   const effectiveResponse = resolveEffectiveAutoNudgeResponse(config.response);
   if (!config.enabled) return;
@@ -587,7 +647,9 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
   }
 
   const sourceName = safeString(payload?.source || '');
-  const managedSession = await isManagedOmxSession(cwd, payload, { allowTeamWorker: true });
+  const managedSession = context
+    ? await isManagedOmxSessionAtPromptContext(cwd, context, { allowTeamWorker: false })
+    : await isManagedOmxSession(cwd, payload, { allowTeamWorker: true });
   if (!managedSession) {
     if (sourceName === 'notify-fallback-watcher-stall') return;
     await logTmuxHookEvent(logsDir, {
@@ -599,7 +661,10 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
   }
 
   const lastMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
-  const { invocationSessionId, skillState, releaseReason } = await syncSkillStateFromTurn(stateDir, payload);
+  const { invocationSessionId, skillState, releaseReason } = syncResult
+    || (context?.status === 'authorized'
+      ? { invocationSessionId: context.authorization.targetSessionId, skillState: null, releaseReason: null }
+      : await syncSkillStateFromTurn(stateDir, payload));
 
   try {
     const nudgeStatePath = await getScopedStatePath(stateDir, 'auto-nudge-state.json', invocationSessionId);
@@ -607,14 +672,34 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
     if (!nudgeState || typeof nudgeState !== 'object') {
       nudgeState = { nudgeCount: 0, lastNudgeAt: '', lastSignature: '', lastSemanticSignature: '' };
     }
-    const paneId = await resolveNudgePaneTarget(stateDir, cwd, payload);
+    const teamWorkerBinding = await resolveTeamWorkerNudgeBinding(stateDir);
+    if (safeString(process.env.OMX_TEAM_WORKER || '').trim() && !teamWorkerBinding) return;
+    const paneId = teamWorkerBinding?.paneId
+      ?? await resolveNudgePaneTarget(stateDir, cwd, payload, context);
+    const teamPaneOptions = teamWorkerBinding
+      ? {
+        exactPaneId: teamWorkerBinding.paneId,
+        expectedPanePid: teamWorkerBinding.panePid,
+        expectedPaneOwnerId: teamWorkerBinding.paneOwnerId,
+        expectedHudPaneId: teamWorkerBinding.hudPaneId,
+      }
+      : { exactPaneId: paneId };
 
     let detected = detectStallPattern(lastMessage, config.patterns, skillState?.phase);
     let source = 'payload';
     let captured = '';
 
     if (!detected && paneId) {
-      captured = await capturePane(paneId);
+      if (teamWorkerBinding) {
+        const captureGuard = await evaluatePaneInjectionReadiness(paneId, {
+          skipIfScrolling: true,
+          ...teamPaneOptions,
+        });
+        if (!captureGuard.ok) return;
+        captured = captureGuard.paneCapture;
+      } else {
+        captured = await capturePane(paneId);
+      }
       detected = detectStallPattern(filterCapturedTestLines(captured), config.patterns, skillState?.phase);
       source = 'capture-pane';
     }
@@ -675,7 +760,7 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
       return;
     }
 
-    const paneGuard = await evaluatePaneInjectionReadiness(paneId, { skipIfScrolling: true });
+    const paneGuard = await evaluatePaneInjectionReadiness(paneId, { skipIfScrolling: true, ...teamPaneOptions });
     if (!paneGuard.ok) {
       await logTmuxHookEvent(logsDir, {
         timestamp: new Date().toISOString(),
@@ -688,6 +773,18 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
       }).catch(() => {});
       return;
     }
+    const readinessPanePid = asNumber(paneGuard.exactPaneProof?.pid);
+    if (!Number.isInteger(readinessPanePid) || readinessPanePid <= 0) {
+      await logTmuxHookEvent(logsDir, {
+        timestamp: new Date().toISOString(),
+        type: 'auto_nudge_skipped',
+        pane_id: paneId,
+        reason: 'pane_readiness_unverified',
+        source,
+      }).catch(() => {});
+      return;
+    }
+    const pinnedPaneOptions = { ...teamPaneOptions, expectedPanePid: readinessPanePid };
 
     const blockedAutoApproval = isDeepInterviewAutoApprovalLocked(skillState)
       && !releaseReason
@@ -716,6 +813,8 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
     try {
       const sendResult = await sendPaneInput({
         paneTarget: paneId,
+        exactPaneId: paneId,
+        ...pinnedPaneOptions,
         prompt: `${effectiveResponse} ${DEFAULT_MARKER}`,
         submitKeyPresses: 2,
         submitDelayMs: 100,

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

@@ -5,6 +5,8 @@ import { readSessionState, isSessionStale } from '../../hooks/session.js';
 import { runProcess } from './process-runner.js';
 import { safeString } from './utils.js';
 import { sameFilePath } from '../../utils/paths.js';
+import type { ResolvedPromptTurnContext } from '../../hooks/prompt-session-provenance.js';
+
 
 const OMX_INSTANCE_OPTION = '@omx_instance_id';
 const OMX_PANE_INSTANCE_OPTION = '@omx_pane_instance_id';
@@ -82,20 +84,30 @@ function readCurrentTmuxSessionName(): string {
   }
 }
 
-async function readTmuxOption(targetValue: string, optionName: string, { pane = false } = {}): Promise<string> {
+interface TmuxOptionProbe {
+  status: 'present' | 'absent' | 'error';
+  value: string;
+}
+
+async function probeTmuxOption(targetValue: string, optionName: string, { pane = false } = {}): Promise<TmuxOptionProbe> {
   const target = safeString(targetValue).trim();
-  if (!target) return '';
+  if (!target) return { status: 'absent', value: '' };
   const args = ['show-option', '-qv'];
   if (pane) args.push('-p');
   args.push('-t', target, optionName);
   try {
     const result = await runProcess('tmux', args, 2000);
-    return safeString(result.stdout).trim();
+    const value = safeString(result.stdout).trim();
+    return { status: value ? 'present' : 'absent', value };
   } catch {
-    return '';
+    return { status: 'error', value: '' };
   }
 }
 
+async function readTmuxOption(targetValue: string, optionName: string, { pane = false } = {}): Promise<string> {
+  return (await probeTmuxOption(targetValue, optionName, { pane })).value;
+}
+
 async function readTmuxSessionInstanceId(sessionTarget: string): Promise<string> {
   return readTmuxOption(sessionTarget, OMX_INSTANCE_OPTION);
 }
@@ -104,6 +116,86 @@ async function readTmuxPaneInstanceId(paneTarget: string): Promise<string> {
   return readTmuxOption(paneTarget, OMX_PANE_INSTANCE_OPTION, { pane: true });
 }
 
+export interface ActualTmuxInstanceEvidence {
+  paneTarget: string;
+  sessionName: string;
+  paneInstanceId: string;
+  sessionInstanceId: string;
+  instanceId: string;
+  source: 'none' | 'pane' | 'session';
+  paneTagStatus: 'not-requested' | 'present' | 'absent' | 'error';
+}
+
+export async function probeActualTmuxInstanceEvidence(paneTarget?: string): Promise<ActualTmuxInstanceEvidence> {
+  const resolvedPaneTarget = safeString(paneTarget ?? process.env.TMUX_PANE ?? '').trim();
+  let sessionName = '';
+  if (resolvedPaneTarget) {
+    try {
+      const result = await runProcess('tmux', ['display-message', '-p', '-t', resolvedPaneTarget, '#S'], 2000);
+      sessionName = safeString(result.stdout).trim();
+    } catch {
+      // A pane target without a session cannot provide session-tag evidence.
+    }
+  } else {
+    sessionName = readCurrentTmuxSessionName();
+  }
+
+  const paneProbe = resolvedPaneTarget
+    ? await probeTmuxOption(resolvedPaneTarget, OMX_PANE_INSTANCE_OPTION, { pane: true })
+    : { status: 'absent' as const, value: '' };
+  const paneTagStatus = resolvedPaneTarget ? paneProbe.status : 'not-requested';
+  if (paneProbe.status === 'present') {
+    return {
+      paneTarget: resolvedPaneTarget,
+      sessionName,
+      paneInstanceId: paneProbe.value,
+      sessionInstanceId: '',
+      instanceId: paneProbe.value,
+      source: 'pane',
+      paneTagStatus,
+    };
+  }
+  if (paneProbe.status === 'error') {
+    return {
+      paneTarget: resolvedPaneTarget,
+      sessionName,
+      paneInstanceId: '',
+      sessionInstanceId: '',
+      instanceId: '',
+      source: 'none',
+      paneTagStatus,
+    };
+  }
+
+  const sessionInstanceId = sessionName
+    ? await readTmuxSessionInstanceId(sessionName)
+    : '';
+  return {
+    paneTarget: resolvedPaneTarget,
+    sessionName,
+    paneInstanceId: '',
+    sessionInstanceId,
+    instanceId: sessionInstanceId,
+    source: sessionInstanceId ? 'session' : 'none',
+    paneTagStatus,
+  };
+}
+
+export function tmuxEvidenceBindsCandidate(
+  evidence: ActualTmuxInstanceEvidence,
+  candidateSessionId: string,
+): boolean {
+  const candidate = safeString(candidateSessionId).trim();
+  if (!candidate) return false;
+  if (evidence.paneTagStatus === 'present') {
+    return evidence.source === 'pane' && evidence.paneInstanceId === candidate;
+  }
+  return evidence.paneTagStatus === 'absent'
+    && evidence.source === 'session'
+    && evidence.sessionInstanceId === candidate;
+}
+
+
 function warnPaneInstanceFallback(paneTarget: string): void {
   // Notify hooks run inside Codex foreground hook surfaces. Keep this
   // compatibility fallback silent; downstream tmux-hook events still record
@@ -218,9 +310,10 @@ export async function resolveManagedSessionContext(
         authoritativeSessionCwd,
         canonicalSessionId || invocationSessionId,
       );
-    const currentTmuxSessionName = readCurrentTmuxSessionName();
-    const currentTmuxPaneTarget = safeString(paneTarget || process.env.TMUX_PANE || '').trim();
-    const currentTmuxPaneInstanceId = currentTmuxPaneTarget ? await readTmuxPaneInstanceId(currentTmuxPaneTarget) : '';
+    const evidence = await probeActualTmuxInstanceEvidence(paneTarget);
+    const currentTmuxSessionName = evidence.sessionName || readCurrentTmuxSessionName();
+    const currentTmuxPaneTarget = evidence.paneTarget;
+    const currentTmuxPaneInstanceId = evidence.paneInstanceId;
     if (currentTmuxPaneInstanceId && currentTmuxPaneInstanceId !== invocationSessionId) {
       return {
         managed: false,
@@ -248,7 +341,11 @@ export async function resolveManagedSessionContext(
       };
     }
 
-    const currentTmuxInstanceId = currentTmuxSessionName ? await readTmuxSessionInstanceId(currentTmuxSessionName) : '';
+    const currentTmuxInstanceId = evidence.sessionName === currentTmuxSessionName
+      ? evidence.sessionInstanceId
+      : currentTmuxSessionName
+        ? await readTmuxSessionInstanceId(currentTmuxSessionName)
+        : '';
     if (currentTmuxInstanceId && currentTmuxInstanceId !== invocationSessionId) {
       return {
         managed: false,
@@ -359,6 +456,39 @@ export async function isManagedOmxSession(cwd: string, payload: any, options: {
   return context.managed === true;
 }
 
+/**
+ * Leader-only adapter: tmux ownership is derived from the immutable provenance
+ * owner instead of re-reading payload or environment session identity.
+ */
+export async function isManagedOmxSessionAtPromptContext(
+  cwd: string,
+  context: ResolvedPromptTurnContext,
+  options: { allowTeamWorker?: boolean } = {},
+): Promise<boolean> {
+  if (context.status !== 'authorized') return false;
+  return isManagedOmxSession(cwd, { session_id: context.authorization.ownerCodexSessionId }, options);
+}
+
+export async function verifyManagedPaneTargetAtPromptContext(paneId: string, cwd: string, context: ResolvedPromptTurnContext): Promise<any> {
+  if (context.status !== 'authorized') return { ok: false, reason: 'prompt_context_unauthorized', paneTarget: safeString(paneId).trim() };
+  return verifyManagedPaneTarget(paneId, cwd, { session_id: context.authorization.ownerCodexSessionId }, { allowTeamWorker: false });
+}
+
+export async function resolveManagedCurrentPaneAtPromptContext(cwd: string, context: ResolvedPromptTurnContext): Promise<string> {
+  if (context.status !== 'authorized') return '';
+  return resolveManagedCurrentPane(cwd, { session_id: context.authorization.ownerCodexSessionId }, { allowTeamWorker: false });
+}
+
+export async function resolveManagedSessionPaneAtPromptContext(cwd: string, context: ResolvedPromptTurnContext): Promise<string> {
+  if (context.status !== 'authorized') return '';
+  return resolveManagedSessionPane(cwd, { session_id: context.authorization.ownerCodexSessionId });
+}
+
+export async function resolveManagedPaneFromAnchorAtPromptContext(anchorPane: string, cwd: string, context: ResolvedPromptTurnContext): Promise<string> {
+  if (context.status !== 'authorized') return '';
+  return resolveManagedPaneFromAnchor(anchorPane, cwd, { session_id: context.authorization.ownerCodexSessionId }, { allowTeamWorker: false });
+}
+
 export async function verifyManagedPaneTarget(paneId: string, cwd: string, payload: any, { allowTeamWorker = true } = {}): Promise<any> {
   const paneTarget = safeString(paneId).trim();
   if (!paneTarget) {
@@ -380,13 +510,20 @@ export async function verifyManagedPaneTarget(paneId: string, cwd: string, paylo
   }
 
   try {
-    const sessionResult = await runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#S'], 2000);
-    const paneSessionName = safeString(sessionResult.stdout).trim();
+    let paneSessionName = safeString(managedContext.currentTmuxSessionName).trim();
+    if (!paneSessionName) {
+      const sessionResult = await runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#S'], 2000);
+      paneSessionName = safeString(sessionResult.stdout).trim();
+    }
     if (!paneSessionName) {
       return { ok: false, reason: 'pane_session_missing', paneTarget, managedContext };
     }
-    const paneInstanceId = await readTmuxPaneInstanceId(paneTarget);
-    const sessionInstanceId = paneInstanceId ? '' : await readTmuxSessionInstanceId(paneSessionName);
+    const paneInstanceId = safeString(managedContext.currentTmuxPaneInstanceId).trim()
+      || await readTmuxPaneInstanceId(paneTarget);
+    const sessionInstanceId = paneInstanceId
+      ? ''
+      : safeString(managedContext.currentTmuxInstanceId).trim()
+        || await readTmuxSessionInstanceId(paneSessionName);
     if (paneInstanceId && paneInstanceId !== managedContext.invocationSessionId) {
       return { ok: false, reason: 'pane_instance_mismatch', paneTarget, paneSessionName, paneInstanceId, managedContext };
     }

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

@@ -4,6 +4,7 @@ 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';
+import type { PromptMutationAuthorization } from '../../hooks/prompt-session-provenance.js';
 
 const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
 const RALPH_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled', 'interrupted']);
@@ -19,7 +20,9 @@ interface RalphSessionResumeHooks {
 
 interface RalphSessionResumeParams {
   stateDir: string;
-  payloadSessionId: string;
+  authorization?: PromptMutationAuthorization;
+  /** Worker-only legacy identity; leader resume requires authorization. */
+  payloadSessionId?: string;
   payloadThreadId?: string;
   env?: NodeJS.ProcessEnv;
   hooks?: RalphSessionResumeHooks;
@@ -210,25 +213,6 @@ async function markRalphStateAbandoned(
   });
 }
 
-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) {
-    const sessionId = safeString(candidate).trim();
-    if (SESSION_ID_PATTERN.test(sessionId)) return sessionId;
-  }
-  return '';
-}
-
-async function readCurrentOmxSessionId(stateDir: string, env: NodeJS.ProcessEnv = process.env): Promise<string> {
-  const envSessionId = readSessionIdFromEnvironment(env);
-  if (envSessionId) return envSessionId;
-
-  const session = await readJson(join(stateDir, 'session.json'));
-  if (!session || typeof session !== 'object') return '';
-  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;
@@ -249,8 +233,9 @@ function bindCurrentPane(state: Record<string, unknown>, nowIso: string, env: No
 async function scanMatchingRalphCandidates(
   stateDir: string,
   currentOmxSessionId: string,
-  payloadSessionId: string,
+  ownerCodexSessionId: string,
   payloadThreadId: string,
+  allowedStorageSessionIds: readonly string[],
   env: NodeJS.ProcessEnv = process.env,
 ): Promise<{ candidates: RalphStateCandidate[]; abandonedCount: number }> {
   const sessionsRoot = join(stateDir, 'sessions');
@@ -260,18 +245,15 @@ async function scanMatchingRalphCandidates(
   const matches: RalphStateCandidate[] = [];
   let abandonedCount = 0;
   for (const entry of entries) {
-    if (!entry.isDirectory() || !SESSION_ID_PATTERN.test(entry.name) || entry.name === currentOmxSessionId) continue;
+    if (!entry.isDirectory() || !SESSION_ID_PATTERN.test(entry.name) || entry.name === currentOmxSessionId || !allowedStorageSessionIds.includes(entry.name)) 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;
-    }
+    if (ownerSessionId !== ownerCodexSessionId) continue;
+    if (ownerThreadId && payloadThreadId && ownerThreadId !== payloadThreadId) continue;
     const freshness = await readRalphStateFreshness(path, state, env);
     if (freshness.stale) {
       await markRalphStateAbandoned(path, state, freshness);
@@ -289,21 +271,29 @@ async function scanMatchingRalphCandidates(
 
 export async function reconcileRalphSessionResume({
   stateDir,
-  payloadSessionId,
+  authorization,
   payloadThreadId = '',
   env = process.env,
   hooks,
 }: RalphSessionResumeParams): Promise<RalphSessionResumeResult> {
+  if (!authorization) {
+    return {
+      currentOmxSessionId: '',
+      resumed: false,
+      updatedCurrentOwner: false,
+      reason: 'authorization_missing',
+    };
+  }
   const lockedResult = await withRalphResumeLock(stateDir, async () => {
     await hooks?.afterLockAcquired?.();
 
-    const currentOmxSessionId = await readCurrentOmxSessionId(stateDir, env);
-    if (!currentOmxSessionId) {
+    const currentOmxSessionId = authorization.targetSessionId;
+    if (!SESSION_ID_PATTERN.test(currentOmxSessionId) || !authorization.allowedStorageSessionIds.includes(currentOmxSessionId)) {
       return {
         currentOmxSessionId: '',
         resumed: false,
         updatedCurrentOwner: false,
-        reason: 'current_omx_session_missing',
+        reason: 'current_omx_session_unauthorized',
       };
     }
 
@@ -315,6 +305,16 @@ export async function reconcileRalphSessionResume({
       : null;
     const nowIso = new Date().toISOString();
 
+    const currentOwnerCodexSessionId = safeString(currentRalphState?.owner_codex_session_id).trim();
+    if (currentRalphState && currentOwnerCodexSessionId && currentOwnerCodexSessionId !== authorization.ownerCodexSessionId) {
+      return {
+        currentOmxSessionId,
+        resumed: false,
+        updatedCurrentOwner: false,
+        reason: 'current_ralph_owner_unauthorized',
+        targetPath: currentRalphPath,
+      };
+    }
     if (currentRalphState && currentRalphState.active === true) {
       const freshness = await readRalphStateFreshness(currentRalphPath, currentRalphState, env);
       if (freshness.stale) {
@@ -335,8 +335,8 @@ export async function reconcileRalphSessionResume({
         updated.owner_omx_session_id = currentOmxSessionId;
         changed = true;
       }
-      if (payloadSessionId && !safeString(updated.owner_codex_session_id).trim()) {
-        updated.owner_codex_session_id = payloadSessionId;
+      if (!safeString(updated.owner_codex_session_id).trim()) {
+        updated.owner_codex_session_id = authorization.ownerCodexSessionId;
         changed = true;
       }
       if (
@@ -382,14 +382,14 @@ export async function reconcileRalphSessionResume({
       };
     }
 
-    const normalizedPayloadSessionId = safeString(payloadSessionId).trim();
+    const normalizedPayloadSessionId = authorization.ownerCodexSessionId;
     const normalizedPayloadThreadId = safeString(payloadThreadId).trim();
-    if (!normalizedPayloadSessionId && !normalizedPayloadThreadId) {
+    if (!normalizedPayloadSessionId) {
       return {
         currentOmxSessionId,
         resumed: false,
         updatedCurrentOwner: false,
-        reason: 'payload_codex_identity_missing',
+        reason: 'authorized_owner_missing',
       };
     }
 
@@ -398,6 +398,7 @@ export async function reconcileRalphSessionResume({
       currentOmxSessionId,
       normalizedPayloadSessionId,
       normalizedPayloadThreadId,
+      authorization.allowedStorageSessionIds,
       env,
     );
     if (candidates.length !== 1) {