oh-my-codex 0.13.2 → 0.14.1

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

@@ -25,6 +25,7 @@ import {
   maybeNudgeTeamLeader,
   resolveLeaderStalenessThresholdMs,
 } from './notify-hook/team-leader-nudge.js';
+import { resolveManagedPaneFromAnchor, resolveManagedSessionPane } from './notify-hook/managed-tmux.js';
 import { DEFAULT_MARKER } from './tmux-hook-engine.js';
 import { isTerminalPhase } from './notify-hook/utils.js';
 import { isSessionStale, isSessionStateAuthoritativeForCwd, readSessionState } from '../hooks/session.js';
@@ -36,6 +37,7 @@ import { listNotifyCanonicalActiveTeams } from './notify-hook/active-team.js';
 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';
 
 function argValue(name: string, fallback = ''): string {
   const idx = process.argv.indexOf(name);
@@ -145,7 +147,7 @@ const watcherOwnerToken = `${process.pid}-${startedAt}-${Math.random().toString(
 const RALPH_CONTINUE_TEXT = 'Ralph loop active continue';
 const RALPH_CONTINUE_CADENCE_MS = 60_000;
 const RALPH_STEER_LOCK_STALE_MS = 30_000;
-const RALPH_TERMINAL_PHASES = new Set(['complete', 'failed', 'cancelled']);
+const RALPH_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled']);
 const RALPH_STARTING_PHASE_TIMEOUT_MS = RALPH_CONTINUE_CADENCE_MS * 2;
 const QUIET_ONCE_EVENT_TYPES = new Set(['watcher_start', 'watcher_once_complete']);
 
@@ -474,6 +476,7 @@ function normalizeRalphContinueSteerState(raw: Record<string, unknown> | null |
 function hasRalphTerminalState(raw: Record<string, unknown> | null | undefined): boolean {
   if (!raw || typeof raw !== 'object') return true;
   if (raw.active !== true) return true;
+  if (!shouldContinueRun(raw)) return true;
   const phase = safeString(raw.current_phase).trim().toLowerCase();
   if (phase && RALPH_TERMINAL_PHASES.has(phase)) return true;
   if (isStaleRalphStartingPhase(raw)) return true;
@@ -1029,6 +1032,90 @@ async function writePidFileRecord(): Promise<void> {
   await writeFile(pidFilePath, JSON.stringify(nextRecord, null, 2)).catch(() => {});
 }
 
+async function buildWatcherManagedPayload(): Promise<Record<string, string> | null> {
+  const session = await readSessionState(cwd).catch(() => null);
+  const sessionId = safeString(session?.session_id).trim();
+  if (!sessionId || !session || isSessionStale(session)) return null;
+  return { session_id: sessionId };
+}
+
+async function persistReboundRalphPaneState(
+  statePath: string,
+  state: Record<string, unknown> | null,
+  paneId: string,
+  nowIso: string,
+): Promise<Record<string, unknown>> {
+  const latestState = await readFile(statePath, 'utf-8')
+    .then((content) => JSON.parse(content) as Record<string, unknown>)
+    .catch(() => null);
+  const nextState = {
+    ...((latestState && typeof latestState === 'object') ? latestState : (state || {})),
+    tmux_pane_id: paneId,
+    tmux_pane_set_at: nowIso,
+  };
+  const tmpPath = `${statePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+  await writeFile(tmpPath, JSON.stringify(nextState, null, 2));
+  try {
+    await rename(tmpPath, statePath);
+  } catch (error) {
+    await unlink(tmpPath).catch(() => {});
+    throw error;
+  }
+  return nextState;
+}
+
+async function resolveRalphContinuePaneTarget(
+  activeRalph: ActiveModeResult,
+  nowIso: string,
+): Promise<{ paneId: string; state: Record<string, unknown> | null; reboundFrom: string }> {
+  const currentState = activeRalph.state && typeof activeRalph.state === 'object'
+    ? activeRalph.state as Record<string, unknown>
+    : null;
+  const anchorPaneId = safeString(currentState?.tmux_pane_id).trim();
+  if (!anchorPaneId) {
+    return {
+      paneId: '',
+      state: currentState,
+      reboundFrom: '',
+    };
+  }
+
+  const managedPayload = await buildWatcherManagedPayload();
+  if (!managedPayload) {
+    return {
+      paneId: anchorPaneId,
+      state: currentState,
+      reboundFrom: '',
+    };
+  }
+
+  let resolvedPaneId = await resolveManagedPaneFromAnchor(anchorPaneId, cwd, managedPayload, { allowTeamWorker: false });
+  if (!resolvedPaneId) {
+    resolvedPaneId = await resolveManagedSessionPane(cwd, managedPayload);
+  }
+  if (!resolvedPaneId) {
+    return {
+      paneId: '',
+      state: currentState,
+      reboundFrom: '',
+    };
+  }
+  if (resolvedPaneId === anchorPaneId) {
+    return {
+      paneId: resolvedPaneId,
+      state: currentState,
+      reboundFrom: '',
+    };
+  }
+
+  const updatedState = await persistReboundRalphPaneState(activeRalph.path, currentState, resolvedPaneId, nowIso);
+  return {
+    paneId: resolvedPaneId,
+    state: updatedState,
+    reboundFrom: anchorPaneId,
+  };
+}
+
 async function runRalphContinueSteerTick(): Promise<void> {
   const now = Date.now();
   const nowIso = new Date(now).toISOString();
@@ -1088,7 +1175,9 @@ async function runRalphContinueSteerTick(): Promise<void> {
       return { sent: false, skipped: true };
     }
 
-    const paneId = safeString(activeRalph.state?.tmux_pane_id).trim();
+    const resolvedPane = await resolveRalphContinuePaneTarget(activeRalph, nowIso);
+    activeRalph.state = resolvedPane.state;
+    const paneId = resolvedPane.paneId;
     if (!paneId) {
       lastRalphContinueSteer.last_reason = 'pane_missing';
       lastRalphContinueSteer.pane_id = '';
@@ -1113,6 +1202,7 @@ async function runRalphContinueSteerTick(): Promise<void> {
       type: 'ralph_continue_steer',
       reason: 'sent',
       pane_id: paneId,
+      rebound_from: resolvedPane.reboundFrom || null,
       state_path: activeRalph.path,
       current_phase: safeString(activeRalph.state?.current_phase) || null,
       cadence_ms: RALPH_CONTINUE_CADENCE_MS,

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

@@ -21,6 +21,8 @@ import { logTmuxHookEvent } from './log.js';
 import { evaluatePaneInjectionReadiness, mapPaneInjectionReadinessReason, sendPaneInput } from './team-tmux-guard.js';
 import { stripOrchestrationIntentTags } from './orchestration-intent.js';
 import { buildCapturePaneArgv, DEFAULT_MARKER, tmuxHookExplicitlyDisablesInjection } from '../tmux-hook-engine.js';
+import { readAutoresearchCompletionStatus } from '../../autoresearch/skill-validation.js';
+import { persistDeepInterviewModeState } from '../../hooks/keyword-detector.js';
 import {
   isManagedOmxSession,
   resolveManagedCurrentPane,
@@ -36,6 +38,7 @@ export const DEEP_INTERVIEW_INPUT_LOCK_MESSAGE = 'Deep interview is active; auto
 export const DEFAULT_AUTO_NUDGE_RESPONSE = 'continue with the current task only if it is already authorized';
 const DEEP_INTERVIEW_ERROR_PATTERNS = [' error', ' failed', ' failure', ' exception', 'unable to continue', 'cannot continue', 'could not continue'];
 const DEEP_INTERVIEW_ABORT_PATTERNS = ['aborted', 'cancelled', 'canceled'];
+const DEEP_INTERVIEW_SUCCESS_PATTERNS = ['interview completed', 'interview complete', 'interview finished', 'final summary ready'];
 const DEEP_INTERVIEW_ABORT_INPUTS = new Set(['abort', 'cancel', 'stop']);
 const DEEP_INTERVIEW_BLOCKED_APPROVAL_PREFIXES = new Set(['next i should']);
 const SKILL_PHASES = new Set(['planning', 'executing', 'reviewing', 'completing']);
@@ -99,6 +102,10 @@ function hasAnySubstring(text, patterns) {
   return patterns.some((pattern) => lower.includes(pattern));
 }
 
+function looksLikeDeepInterviewSuccess(text) {
+  return hasAnySubstring(text, DEEP_INTERVIEW_SUCCESS_PATTERNS);
+}
+
 export function isDeepInterviewAutoApprovalLocked(skillState) {
   return Boolean(
     skillState
@@ -188,6 +195,78 @@ async function persistSkillActiveState(stateDir, sessionId, state) {
   await writeScopedJson(stateDir, SKILL_ACTIVE_STATE_FILE, sessionId, state).catch(() => {});
 }
 
+function cloneSkillActiveState(state) {
+  if (!state || typeof state !== 'object') return null;
+  return {
+    ...state,
+    input_lock: state.input_lock
+      ? {
+        ...state.input_lock,
+        blocked_inputs: Array.isArray(state.input_lock.blocked_inputs)
+          ? [...state.input_lock.blocked_inputs]
+          : state.input_lock.blocked_inputs,
+      }
+      : state.input_lock,
+  };
+}
+
+export async function syncSkillStateFromTurn(stateDir, payload) {
+  const lastMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
+  const latestUserInput = latestUserInputFromPayload(payload);
+  const invocationSessionId = resolveInvocationSessionId(payload);
+  let skillState = await loadSkillActiveState(stateDir, invocationSessionId);
+  let releaseReason = null;
+
+  if (!skillState) {
+    return { invocationSessionId, skillState: null, releaseReason };
+  }
+
+  const previousSkillState = cloneSkillActiveState(skillState);
+  const previousPhase = normalizeSkillPhase(skillState.phase);
+  const inferredPhase = inferSkillPhaseFromText(lastMessage, previousPhase);
+  const explicitDeepInterviewSuccess = skillState.skill === 'deep-interview' && looksLikeDeepInterviewSuccess(lastMessage);
+  const nextPhase = skillState.skill === 'deep-interview'
+    && inferredPhase === 'completing'
+    && previousPhase !== 'completing'
+    && !explicitDeepInterviewSuccess
+    ? previousPhase
+    : inferredPhase;
+  skillState.phase = nextPhase;
+  skillState.active = nextPhase !== 'completing';
+
+  if (skillState.skill === 'autoresearch') {
+    const completion = await readAutoresearchCompletionStatus(payload.cwd || process.cwd(), invocationSessionId);
+    skillState.validation_mode = completion.validationMode;
+    skillState.autoresearch_completion_reason = completion.reason;
+    skillState.completion_artifact_path = completion.artifactPath;
+    if (completion.complete) {
+      skillState.phase = 'completing';
+      skillState.active = false;
+    } else if (inferredPhase === 'completing') {
+      skillState.phase = previousPhase === 'completing' ? 'reviewing' : previousPhase;
+      skillState.active = true;
+    }
+  }
+
+  const nowIso = new Date().toISOString();
+  skillState.updated_at = nowIso;
+  releaseReason = inferDeepInterviewReleaseReason({ skillState, latestUserInput, lastMessage });
+  if (releaseReason && isDeepInterviewAutoApprovalLocked(skillState)) {
+    releaseDeepInterviewInputLock(skillState, releaseReason, nowIso);
+  }
+  await persistSkillActiveState(stateDir, invocationSessionId, skillState);
+
+  if (skillState.skill === 'deep-interview' || previousSkillState?.skill === 'deep-interview') {
+    await persistDeepInterviewModeState(stateDir, skillState, nowIso, previousSkillState, {
+      sessionId: invocationSessionId,
+      threadId: safeString(payload?.['thread-id'] || payload?.thread_id || ''),
+      turnId: safeString(payload?.['turn-id'] || payload?.turn_id || ''),
+    });
+  }
+
+  return { invocationSessionId, skillState, releaseReason };
+}
+
 
 export async function isDeepInterviewStateActive(stateDir, sessionId) {
   const modeState = await readScopedJsonIfExists(stateDir, 'deep-interview-state.json', sessionId, null);
@@ -479,8 +558,10 @@ export async function resolveNudgePaneTarget(stateDir: any, cwd = '', payload: a
         if (!anchoredPane) continue;
         const managedPane = await resolveManagedPaneFromAnchor(anchoredPane, cwd, payload, { allowTeamWorker });
         if (managedPane) return managedPane;
-        const verdict = await verifyManagedPaneTarget(anchoredPane, cwd, payload, { allowTeamWorker });
-        if (verdict.ok) return anchoredPane;
+        if (allowTeamWorker) {
+          const verdict = await verifyManagedPaneTarget(anchoredPane, cwd, payload, { allowTeamWorker });
+          if (verdict.ok) return anchoredPane;
+        }
       } catch {
         // skip malformed state
       }
@@ -516,21 +597,9 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
   }
 
   const lastMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
-  const latestUserInput = latestUserInputFromPayload(payload);
-  const invocationSessionId = resolveInvocationSessionId(payload);
-  let skillState = await loadSkillActiveState(stateDir, invocationSessionId);
-  let releaseReason = null;
+  const { invocationSessionId, skillState, releaseReason } = await syncSkillStateFromTurn(stateDir, payload);
 
   try {
-    if (skillState) {
-      const inferredPhase = inferSkillPhaseFromText(lastMessage, skillState.phase);
-      skillState.phase = inferredPhase;
-      skillState.active = inferredPhase !== 'completing';
-      skillState.updated_at = new Date().toISOString();
-      releaseReason = inferDeepInterviewReleaseReason({ skillState, latestUserInput, lastMessage });
-      await persistSkillActiveState(stateDir, invocationSessionId, skillState);
-    }
-
     const nudgeStatePath = await getScopedStatePath(stateDir, 'auto-nudge-state.json', invocationSessionId);
     let nudgeState = await readScopedJsonIfExists(stateDir, 'auto-nudge-state.json', invocationSessionId, null);
     if (!nudgeState || typeof nudgeState !== 'object') {
@@ -618,8 +687,10 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
       return;
     }
 
-    const deepInterviewLockActive = isDeepInterviewAutoApprovalLocked(skillState) && !releaseReason;
-    if (deepInterviewLockActive) {
+    const blockedAutoApproval = isDeepInterviewAutoApprovalLocked(skillState)
+      && !releaseReason
+      && isBlockedAutoApprovalInput(effectiveResponse, skillState.input_lock?.blocked_inputs);
+    if (blockedAutoApproval) {
       const blockedMessage = skillState.input_lock?.message || DEEP_INTERVIEW_INPUT_LOCK_MESSAGE;
       await logTmuxHookEvent(logsDir, {
         timestamp: new Date().toISOString(),
@@ -628,9 +699,7 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
         response: effectiveResponse,
         source,
         blocked_by: 'deep-interview-lock',
-        block_kind: isBlockedAutoApprovalInput(effectiveResponse, skillState.input_lock?.blocked_inputs)
-          ? 'blocked-auto-approval'
-          : 'input-lock-active',
+        block_kind: 'blocked-auto-approval',
         message: blockedMessage,
         suppressed: true,
       }).catch(() => {});

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

@@ -248,7 +248,7 @@ export async function verifyManagedPaneTarget(paneId: string, cwd: string, paylo
 }
 
 
-async function readManagedPaneCommandState(paneTarget: string): Promise<{ currentCommand: string; startCommand: string }> {
+async function readManagedPaneCommandState(paneTarget: string): Promise<{ currentCommand: string; startCommand: string; lookupFailed: boolean }> {
   try {
     const [currentResult, startResult] = await Promise.all([
       runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#{pane_current_command}'], 2000),
@@ -257,9 +257,10 @@ async function readManagedPaneCommandState(paneTarget: string): Promise<{ curren
     return {
       currentCommand: safeString(currentResult.stdout).trim().toLowerCase(),
       startCommand: safeString(startResult.stdout).trim().toLowerCase(),
+      lookupFailed: false,
     };
   } catch {
-    return { currentCommand: '', startCommand: '' };
+    return { currentCommand: '', startCommand: '', lookupFailed: true };
   }
 }
 
@@ -268,6 +269,59 @@ function paneLooksLikeManagedAgent({ currentCommand, startCommand }: { currentCo
   if (startCommand.includes('codex')) return true;
   return currentCommand === 'codex' || currentCommand === 'node' || currentCommand === 'npx';
 }
+
+function paneLooksLikeRetainableManagedAnchor({ currentCommand, startCommand }: { currentCommand: string; startCommand: string }): boolean {
+  if (/\bomx\b.*\bhud\b.*--watch/i.test(startCommand)) return false;
+  if (currentCommand === 'codex') return true;
+  if ((currentCommand === 'node' || currentCommand === 'npx') && startCommand.includes('codex')) return true;
+  return false;
+}
+
+function paneLooksLikeDetachedManagedWrapperFallback({ currentCommand, startCommand }: { currentCommand: string; startCommand: string }): boolean {
+  if (/\bomx\b.*\bhud\b.*--watch/i.test(startCommand)) return false;
+  return currentCommand === 'node' || currentCommand === 'npx';
+}
+
+interface ManagedSessionPaneRow {
+  paneId: string;
+  active: boolean;
+  currentCommand: string;
+  startCommand: string;
+}
+
+function parseManagedSessionPaneRows(stdout: string): ManagedSessionPaneRow[] {
+  return safeString(stdout)
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const [paneId = '', activeRaw = '0', rawCurrentCommand = '', rawStartCommand = ''] = line.split('\t');
+      return {
+        paneId: safeString(paneId).trim(),
+        active: safeString(activeRaw).trim() === '1',
+        currentCommand: safeString(rawCurrentCommand).trim().toLowerCase(),
+        startCommand: safeString(rawStartCommand).trim().toLowerCase(),
+      };
+    })
+    .filter((row) => row.paneId !== '');
+}
+
+function selectManagedSessionPane(
+  rows: ManagedSessionPaneRow[],
+  { allowWrapperFallback = false }: { allowWrapperFallback?: boolean } = {},
+): string {
+  const nonHudRows = rows.filter((row) => !/\bomx\b.*\bhud\b.*--watch/i.test(row.startCommand));
+  const canonicalRows = nonHudRows.filter((row) => paneLooksLikeRetainableManagedAnchor(row));
+  const activeCanonical = canonicalRows.find((row) => row.active);
+  if (activeCanonical) return activeCanonical.paneId;
+  if (canonicalRows[0]?.paneId) return canonicalRows[0].paneId;
+  if (!allowWrapperFallback) return '';
+
+  const wrapperFallbackRows = nonHudRows.filter((row) => paneLooksLikeDetachedManagedWrapperFallback(row));
+  const activeWrapperFallback = wrapperFallbackRows.find((row) => row.active);
+  if (activeWrapperFallback) return activeWrapperFallback.paneId;
+  return wrapperFallbackRows[0]?.paneId || '';
+}
 export async function resolveManagedCurrentPane(cwd: string, payload: any, { allowTeamWorker = false } = {}): Promise<string> {
   const paneTarget = safeString(process.env.TMUX_PANE || '').trim();
   if (!paneTarget) return '';
@@ -286,22 +340,10 @@ export async function resolveManagedSessionPane(cwd: string, payload: any): Prom
   try {
     const panesResult = await runProcess(
       'tmux',
-      ['list-panes', '-s', '-t', expectedSession, '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}'],
+      ['list-panes', '-s', '-t', expectedSession, '-F', '#{pane_id}\t#{pane_active}\t#{pane_current_command}\t#{pane_start_command}'],
       2000,
     );
-    const panes = safeString(panesResult.stdout)
-      .trim()
-      .split('\n')
-      .filter(Boolean);
-    for (const line of panes) {
-      const [candidatePaneId, rawCurrentCommand = '', rawStartCommand = ''] = line.split('\t');
-      const startCommand = safeString(rawStartCommand).toLowerCase();
-      const currentCommand = safeString(rawCurrentCommand).trim().toLowerCase();
-      if (!candidatePaneId) continue;
-      if (/\bomx\b.*\bhud\b.*--watch/i.test(startCommand)) continue;
-      if (startCommand.includes('codex')) return candidatePaneId;
-      if (currentCommand === 'codex') return candidatePaneId;
-    }
+    return selectManagedSessionPane(parseManagedSessionPaneRows(panesResult.stdout));
   } catch {
     // best effort only
   }
@@ -315,29 +357,26 @@ export async function resolveManagedPaneFromAnchor(anchorPane: string, cwd: stri
   const verdict = await verifyManagedPaneTarget(paneTarget, cwd, payload, { allowTeamWorker });
   if (!verdict.ok) return '';
 
+  const commandState = await readManagedPaneCommandState(paneTarget);
+  if (commandState.lookupFailed) return paneTarget;
+  if (paneLooksLikeRetainableManagedAnchor(commandState)) return paneTarget;
+
   try {
-    const sessionResult = await runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#S'], 2000);
-    const sessionName = safeString(sessionResult.stdout).trim();
-    if (!sessionName) return paneTarget;
+    const sessionName = safeString(verdict.paneSessionName || verdict.managedContext?.expectedTmuxSessionName).trim();
+    if (!sessionName) return '';
 
     const panesResult = await runProcess(
       'tmux',
-      ['list-panes', '-s', '-t', sessionName, '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}'],
+      ['list-panes', '-s', '-t', sessionName, '-F', '#{pane_id}\t#{pane_active}\t#{pane_current_command}\t#{pane_start_command}'],
       2000,
     );
-    const panes = safeString(panesResult.stdout).trim().split('\n').filter(Boolean);
-    for (const line of panes) {
-      const [candidatePaneId, rawCurrentCommand = '', rawStartCommand = ''] = line.split('\t');
-      const startCommand = safeString(rawStartCommand).toLowerCase();
-      const currentCommand = safeString(rawCurrentCommand).trim().toLowerCase();
-      if (!candidatePaneId) continue;
-      if (/\bomx\b.*\bhud\b.*--watch/i.test(startCommand)) continue;
-      if (startCommand.includes('codex')) return candidatePaneId;
-      if (currentCommand === 'codex') return candidatePaneId;
-    }
+    const selectedPane = selectManagedSessionPane(parseManagedSessionPaneRows(panesResult.stdout), {
+      allowWrapperFallback: paneLooksLikeDetachedManagedWrapperFallback(commandState),
+    });
+    if (selectedPane) return selectedPane;
   } catch {
     // best effort only
   }
 
-  return paneTarget;
+  return '';
 }

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

@@ -7,7 +7,7 @@ import { resolveCodexPane } from '../tmux-hook-engine.js';
 import { safeString } from './utils.js';
 
 const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
-const RALPH_TERMINAL_PHASES = new Set(['complete', 'failed', 'cancelled']);
+const RALPH_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled']);
 const RALPH_RESUME_LOCK_STALE_MS = 10_000;
 const RALPH_RESUME_LOCK_TIMEOUT_MS = 5_000;
 const RALPH_RESUME_LOCK_RETRY_MS = 25;

package/src/scripts/notify-hook.ts

@@ -40,7 +40,13 @@ import {
 import { isLeaderStale, resolveLeaderStalenessThresholdMs, maybeNudgeTeamLeader } from './notify-hook/team-leader-nudge.js';
 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 {
+  maybeAutoNudge,
+  resolveNudgePaneTarget,
+  isDeepInterviewStateActive,
+  isDeepInterviewInputLockActive,
+  syncSkillStateFromTurn,
+} 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';
@@ -238,14 +244,19 @@ async function main() {
   }
 
   // 1. Log the turn
+  const normalizedInputMessages = normalizeInputMessages(payload);
+  const latestInputPreview = safeString(
+    normalizedInputMessages.length > 0
+      ? normalizedInputMessages[normalizedInputMessages.length - 1]
+      : '',
+  ).slice(0, 200);
   const logEntry = {
     timestamp: new Date().toISOString(),
     type: payload.type || 'agent-turn-complete',
     thread_id: payload['thread-id'] || payload.thread_id,
     turn_id: payload['turn-id'] || payload.turn_id,
-    input_preview: (payload['input-messages'] || payload.input_messages || [])
-      .map((m: any) => m.slice(0, 100))
-      .join('; '),
+    input_preview: latestInputPreview,
+    input_message_count: normalizedInputMessages.length,
     output_preview: (payload['last-assistant-message'] || payload.last_assistant_message || '')
       .slice(0, 200),
   };
@@ -473,7 +484,14 @@ async function main() {
     // Non-fatal: keyword detector module may not be built yet
   }
 
+  try {
+    await syncSkillStateFromTurn(stateDir, payload);
+  } catch {
+    // Non-fatal: lifecycle sync should not block the hook
+  }
+
   const deepInterviewStateActive = await isDeepInterviewStateActive(stateDir, getEffectiveSessionId());
+  const deepInterviewInputLockActive = await isDeepInterviewInputLockActive(stateDir, getEffectiveSessionId());
 
   // 4.55. Notify leader when individual worker transitions to idle (worker session only)
   if (isTeamWorker && parsedTeamWorker && !deepInterviewStateActive) {
@@ -642,7 +660,7 @@ async function main() {
 
   // 9. Auto-nudge: detect Codex stall patterns and automatically send a continuation prompt.
   //    Works for both leader and worker contexts.
-  if (!deepInterviewStateActive) {
+  if (!deepInterviewStateActive || deepInterviewInputLockActive) {
     try {
       await maybeAutoNudge({ cwd, stateDir, logsDir, payload });
     } catch {

package/src/scripts/postinstall-bootstrap.js

@@ -0,0 +1,23 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const distScriptPath = join(__dirname, "..", "..", "dist", "scripts", "postinstall.js");
+
+if (!existsSync(distScriptPath)) {
+  process.exit(0);
+}
+
+const moduleUrl = pathToFileURL(distScriptPath).href;
+try {
+  const postinstallModule = await import(moduleUrl);
+  if (typeof postinstallModule.main === "function") {
+    await postinstallModule.main();
+  }
+} catch (error) {
+  console.warn(
+    `[omx] Postinstall bootstrap skipped after a non-fatal error: ${error instanceof Error ? error.message : String(error)}`,
+  );
+}