oh-my-codex 0.11.11 → 0.11.13

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

@@ -17,13 +17,13 @@ import {
 } from './state-io.js';
 import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
+import { resolveManagedCurrentPane, resolveManagedSessionContext, verifyManagedPaneTarget } from './managed-tmux.js';
 import { evaluatePaneInjectionReadiness, mapPaneInjectionReadinessReason, sendPaneInput } from './team-tmux-guard.js';
 import {
   normalizeTmuxHookConfig,
   pickActiveMode,
   evaluateInjectionGuards,
   buildSendKeysArgv,
-  resolveCodexPane,
 } from '../tmux-hook-engine.js';
 
 function isHudPaneStartCommand(startCommand: any): boolean {
@@ -96,6 +96,25 @@ async function resolveCanonicalPaneFromPaneTarget(paneTarget: any, expectedCwd:
   return finalizeResolvedPane(healedPaneId, 'healed_hud_pane_target', expectedCwd);
 }
 
+async function resolvePreferredModePane(stateDir: string, allowedModes: string[]): Promise<{ mode: string; state: any; pane: string } | null> {
+  const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir).catch(() => [stateDir]);
+  const dirs = [...scopedDirs];
+  if (!dirs.map((dir) => resolvePath(dir)).includes(resolvePath(stateDir))) {
+    dirs.push(stateDir);
+  }
+  for (const dir of dirs) {
+    for (const mode of allowedModes || []) {
+      const path = join(dir, `${mode}-state.json`);
+      const parsed = await readJsonIfExists(path, null);
+      const pane = safeString(parsed?.tmux_pane_id || '').trim();
+      if (parsed?.active && pane) {
+        return { mode, state: parsed, pane };
+      }
+    }
+  }
+  return null;
+}
+
 export async function resolveSessionToPane(sessionName: any): Promise<string | null> {
   const result = await runProcess('tmux', ['list-panes', '-t', sessionName, '-F', '#{pane_id}\t#{pane_active}\t#{pane_current_command}\t#{pane_start_command}']);
   const rows = result.stdout
@@ -128,27 +147,35 @@ export async function resolveSessionToPane(sessionName: any): Promise<string | n
   return nonHudRows[0]?.paneId || null;
 }
 
-export async function resolvePaneTarget(target: any, fallbackPane: any, expectedCwd: any, modePane: any): Promise<any> {
-  const canonicalFallbackPane = safeString(fallbackPane).trim();
-  if (canonicalFallbackPane) {
-    try {
-      return await finalizeResolvedPane(canonicalFallbackPane, 'fallback_current_pane', expectedCwd);
-    } catch {
-      // Fall through to mode/config probes
-    }
+export async function resolvePaneTarget(target: any, expectedCwd: any, modePane: any, cwd: string, payload: any): Promise<any> {
+  const requiresManagedOwnership = safeString(cwd).trim() !== '' && safeString(payload?.session_id || payload?.['session-id'] || process.env.OMX_SESSION_ID || '').trim() !== '';
+  const managedContext = requiresManagedOwnership
+    ? await resolveManagedSessionContext(cwd, payload, { allowTeamWorker: false })
+    : { managed: false, reason: 'not_required', invocationSessionId: '', sessionState: null, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
+  if (requiresManagedOwnership && !managedContext.managed) {
+    return { paneTarget: null, reason: managedContext.reason || 'unmanaged_session' };
   }
 
-  if (modePane) {
+  const canonicalModePane = safeString(modePane).trim();
+  if (canonicalModePane) {
     try {
-      const resolved = await resolveCanonicalPaneFromPaneTarget(modePane, expectedCwd);
+      const resolved = await resolveCanonicalPaneFromPaneTarget(canonicalModePane, expectedCwd);
       if (resolved.paneTarget) {
-        return {
-          ...resolved,
-          reason: resolved.reason === 'ok' ? 'fallback_mode_state_pane' : resolved.reason,
-        };
+        const ownership = requiresManagedOwnership
+          ? await verifyManagedPaneTarget(resolved.paneTarget, cwd, payload, { allowTeamWorker: false })
+          : { ok: true };
+        if (ownership.ok) {
+          return {
+            ...resolved,
+            reason: resolved.reason === 'ok' ? 'fallback_mode_state_pane' : resolved.reason,
+            source: 'mode_state',
+            healTarget: true,
+          };
+        }
+        return { paneTarget: null, reason: ownership.reason || 'pane_not_managed_session' };
       }
     } catch {
-      // Fall through to config probes
+      // Fall through to explicit config target
     }
   }
 
@@ -157,20 +184,52 @@ export async function resolvePaneTarget(target: any, fallbackPane: any, expected
   if (target.type === 'pane') {
     try {
       const resolved = await resolveCanonicalPaneFromPaneTarget(target.value, expectedCwd);
-      if (resolved.paneTarget) return resolved;
-    } catch {
-      // Fall through
-    }
-  } else {
-    try {
-      const paneId = await resolveSessionToPane(target.value);
-      if (paneId) return await finalizeResolvedPane(paneId, 'ok', expectedCwd);
+      if (resolved.paneTarget) {
+        const ownership = requiresManagedOwnership
+          ? await verifyManagedPaneTarget(resolved.paneTarget, cwd, payload, { allowTeamWorker: false })
+          : { ok: true };
+        if (ownership.ok) {
+          return {
+            ...resolved,
+            reason: resolved.reason === 'ok' ? 'explicit_pane_target' : resolved.reason,
+            source: 'explicit_target',
+            healTarget: true,
+          };
+        }
+        return { paneTarget: null, reason: ownership.reason || 'pane_not_managed_session' };
+      }
     } catch {
       // Fall through
     }
+    return { paneTarget: null, reason: 'target_not_found' };
   }
 
-  return { paneTarget: null, reason: 'target_not_found' };
+  try {
+    if (!requiresManagedOwnership) return { paneTarget: null, reason: 'target_session_requires_managed_context' };
+    const explicitSessionTarget = safeString(target.value).trim();
+    const expectedSessionTarget = safeString(managedContext.expectedTmuxSessionName).trim();
+    const sessionIdTarget = safeString(managedContext.invocationSessionId).trim();
+    const stateSessionTarget = safeString(managedContext.sessionState?.session_id).trim();
+    const allowedSessionTargets = new Set([expectedSessionTarget, sessionIdTarget, stateSessionTarget].filter(Boolean));
+    if (!allowedSessionTargets.has(explicitSessionTarget)) {
+      return { paneTarget: null, reason: 'target_session_not_managed' };
+    }
+    const paneId = await resolveSessionToPane(expectedSessionTarget);
+    if (!paneId) return { paneTarget: null, reason: 'target_not_found' };
+    const resolved = await finalizeResolvedPane(paneId, 'managed_session_target', expectedCwd);
+    if (!resolved.paneTarget) return resolved;
+    const ownership = await verifyManagedPaneTarget(resolved.paneTarget, cwd, payload, { allowTeamWorker: false });
+    if (!ownership.ok) {
+      return { paneTarget: null, reason: ownership.reason || 'pane_not_managed_session' };
+    }
+    return {
+      ...resolved,
+      source: 'explicit_target',
+      healTarget: true,
+    };
+  } catch {
+    return { paneTarget: null, reason: 'target_not_found' };
+  }
 }
 
 export async function handleTmuxInjection({
@@ -202,7 +261,6 @@ export async function handleTmuxInjection({
   const activeModes: string[] = [];
   const activeModeStates: Record<string, any> = {};
   const scannedStateDirs = new Set<string>();
-  const payloadSessionId = safeString(payload.session_id || payload['session-id'] || '');
   const scanActiveModeStateDirs = async (dirs: string[], preserveExisting = false) => {
     for (const scopedDir of dirs) {
       const resolvedScopedDir = resolvePath(scopedDir);
@@ -225,7 +283,7 @@ export async function handleTmuxInjection({
     }
   };
   try {
-    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir, payloadSessionId);
+    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
     await scanActiveModeStateDirs(scopedDirs);
 
     if (!pickActiveMode(activeModes, config.allowed_modes) && !scannedStateDirs.has(resolvePath(stateDir))) {
@@ -235,9 +293,10 @@ export async function handleTmuxInjection({
     // Non-fatal
   }
 
-  const mode = pickActiveMode(activeModes, config.allowed_modes);
-  const modeState = mode ? (activeModeStates[mode] || {}) : {};
-  const modePane = safeString(modeState.tmux_pane_id || '');
+  const preferredModePane = await resolvePreferredModePane(stateDir, config.allowed_modes).catch(() => null);
+  const mode = preferredModePane?.mode || pickActiveMode(activeModes, config.allowed_modes);
+  const modeState = preferredModePane?.state || (mode ? (activeModeStates[mode] || {}) : {});
+  const modePane = preferredModePane?.pane || safeString(modeState.tmux_pane_id || '');
   const preGuard = evaluateInjectionGuards({
     config,
     mode,
@@ -280,8 +339,19 @@ export async function handleTmuxInjection({
     turnId,
     timestamp: nowIso,
   }), sourceText);
-  const fallbackPane = resolveCodexPane();
-  const resolution = await resolvePaneTarget(config.target, fallbackPane, cwd, modePane);
+  const preferredPaneTarget = modePane || await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker: false });
+  let resolution = preferredModePane
+    ? await resolveCanonicalPaneFromPaneTarget(preferredModePane.pane, cwd).then((resolved) => (
+      resolved.paneTarget
+        ? { ...resolved, reason: 'fallback_mode_state_pane', source: 'mode_state', healTarget: true }
+        : resolved
+    ))
+    : preferredPaneTarget
+      ? await resolvePaneTarget({ type: 'pane', value: preferredPaneTarget }, cwd, '', cwd, payload)
+      : await resolvePaneTarget(config.target, cwd, modePane, cwd, payload);
+  if (!resolution.paneTarget && preferredPaneTarget) {
+    resolution = await resolvePaneTarget(config.target, cwd, modePane, cwd, payload);
+  }
   if (!resolution.paneTarget) {
     state.last_reason = resolution.reason;
     state.last_event_at = nowIso;
@@ -319,7 +389,7 @@ export async function handleTmuxInjection({
   }
 
   // Pane-canonical healing: persist resolved pane target so routing stops depending on session names or stale pane ids.
-  if (config.target && (config.target.type !== 'pane' || safeString(config.target.value).trim() !== paneTarget)) {
+  if (resolution.healTarget && config.target && (config.target.type !== 'pane' || safeString(config.target.value).trim() !== paneTarget)) {
     try {
       const healed = {
         ...(rawConfig && typeof rawConfig === 'object' ? rawConfig : {}),

package/src/scripts/notify-hook.ts

@@ -39,6 +39,10 @@ import { isLeaderStale, resolveLeaderStalenessThresholdMs, maybeNudgeTeamLeader
 import { drainPendingTeamDispatch } from './notify-hook/team-dispatch.js';
 import { handleTmuxInjection } from './notify-hook/tmux-injection.js';
 import { maybeAutoNudge, resolveNudgePaneTarget, isDeepInterviewStateActive } from './notify-hook/auto-nudge.js';
+import { isManagedOmxSession } from './notify-hook/managed-tmux.js';
+import { logNotifyHookEvent } from './notify-hook/log.js';
+import { reconcileRalphSessionResume } from './notify-hook/ralph-session-resume.js';
+import { sendPaneInput } from './notify-hook/team-tmux-guard.js';
 import {
   buildOperationalContext,
   deriveAssistantSignalEvents,
@@ -68,6 +72,79 @@ const RALPH_ACTIVE_PROGRESS_PHASES = new Set([
   'fixing',
 ]);
 
+const IDLE_NOTIFICATION_SUMMARY_MAX_LENGTH = 240;
+
+function summarizeIdleNotificationMessage(message: unknown): string {
+  const source = safeString(message)
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const preferred = source.at(-1) || '';
+  const normalized = preferred.replace(/\s+/g, ' ').trim();
+  if (!normalized) return '';
+  return normalized.length > IDLE_NOTIFICATION_SUMMARY_MAX_LENGTH
+    ? `${normalized.slice(0, IDLE_NOTIFICATION_SUMMARY_MAX_LENGTH - 1)}…`
+    : normalized;
+}
+
+function classifyIdleNotificationPhase(message: unknown): 'idle' | 'progress' | 'finished' | 'failed' {
+  const lower = safeString(message).toLowerCase();
+  if (!lower) return 'idle';
+
+  if (/(error|failed|exception|invalid|timed out|timeout)/i.test(lower)) {
+    return 'failed';
+  }
+
+  if ([
+    'all tests pass',
+    'build succeeded',
+    'completed',
+    'complete',
+    'done',
+    'final summary',
+    'summary',
+  ].some((pattern) => lower.includes(pattern))) {
+    return 'finished';
+  }
+
+  if ([
+    'verify',
+    'verified',
+    'verification',
+    'review',
+    'reviewed',
+    'diagnostic',
+    'typecheck',
+    'test',
+    'implement',
+    'implemented',
+    'apply patch',
+    'change',
+    'fix',
+    'update',
+    'refactor',
+    'resume',
+    'resumed',
+    'progress',
+    'continue',
+    'continued',
+  ].some((pattern) => lower.includes(pattern))) {
+    return 'progress';
+  }
+
+  return 'idle';
+}
+
+function buildIdleNotificationFingerprint(payload: Record<string, unknown>): string {
+  const lastAssistantMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
+  const summary = summarizeIdleNotificationMessage(lastAssistantMessage);
+  const phase = classifyIdleNotificationPhase(lastAssistantMessage);
+  return JSON.stringify({
+    phase,
+    ...(summary ? { summary } : {}),
+  });
+}
+
 async function main() {
   const rawPayload = process.argv[process.argv.length - 1];
   if (!rawPayload || rawPayload.startsWith('-')) {
@@ -83,6 +160,9 @@ async function main() {
 
   const cwd = payload.cwd || payload['cwd'] || process.cwd();
   const payloadSessionId = safeString(payload.session_id || payload['session-id'] || '');
+  const payloadThreadId = safeString(payload['thread-id'] || payload.thread_id || '');
+  const inputMessages = normalizeInputMessages(payload);
+  const latestUserInput = safeString(inputMessages.length > 0 ? inputMessages[inputMessages.length - 1] : '');
 
   // Team worker detection via environment variable
   const teamWorkerEnv = process.env.OMX_TEAM_WORKER; // e.g., "fix-ts/worker-1"
@@ -94,6 +174,7 @@ async function main() {
     : join(cwd, '.omx', 'state');
   const logsDir = join(cwd, '.omx', 'logs');
   const omxDir = join(cwd, '.omx');
+  let currentOmxSessionId = '';
 
   // Ensure directories exist
   await mkdir(logsDir, { recursive: true }).catch(() => {});
@@ -158,11 +239,45 @@ async function main() {
   const logFile = join(logsDir, `turns-${new Date().toISOString().split('T')[0]}.jsonl`);
   await appendFile(logFile, JSON.stringify(logEntry) + '\n').catch(() => {});
 
+  // Reconcile Ralph ownership for same-Codex-session continuation before
+  // lifecycle counters or injection read the active scope.
+  if (!isTeamWorker) {
+    try {
+      const resumeResult = await reconcileRalphSessionResume({
+        stateDir,
+        payloadSessionId,
+        payloadThreadId,
+      });
+      currentOmxSessionId = resumeResult.currentOmxSessionId;
+      if (resumeResult.resumed || resumeResult.updatedCurrentOwner) {
+        await logNotifyHookEvent(logsDir, {
+          timestamp: new Date().toISOString(),
+          type: 'ralph_session_resume',
+          reason: resumeResult.reason,
+          current_omx_session_id: resumeResult.currentOmxSessionId || null,
+          payload_codex_session_id: payloadSessionId || null,
+          source_path: resumeResult.sourcePath || null,
+          target_path: resumeResult.targetPath || null,
+          owner_updated: resumeResult.updatedCurrentOwner,
+          resumed: resumeResult.resumed,
+        });
+      }
+    } catch (error) {
+      await logNotifyHookEvent(logsDir, {
+        timestamp: new Date().toISOString(),
+        level: 'warn',
+        type: 'ralph_session_resume_failure',
+        payload_codex_session_id: payloadSessionId || null,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
   // 2. Update active mode state (increment iteration)
   // GUARD: Skip when running inside a team worker to prevent state corruption
   if (!isTeamWorker) {
     try {
-      const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir, payloadSessionId);
+      const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
       for (const scopedDir of scopedDirs) {
         const stateFiles = await readdir(scopedDir).catch(() => []);
         for (const f of stateFiles) {
@@ -298,7 +413,9 @@ async function main() {
       if (existsSync(hudStatePath)) {
         hudState = JSON.parse(await readFile(hudStatePath, 'utf-8'));
       }
-      hudState.last_turn_at = new Date().toISOString();
+      const nowIso = new Date().toISOString();
+      hudState.last_turn_at = nowIso;
+      (hudState as any).last_progress_at = nowIso;
       hudState.turn_count = (hudState.turn_count || 0) + 1;
       (hudState as any).last_agent_output = (payload['last-assistant-message'] || payload.last_assistant_message || '')
         .slice(0, 100);
@@ -323,14 +440,12 @@ async function main() {
   // 4.45. Skill activation tracking: update skill-active-state.json before any nudge logic.
   try {
     const { recordSkillActivation } = await import('../hooks/keyword-detector.js');
-    const inputMessages = normalizeInputMessages(payload);
-    const latestUserInput = safeString(inputMessages.length > 0 ? inputMessages[inputMessages.length - 1] : '');
     if (latestUserInput) {
       await recordSkillActivation({
         stateDir,
         text: latestUserInput,
         sessionId: payloadSessionId,
-        threadId: safeString(payload['thread-id'] || payload.thread_id || ''),
+        threadId: payloadThreadId,
         turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
       });
     }
@@ -443,19 +558,20 @@ async function main() {
       const { notifyLifecycle } = await import('../notifications/index.js');
       const { shouldSendIdleNotification, recordIdleNotificationSent } = await import('../notifications/idle-cooldown.js');
       const sessionJsonPath = join(stateDir, 'session.json');
+      const idleFingerprint = buildIdleNotificationFingerprint(payload);
       let notifySessionId = '';
       try {
         const sessionData = JSON.parse(await readFile(sessionJsonPath, 'utf-8'));
         notifySessionId = safeString(sessionData && sessionData.session_id ? sessionData.session_id : '');
       } catch { /* no session file */ }
 
-      if (notifySessionId && shouldSendIdleNotification(stateDir, notifySessionId)) {
+      if (notifySessionId && shouldSendIdleNotification(stateDir, notifySessionId, idleFingerprint)) {
         const idleResult = await notifyLifecycle('session-idle', {
           sessionId: notifySessionId,
           projectPath: cwd,
         });
         if (idleResult && idleResult.anySuccess) {
-          recordIdleNotificationSent(stateDir, notifySessionId);
+          recordIdleNotificationSent(stateDir, notifySessionId, idleFingerprint);
         }
         try {
           const { buildNativeHookEvent } = await import('../hooks/extensibility/events.js');
@@ -506,7 +622,7 @@ async function main() {
         payload,
         stateDir,
         logsDir,
-        sessionId: payloadSessionId,
+        sessionId: currentOmxSessionId || payloadSessionId,
         turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
       });
     } catch (err) {
@@ -531,23 +647,36 @@ async function main() {
       const { processCodeSimplifier } = await import('../hooks/code-simplifier/index.js');
       const csResult = processCodeSimplifier(cwd, stateDir);
       if (csResult.triggered) {
-        const csPaneId = await resolveNudgePaneTarget(stateDir);
-        if (csPaneId) {
-          const csText = `${csResult.message} ${DEFAULT_MARKER}`;
-          const { runProcess } = await import('./notify-hook/process-runner.js');
-          await runProcess('tmux', ['send-keys', '-t', csPaneId, '-l', csText], 3000);
-          await new Promise(r => setTimeout(r, 100));
-          await runProcess('tmux', ['send-keys', '-t', csPaneId, 'C-m'], 3000);
-          await new Promise(r => setTimeout(r, 100));
-          await runProcess('tmux', ['send-keys', '-t', csPaneId, 'C-m'], 3000);
-
+        const managedSession = await isManagedOmxSession(cwd, payload, { allowTeamWorker: false });
+        if (!managedSession) {
           const { logTmuxHookEvent } = await import('./notify-hook/log.js');
           await logTmuxHookEvent(logsDir, {
             timestamp: new Date().toISOString(),
-            type: 'code_simplifier_triggered',
-            pane_id: csPaneId,
-            file_count: csResult.message.split('\n').filter(l => l.trimStart().startsWith('- ')).length,
+            type: 'code_simplifier_skipped',
+            reason: 'unmanaged_session',
           });
+        } else {
+          const csPaneId = await resolveNudgePaneTarget(stateDir, cwd, payload);
+          if (csPaneId) {
+            const csText = `${csResult.message} ${DEFAULT_MARKER}`;
+            const sendResult = await sendPaneInput({
+              paneTarget: csPaneId,
+              prompt: csText,
+              submitKeyPresses: 2,
+              submitDelayMs: 100,
+            });
+            if (!sendResult.ok) {
+              throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+            }
+
+            const { logTmuxHookEvent } = await import('./notify-hook/log.js');
+            await logTmuxHookEvent(logsDir, {
+              timestamp: new Date().toISOString(),
+              type: 'code_simplifier_triggered',
+              pane_id: csPaneId,
+              file_count: csResult.message.split('\n').filter(l => l.trimStart().startsWith('- ')).length,
+            });
+          }
         }
       }
     } catch {

package/src/scripts/run-provider-advisor.ts

@@ -59,7 +59,8 @@ function ensureBinary(binary: string): void {
   const probe = spawnSync(binary, ['--version'], {
     stdio: 'ignore',
     encoding: 'utf8',
-  });
+      windowsHide: true,
+    });
 
   if (probe.error && (probe.error as NodeJS.ErrnoException).code === 'ENOENT') {
     const verify = `${binary} --version`;
@@ -153,7 +154,8 @@ async function main(): Promise<void> {
   const run = spawnSync(binary, ['-p', prompt], {
     encoding: 'utf8',
     maxBuffer: 10 * 1024 * 1024,
-  });
+      windowsHide: true,
+    });
 
   const stdout = run.stdout || '';
   const stderr = run.stderr || '';

package/src/scripts/run-test-files.ts

@@ -0,0 +1,48 @@
+import { spawnSync } from 'node:child_process';
+import { readdirSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+function collectTests(path: string, out: string[]): void {
+  let stats;
+  try {
+    stats = statSync(path);
+  } catch {
+    return;
+  }
+
+  if (stats.isDirectory()) {
+    for (const entry of readdirSync(path)) {
+      collectTests(join(path, entry), out);
+    }
+    return;
+  }
+
+  if (stats.isFile() && path.endsWith('.test.js')) {
+    out.push(path);
+  }
+}
+
+const roots = process.argv.slice(2);
+const targets = roots.length > 0 ? roots : ['dist'];
+const files: string[] = [];
+for (const target of targets) {
+  collectTests(resolve(target), files);
+}
+
+files.sort();
+
+if (files.length === 0) {
+  console.error(`No test files found under: ${targets.join(', ')}`);
+  process.exit(1);
+}
+
+const result = spawnSync(process.execPath, ['--test', ...files], {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+if (typeof result.status === 'number') {
+  process.exit(result.status);
+}
+
+process.exit(1);

package/src/scripts/tmux-hook-engine.ts

@@ -80,6 +80,10 @@ export function normalizeTmuxHookConfig(raw: any): any {
   };
 }
 
+export function tmuxHookExplicitlyDisablesInjection(raw: any): boolean {
+  return Boolean(raw && typeof raw === 'object' && raw.enabled === false);
+}
+
 export function pickActiveMode(activeModes: any, allowedModes: any): string | null {
   const activeSet = new Set((activeModes || []).filter((mode: any) => typeof mode === 'string'));
   for (const mode of allowedModes || []) {
@@ -223,6 +227,7 @@ export function resolveCodexPane(): string {
   try {
     const sessionName = execFileSync('tmux', ['display-message', '-t', envPane, '-p', '#S'], {
       encoding: 'utf-8', timeout: 2000,
+      windowsHide: true,
     }).trim();
     if (!sessionName) return '';
 
@@ -297,6 +302,17 @@ export function paneLooksReady(captured: any): boolean {
   return lines.some((line) => /^\s*(?:[›>❯]\s*)?[A-Z][A-Z0-9]+-\d+\s+only(?:\s*(?:…|\.{3}))?\s*$/iu.test(line));
 }
 
+export function paneShowsCodexViewport(captured: any): boolean {
+  const lines = normalizePaneLines(captured);
+  if (lines.length === 0) return false;
+  if (paneIsBootstrapping(lines)) return false;
+
+  const hasCodexBanner = lines.some((line) => /\bOpenAI Codex\b/i.test(line));
+  if (!hasCodexBanner) return false;
+
+  return lines.some((line) => /(?:^|\s)(?:model|directory):/i.test(line));
+}
+
 export function paneHasActiveTask(captured: any): boolean {
   const tail = normalizePaneLines(captured).map((line) => line.trim()).slice(-40);
   if (tail.some((line) => /\b\d+\s+background terminal running\b/i.test(line))) return true;