oh-my-codex 0.20.1 → 0.20.2

package/src/scripts/notify-fallback-watcher.ts

@@ -2,7 +2,7 @@
 
 import { existsSync } from 'fs';
 import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'fs/promises';
-import { spawnSync } from 'child_process';
+import { spawn, type ChildProcess } from 'child_process';
 import { dirname, join, resolve } from 'path';
 import { homedir } from 'os';
 import { StringDecoder } from 'string_decoder';
@@ -39,6 +39,7 @@ import { sameFilePath } from '../utils/paths.js';
 import { validateSessionId } from '../mcp/state-paths.js';
 import { TEAM_NAME_SAFE_PATTERN } from '../team/contracts.js';
 import { shouldContinueRun } from '../runtime/run-loop.js';
+import { deliverNotifyFallback, compactNotifyFallbackDeliveries, NOTIFY_FALLBACK_LEASE_MS } from './notify-fallback-delivery.js';
 
 function argValue(name: string, fallback = ''): string {
   const idx = process.argv.indexOf(name);
@@ -132,15 +133,18 @@ const parentPid = Math.trunc(asNumber(argValue('--parent-pid', String(process.pp
 const startedAt = Date.now();
 const fileWindowMs = runOnce ? 15000 : 30000;
 const defaultMaxLifetimeMs = 6 * 60 * 60 * 1000;
-const maxLifetimeMs = runOnce
-  ? 0
-  : Math.max(
-    pollMs,
-    asNumber(
-      argValue('--max-lifetime-ms', process.env.OMX_NOTIFY_FALLBACK_MAX_LIFETIME_MS || String(defaultMaxLifetimeMs)),
-      defaultMaxLifetimeMs
-    )
-  );
+const requestedMaxLifetimeMs = asNumber(
+  argValue('--max-lifetime-ms', process.env.OMX_NOTIFY_FALLBACK_MAX_LIFETIME_MS || String(defaultMaxLifetimeMs)),
+  defaultMaxLifetimeMs,
+);
+const configuredMaxLifetimeMs = Number.isSafeInteger(requestedMaxLifetimeMs) && requestedMaxLifetimeMs > 0
+  ? requestedMaxLifetimeMs
+  : defaultMaxLifetimeMs;
+const maxLifetimeMs = runOnce ? 0 : Math.max(pollMs, configuredMaxLifetimeMs);
+const authorityLifetimeMs = runOnce
+  ? NOTIFY_FALLBACK_LEASE_MS
+  : Math.min(Math.max(pollMs, configuredMaxLifetimeMs), 24 * 60 * 60 * 1000);
+const authorityDeadlineAtMs = startedAt + authorityLifetimeMs;
 
 const runtimeRoot = resolve(process.env.OMX_ROOT || process.env.OMX_STATE_ROOT || cwd);
 const omxDir = join(runtimeRoot, '.omx');
@@ -284,6 +288,28 @@ const fileState = new Map<string, WatcherFileMeta>();
 const seenTurnKeys = new Set<string>();
 let stopping = false;
 let shutdownPromise: Promise<void> | null = null;
+let activeNotifyHookChild: ChildProcess | null = null;
+let activeNotifyHookClose: Promise<{ status: number | null; signal: string | null }> | null = null;
+let activeNotifyHookTermination: Promise<boolean> | null = null;
+let activeDeliveryPromise: Promise<unknown> | null = null;
+async function terminateActiveNotifyHookChild(): Promise<boolean> {
+  if (activeNotifyHookTermination) return activeNotifyHookTermination;
+  const child = activeNotifyHookChild;
+  const close = activeNotifyHookClose;
+  if (!child || !close) return true;
+  activeNotifyHookTermination = (async () => {
+    child.kill('SIGTERM');
+    const termResult = await Promise.race([close.then(() => true), sleep(1_000).then(() => false)]);
+    if (termResult) return true;
+    child.kill('SIGKILL');
+    return Promise.race([close.then(() => true), sleep(2_000).then(() => false)]);
+  })();
+  try {
+    return await activeNotifyHookTermination;
+  } finally {
+    activeNotifyHookTermination = null;
+  }
+}
 const dispatchTickMax = Math.max(1, asNumber(argValue('--dispatch-max-per-tick', '5'), 5));
 let dispatchDrainRuns = 0;
 let lastDispatchDrain: DispatchDrainState = {
@@ -1485,6 +1511,8 @@ async function requestShutdown(reason: string, signal: string | null = null): Pr
   if (shutdownPromise) return shutdownPromise;
   stopping = true;
   shutdownPromise = (async () => {
+    await terminateActiveNotifyHookChild();
+    await activeDeliveryPromise?.catch(() => undefined);
     await writeState({ stop_reason: reason, stop_signal: signal, stopping: true });
     await eventLog({
       type: 'watcher_stop',
@@ -1633,10 +1661,13 @@ function turnKey(threadId: string, turnId: string): string {
   return `${threadId || 'no-thread'}|${turnId || 'no-turn'}`;
 }
 
-function buildNotifyPayload(threadId: string, turnId: string, lastMessage: string): Record<string, unknown> {
+async function buildNotifyPayload(threadId: string, turnId: string, lastMessage: string): Promise<Record<string, unknown>> {
+  const session = await readSessionState(cwd).catch(() => null);
+  const payloadSessionId = normalizeValidSessionId(session?.session_id) || threadId;
   return {
     type: 'agent-turn-complete',
     cwd,
+    session_id: payloadSessionId,
     'thread-id': threadId,
     'turn-id': turnId,
     'input-messages': ['[notify-fallback] synthesized from rollout task_complete'],
@@ -1645,25 +1676,48 @@ function buildNotifyPayload(threadId: string, turnId: string, lastMessage: strin
   };
 }
 
-async function invokeNotifyHook(payload: Record<string, unknown>, filePath: string): Promise<void> {
-  const result = spawnSync(process.execPath, [notifyScript, JSON.stringify(payload)], {
-    cwd,
-    encoding: 'utf-8',
-    env: {
-      ...process.env,
-      OMX_NOTIFY_HOOK_TRUSTED_MANAGED_CWD: cwd,
-    },
-    windowsHide: true,
-  });
-  const ok = result.status === 0;
-  await eventLog({
-    type: 'fallback_notify',
-    ok,
-    thread_id: (payload as Record<string, string>)['thread-id'],
-    turn_id: (payload as Record<string, string>)['turn-id'],
-    file: filePath,
-    reason: ok ? 'sent' : 'notify_hook_failed',
-    error: ok ? undefined : (result.stderr || result.stdout || '').trim().slice(0, 240),
+async function invokeNotifyHook(payload: Record<string, unknown>): Promise<{ spawned: boolean; childPid?: number; status?: number | null; signal?: string | null; error?: unknown; timedOut?: boolean; authorityDeadline?: boolean; terminationUnconfirmed?: boolean }> {
+  return new Promise((resolveInvoke) => {
+    let settled = false;
+    let spawned = false;
+    let timedOut = false;
+    let deadlineTimedOut = false;
+    const child = spawn(process.execPath, [notifyScript, JSON.stringify(payload)], {
+      cwd,
+      stdio: 'ignore',
+      env: { ...process.env, OMX_NOTIFY_HOOK_TRUSTED_MANAGED_CWD: cwd },
+      windowsHide: true,
+    });
+    const close = new Promise<{ status: number | null; signal: string | null }>((resolveClose) => {
+      child.once('close', (status, signal) => resolveClose({ status, signal }));
+    });
+    activeNotifyHookChild = child;
+    activeNotifyHookClose = close;
+    const finish = (result: { spawned: boolean; childPid?: number; status?: number | null; signal?: string | null; error?: unknown; timedOut?: boolean; authorityDeadline?: boolean; terminationUnconfirmed?: boolean }) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(hookTimeout);
+      clearTimeout(deadlineTimeout);
+      if (activeNotifyHookChild === child) {
+        activeNotifyHookChild = null;
+        activeNotifyHookClose = null;
+        activeNotifyHookTermination = null;
+      }
+      resolveInvoke(result);
+    };
+    const stopForTimeout = async (isDeadline: boolean) => {
+      if (settled) return;
+      if (isDeadline) deadlineTimedOut = true;
+      else timedOut = true;
+      const confirmed = await terminateActiveNotifyHookChild();
+      const closed = await Promise.race([close, sleep(2_000).then(() => null)]);
+      finish({ spawned: true, childPid: child.pid, status: closed?.status ?? null, signal: closed?.signal ?? null, timedOut, authorityDeadline: deadlineTimedOut, terminationUnconfirmed: !confirmed || closed === null, error: isDeadline ? new Error('authority_deadline') : new Error('hook_timeout') });
+    };
+    const hookTimeout = setTimeout(() => { void stopForTimeout(false); }, 10_000);
+    const deadlineTimeout = setTimeout(() => { void stopForTimeout(true); }, Math.max(0, authorityDeadlineAtMs - Date.now()));
+    child.once('error', (error) => finish({ spawned, childPid: child.pid, error }));
+    child.once('spawn', () => { spawned = true; });
+    void close.then(({ status, signal }) => finish({ spawned, childPid: child.pid, status, signal }));
   });
 }
 
@@ -1677,23 +1731,58 @@ async function processLine(meta: WatcherFileMeta, line: string, filePath: string
 
   if (!parsed || parsed.type !== 'event_msg' || !parsed.payload) return;
   if ((parsed.payload as Record<string, unknown>).type !== 'task_complete') return;
-
   const turnId = safeString((parsed.payload as Record<string, unknown>).turn_id);
-  if (!turnId) return;
-
   const evtTs = Date.parse(safeString(parsed.timestamp));
-  if (Number.isFinite(evtTs) && evtTs < startedAt - 3000) return;
-
   const key = turnKey(meta.threadId, turnId);
+  if (!turnId || !Number.isFinite(evtTs) || evtTs > Date.now() + 5 * 60 * 1000 || evtTs < startedAt - 3000) {
+    seenTurnKeys.add(key);
+    return;
+  }
   if (seenTurnKeys.has(key)) return;
-  seenTurnKeys.add(key);
-
-  const payload = buildNotifyPayload(
+  const payload = await buildNotifyPayload(
     meta.threadId,
     turnId,
-    safeString((parsed.payload as Record<string, unknown>).last_agent_message)
+    safeString((parsed.payload as Record<string, unknown>).last_agent_message),
   );
-  await invokeNotifyHook(payload, filePath);
+  let spawnResult: Awaited<ReturnType<typeof invokeNotifyHook>> | undefined;
+  const deliveryPromise = deliverNotifyFallback({
+    stateDir,
+    threadId: meta.threadId,
+    turnId,
+    eventTimestampMs: evtTs,
+    rolloutPath: filePath,
+    watcherMode: runOnce ? 'once' : 'persistent',
+    deadlineAtMs: authorityDeadlineAtMs,
+    stopping: () => stopping,
+    spawnHook: async () => {
+      spawnResult = await invokeNotifyHook(payload);
+      return spawnResult;
+    },
+  });
+  activeDeliveryPromise = deliveryPromise;
+  const result = await deliveryPromise.finally(() => {
+    if (activeDeliveryPromise === deliveryPromise) activeDeliveryPromise = null;
+  });
+  if (result.kind === 'retry_eligible' && !stopping && Date.now() + 250 < authorityDeadlineAtMs) {
+    await sleep(250);
+    await processLine(meta, line, filePath);
+    return;
+  }
+  seenTurnKeys.add(key);
+  if (result.kind !== 'acquired_effect') {
+    await eventLog({ type: 'fallback_notify_claim', thread_id: meta.threadId, turn_id: turnId, file: filePath, reason: 'reason' in result ? result.reason : result.kind, attempt: 'attempt' in result ? result.attempt : undefined });
+  }
+  if (spawnResult?.spawned) {
+    await eventLog({
+      type: 'fallback_notify',
+      ok: spawnResult.status === 0,
+      thread_id: meta.threadId,
+      turn_id: turnId,
+      file: filePath,
+      reason: spawnResult.status === 0 ? 'sent' : 'notify_hook_failed',
+      error: spawnResult.status === 0 ? undefined : String(spawnResult.error || '').slice(0, 240),
+    });
+  }
 }
 
 async function ensureTrackedFiles(): Promise<void> {
@@ -1916,6 +2005,9 @@ async function pumpTeamControlPlaneTick(): Promise<CycleActivitySummary> {
 
 
 async function runWatcherCycle(): Promise<number> {
+  await compactNotifyFallbackDeliveries(stateDir).catch(async (error) => {
+    await eventLog({ type: 'fallback_notify_claim', reason: 'compaction_io_skip', error: error instanceof Error ? error.message : String(error) });
+  });
   let processedRolloutCount = 0;
   if (authorityOnly) {
     const authorityBackoff = await resolveAuthorityPrimaryWatcherHealth();

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,16 @@ export async function capturePane(paneId, lines = 10) {
   }
 }
 
-export async function resolveNudgePaneTarget(stateDir: any, cwd = '', payload: any = undefined) {
+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 +580,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 +594,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 +613,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 +627,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,7 +638,7 @@ 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 paneId = await resolveNudgePaneTarget(stateDir, cwd, payload, context);
 
     let detected = detectStallPattern(lastMessage, config.patterns, skillState?.phase);
     let source = 'payload';

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 };
     }