oh-my-codex 0.20.1 → 0.20.2

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) {

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

@@ -2,7 +2,7 @@
  * State file I/O helpers for notify-hook modules.
  */
 
-import { mkdir, readFile, readdir, writeFile } from 'fs/promises';
+import { mkdir, readFile, readdir, stat, writeFile } from 'fs/promises';
 import { dirname, join } from 'path';
 import { validateSessionId } from '../../mcp/state-paths.js';
 import { asNumber, safeString } from './utils.js';
@@ -23,27 +23,74 @@ function isSafeStateFileName(fileName: string): boolean {
     && !fileName.includes('\\');
 }
 
-interface SessionMetadata {
+export interface SessionMetadata {
   sessionId?: string;
-  nativeAliases: string[];
+  aliases: string[];
+  status: 'missing' | 'unusable' | 'usable';
 }
 
 async function readSessionMetadataFromBaseStateDir(baseStateDir: string): Promise<SessionMetadata> {
-  const session = await readJsonIfExists(join(baseStateDir, 'session.json'), null);
+  let session: any;
+  try {
+    session = JSON.parse(await readFile(join(baseStateDir, 'session.json'), 'utf-8'));
+  } catch (error: any) {
+    return { aliases: [], status: error?.code === 'ENOENT' ? 'missing' : 'unusable' };
+  }
+  if (!session || typeof session !== 'object' || Array.isArray(session)) {
+    return { aliases: [], status: 'unusable' };
+  }
+
   let sessionId: string | undefined;
   try {
-    sessionId = validateSessionId(session?.session_id);
+    sessionId = validateSessionId(session.session_id);
   } catch {
-    sessionId = undefined;
+    return { aliases: [], status: 'unusable' };
   }
-  const nativeAliases = [
-    session?.native_session_id,
-    session?.codex_session_id,
-    session?.previous_native_session_id,
+  if (!sessionId) return { aliases: [], status: 'unusable' };
+
+  const aliases = [
+    session.native_session_id,
+    session.codex_session_id,
+    session.previous_native_session_id,
+    session.owner_omx_session_id,
   ]
     .map((value) => safeString(value).trim())
-    .filter(Boolean);
-  return { sessionId, nativeAliases: [...new Set(nativeAliases)] };
+    .filter((value) => {
+      try {
+        return Boolean(validateSessionId(value));
+      } catch {
+        return false;
+      }
+    });
+  return { sessionId, aliases: [...new Set(aliases)], status: 'usable' };
+}
+
+export async function readNotifySessionMetadata(baseStateDir: string): Promise<SessionMetadata> {
+  return readSessionMetadataFromBaseStateDir(baseStateDir);
+}
+
+function readOmxSessionIdFromEnvironment(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const candidate = safeString(env.OMX_SESSION_ID).trim();
+  if (!candidate) return undefined;
+  try {
+    return validateSessionId(candidate);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Neutral fact for the provenance evaluator; it never interprets fork policy. */
+
+export async function hasExistingScopedSessionDir(baseStateDir: string, sessionId: string): Promise<boolean> {
+  try {
+    return (await stat(join(baseStateDir, 'sessions', sessionId))).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function getOmxSessionIdFromEnvironment(): string | undefined {
+  return readOmxSessionIdFromEnvironment();
 }
 
 function readSessionIdFromEnvironment(): string | undefined {
@@ -63,7 +110,7 @@ function readSessionIdFromEnvironment(): string | undefined {
 
 function resolveCanonicalSessionId(candidate: string | undefined, metadata: SessionMetadata): string | undefined {
   if (!candidate) return undefined;
-  return metadata.sessionId && metadata.nativeAliases.includes(candidate)
+  return metadata.sessionId && metadata.aliases.includes(candidate)
     ? metadata.sessionId
     : candidate;
 }
@@ -117,6 +164,26 @@ export async function getScopedStateDirsForCurrentSession(
   return resolveBaseScopedStateDirs(baseStateDir, explicitSessionId, options);
 }
 
+export interface NotifyStateScope {
+  readonly targetSessionId: string;
+  readonly ownerCodexSessionId: string;
+  readonly allowedStorageSessionIds: readonly string[];
+}
+
+export async function getScopedStatePathAtScope(
+  baseStateDir: string,
+  fileName: string,
+  scope: NotifyStateScope,
+): Promise<string> {
+  if (!isSafeStateFileName(fileName)) {
+    throw new Error(`unsafe state file name: ${fileName}`);
+  }
+  if (!scope.allowedStorageSessionIds.includes(scope.targetSessionId)) {
+    throw new Error('notify state scope target is unauthorized');
+  }
+  return join(baseStateDir, 'sessions', scope.targetSessionId, fileName);
+}
+
 export async function getScopedStatePath(
   baseStateDir: string,
   fileName: string,
@@ -161,6 +228,26 @@ export async function writeScopedJson(
   await writeFile(targetPath, JSON.stringify(value, null, 2));
 }
 
+export async function readScopedJsonAtScope(
+  baseStateDir: string,
+  fileName: string,
+  scope: NotifyStateScope,
+  fallback: any,
+): Promise<any> {
+  return readJsonIfExists(await getScopedStatePathAtScope(baseStateDir, fileName, scope), fallback);
+}
+
+export async function writeScopedJsonAtScope(
+  baseStateDir: string,
+  fileName: string,
+  scope: NotifyStateScope,
+  value: unknown,
+): Promise<void> {
+  const targetPath = await getScopedStatePathAtScope(baseStateDir, fileName, scope);
+  await mkdir(dirname(targetPath), { recursive: true });
+  await writeFile(targetPath, JSON.stringify(value, null, 2));
+}
+
 export function normalizeTmuxState(raw: any): any {
   if (!raw || typeof raw !== 'object') {
     return {

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

@@ -19,7 +19,14 @@ import {
 } from './state-io.js';
 import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
-import { resolveInvocationSessionId, resolveManagedCurrentPane, resolveManagedSessionContext, verifyManagedPaneTarget } from './managed-tmux.js';
+import {
+  resolveInvocationSessionId,
+  resolveManagedCurrentPane,
+  resolveManagedCurrentPaneAtPromptContext,
+  resolveManagedSessionContext,
+  verifyManagedPaneTarget,
+  verifyManagedPaneTargetAtPromptContext,
+} from './managed-tmux.js';
 import { evaluatePaneInjectionReadiness, mapPaneInjectionReadinessReason, sendPaneInput } from './team-tmux-guard.js';
 import { listActiveSkills, readVisibleSkillActiveStateForStateDir } from '../../state/skill-active.js';
 import {
@@ -28,6 +35,7 @@ import {
   evaluateInjectionGuards,
   buildSendKeysArgv,
 } from '../tmux-hook-engine.js';
+import type { ResolvedPromptTurnContext } from '../../hooks/prompt-session-provenance.js';
 
 function isHudPaneStartCommand(startCommand: any): boolean {
   return /\bomx\b.*\bhud\b.*--watch/i.test(safeString(startCommand));
@@ -404,16 +412,21 @@ export async function resolvePaneTarget(target: any, expectedCwd: any, modePane:
   }
 }
 
-export async function handleTmuxInjection({
-  payload,
-  cwd,
-  stateDir,
-  logsDir,
-}: any): Promise<void> {
+export async function handleTmuxInjection({ payload, cwd, stateDir, logsDir, context = null }: {
+  payload: any;
+  cwd: string;
+  stateDir: string;
+  logsDir: string;
+  context?: ResolvedPromptTurnContext | null;
+}): Promise<void> {
   const omxDir = join(cwd, '.omx');
   const configPath = join(omxDir, 'tmux-hook.json');
   const hookStatePath = join(stateDir, 'tmux-hook-state.json');
   const nowIso = new Date().toISOString();
+  if (context && context.status !== 'authorized') return;
+  const ownershipPayload = context?.status === 'authorized'
+    ? { ...payload, session_id: context.authorization.ownerCodexSessionId, 'session-id': context.authorization.ownerCodexSessionId }
+    : payload;
   const now = Date.now();
 
   const rawConfig = await readJsonIfExists(configPath, null);
@@ -429,7 +442,7 @@ export async function handleTmuxInjection({
   const sourceText = inputMessages.join('\n');
   const state = normalizeTmuxState(await readJsonIfExists(hookStatePath, null));
   state.recent_keys = pruneRecentKeys(state.recent_keys, now);
-  const canonicalModeState = await readVisibleAllowedModes(cwd, stateDir, payload, config.allowed_modes).catch(() => ({
+  const canonicalModeState = await readVisibleAllowedModes(cwd, stateDir, ownershipPayload, config.allowed_modes).catch(() => ({
     canonicalPresent: false,
     activeSkillCount: 0,
     allowedSet: null,
@@ -547,7 +560,9 @@ export async function handleTmuxInjection({
     turnId,
     timestamp: nowIso,
   }), sourceText);
-  const managedCurrentPane = await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker: false });
+  const managedCurrentPane = context
+    ? await resolveManagedCurrentPaneAtPromptContext(cwd, context)
+    : await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker: false });
   if (modePane && managedCurrentPane && modePane !== managedCurrentPane) {
     state.last_reason = 'mode_pane_current_pane_mismatch';
     state.last_event_at = nowIso;
@@ -564,12 +579,12 @@ export async function handleTmuxInjection({
 
   const preferredPaneTarget = modePane || managedCurrentPane;
   let resolution = preferredModePane
-    ? await resolvePaneTarget({ type: 'pane', value: preferredModePane.pane }, cwd, preferredModePane.pane, cwd, payload)
+    ? await resolvePaneTarget({ type: 'pane', value: preferredModePane.pane }, cwd, preferredModePane.pane, cwd, ownershipPayload)
     : preferredPaneTarget
-      ? await resolvePaneTarget({ type: 'pane', value: preferredPaneTarget }, cwd, '', cwd, payload)
-      : await resolvePaneTarget(config.target, cwd, modePane, cwd, payload);
+      ? await resolvePaneTarget({ type: 'pane', value: preferredPaneTarget }, cwd, '', cwd, ownershipPayload)
+      : await resolvePaneTarget(config.target, cwd, modePane, cwd, ownershipPayload);
   if (!resolution.paneTarget && preferredPaneTarget) {
-    resolution = await resolvePaneTarget(config.target, cwd, modePane, cwd, payload);
+    resolution = await resolvePaneTarget(config.target, cwd, modePane, cwd, ownershipPayload);
   }
   if (!resolution.paneTarget) {
     state.last_reason = resolution.reason;
@@ -586,14 +601,16 @@ export async function handleTmuxInjection({
   }
   const paneTarget = resolution.paneTarget;
 
-  const ownership = await validateResolvedInjectionOwnership({
-    paneTarget,
-    cwd,
-    payload,
-    modeState,
-    modePane,
-    managedCurrentPane,
-  });
+  const ownership = context
+    ? await verifyManagedPaneTargetAtPromptContext(paneTarget, cwd, context)
+    : await validateResolvedInjectionOwnership({
+      paneTarget,
+      cwd,
+      payload,
+      modeState,
+      modePane,
+      managedCurrentPane,
+    });
   if (!ownership.ok) {
     state.last_reason = ownership.reason;
     state.last_event_at = nowIso;

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

@@ -84,7 +84,15 @@ export function parseVisualVerdict(text: any): { verdict: string; raw: string }
  *
  * Module import failure is handled by the caller in notify-hook.ts.
  */
-export async function maybePersistVisualVerdict({ cwd, payload, stateDir, logsDir, sessionId, turnId }: any): Promise<void> {
+export async function maybePersistVisualVerdict({
+  cwd,
+  payload,
+  stateDir,
+  logsDir,
+  sessionId,
+  turnId,
+  persistRuntimeFeedback = true,
+}: any): Promise<void> {
   const output = safeString(
     payload?.['last-assistant-message'] || payload?.last_assistant_message || '',
   );
@@ -92,17 +100,19 @@ 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, stateDir });
-  } catch (err: any) {
-    await logNotifyHookEvent(logsDir, {
-      timestamp: new Date().toISOString(),
-      level: 'warn',
-      type: 'visual_runtime_feedback_persist_failure',
-      error: err?.message || String(err),
-      session_id: sessionId,
-      turn_id: turnId,
-    });
+  if (persistRuntimeFeedback) {
+    try {
+      await maybePersistRuntimeVisualFeedback({ cwd, output, sessionId, stateDir });
+    } catch (err: any) {
+      await logNotifyHookEvent(logsDir, {
+        timestamp: new Date().toISOString(),
+        level: 'warn',
+        type: 'visual_runtime_feedback_persist_failure',
+        error: err?.message || String(err),
+        session_id: sessionId,
+        turn_id: turnId,
+      });
+    }
   }
 
   const parsed = parseVisualVerdict(output);