oh-my-codex 0.18.6 → 0.18.8

package/src/scripts/notify-hook/team-worker-stop.ts

@@ -6,11 +6,12 @@
  * It must not depend on idle/heartbeat freshness or inferred progress stalls.
  */
 
-import { appendFile, mkdir, rename, writeFile } from 'fs/promises';
-import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { appendFile, mkdir, rename, rm, stat, writeFile } from 'fs/promises';
+import { dirname, join, relative } from 'path';
 import { DEFAULT_MARKER, paneHasActiveTask } from '../tmux-hook-engine.js';
 import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
-import { safeString, asNumber } from './utils.js';
+import { safeString, asNumber, isTerminalPhase } from './utils.js';
 import { readJsonIfExists } from './state-io.js';
 import { logTmuxHookEvent } from './log.js';
 import { evaluatePaneInjectionReadiness, queuePaneInput, sendPaneInput } from './team-tmux-guard.js';
@@ -21,6 +22,110 @@ const STOP_NUDGE_COOLDOWN_MS = 30_000;
 const SOURCE_TYPE = 'worker_stop';
 const LEADER_PANE_MISSING_NO_INJECTION_REASON = 'leader_pane_missing_no_injection';
 const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
+const TEAM_SHUTDOWN_NO_INJECTION_REASON = 'team_state_gone_or_shutdown';
+const TEAM_LOCK_HELD_REASON = 'suppressed_team_lock_held';
+
+async function teamStateAllowsWorkerStopNudge(stateDir, teamName) {
+  const teamDir = join(stateDir, 'team', teamName);
+  if (!existsSync(teamDir)) return false;
+  if (existsSync(join(teamDir, 'shutdown.json'))) return false;
+
+  const phase = await readJsonIfExists(join(teamDir, 'phase.json'), null);
+  const currentPhase = safeString(phase?.current_phase || phase?.phase || '').trim();
+  if (currentPhase && isTerminalPhase(currentPhase)) return false;
+
+  return true;
+}
+
+async function acquireTeamStopNudgeLock(teamDir, nowMs, cooldownMs) {
+  const lockDir = join(teamDir, 'worker-stop-nudge.lock');
+  const staleAfterMs = Math.max(cooldownMs, 30_000);
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await mkdir(lockDir);
+      await writeFile(join(lockDir, 'owner.json'), JSON.stringify({
+        pid: process.pid,
+        acquired_at_ms: nowMs,
+        acquired_at: new Date(nowMs).toISOString(),
+      }, null, 2)).catch(() => {});
+      return { acquired: true, lockDir };
+    } catch (error) {
+      if (error?.code === 'ENOENT') return { acquired: false, reason: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+      if (error?.code !== 'EEXIST') return { acquired: false, reason: TEAM_LOCK_HELD_REASON };
+
+      try {
+        const lockStat = await stat(lockDir);
+        if ((nowMs - lockStat.mtimeMs) >= staleAfterMs) {
+          await rm(lockDir, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      return { acquired: false, reason: TEAM_LOCK_HELD_REASON };
+    }
+  }
+
+  return { acquired: false, reason: TEAM_LOCK_HELD_REASON };
+}
+
+async function releaseTeamStopNudgeLock(lockDir) {
+  if (!lockDir) return;
+  await rm(lockDir, { recursive: true, force: true }).catch(() => {});
+}
+
+async function ensureDirectoryUnderExistingTeam(teamDir, targetDir) {
+  if (!existsSync(teamDir)) return false;
+  const rel = relative(teamDir, targetDir);
+  if (!rel) return true;
+  if (rel.startsWith('..')) throw new Error('state_path_outside_team_dir');
+
+  let current = teamDir;
+  for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
+    if (!existsSync(teamDir)) return false;
+    current = join(current, segment);
+    try {
+      await mkdir(current);
+    } catch (error) {
+      if (error?.code === 'ENOENT' && !existsSync(teamDir)) return false;
+      if (error?.code !== 'EEXIST') throw error;
+      const currentStat = await stat(current);
+      if (!currentStat.isDirectory()) throw error;
+    }
+  }
+  return existsSync(teamDir);
+}
+
+async function writeStopNudgeStateIfTeamExists(teamDir, statePath, state) {
+  const stateDir = dirname(statePath);
+  const ready = await ensureDirectoryUnderExistingTeam(teamDir, stateDir);
+  if (!ready) return false;
+  try {
+    const tmpPath = `${statePath}.tmp.${process.pid}`;
+    await writeFile(tmpPath, JSON.stringify(state, null, 2));
+    await rename(tmpPath, statePath);
+  } catch (error) {
+    if (error?.code === 'ENOENT' && !existsSync(teamDir)) return false;
+    throw error;
+  }
+  return existsSync(teamDir);
+}
+
+async function appendWorkerStopEventIfTeamExists(stateDir, teamName, event) {
+  const teamDir = join(stateDir, 'team', teamName);
+  const eventsDir = join(teamDir, 'events');
+  const ready = await ensureDirectoryUnderExistingTeam(teamDir, eventsDir);
+  if (!ready) return false;
+  const eventsPath = join(eventsDir, 'events.ndjson');
+  try {
+    await appendFile(eventsPath, JSON.stringify(event) + '\n');
+  } catch (error) {
+    if (error?.code === 'ENOENT' && !existsSync(teamDir)) return false;
+    throw error;
+  }
+  return existsSync(teamDir);
+}
 
 function resolveWorkerStopCooldownMs() {
   const raw = safeString(process.env.OMX_TEAM_WORKER_STOP_COOLDOWN_MS || '');
@@ -42,20 +147,6 @@ async function resolveCanonicalLeaderPaneId(leaderPaneId) {
   return normalizedLeaderPaneId;
 }
 
-async function appendWorkerStopEvent(stateDir, teamName, event) {
-  const eventsDir = join(stateDir, 'team', teamName, 'events');
-  const eventsPath = join(eventsDir, 'events.ndjson');
-  await mkdir(eventsDir, { recursive: true }).catch(() => {});
-  await appendFile(eventsPath, JSON.stringify(event) + '\n').catch(() => {});
-}
-
-async function writeStopNudgeState(statePath, state) {
-  await mkdir(dirname(statePath), { recursive: true }).catch(() => {});
-  const tmpPath = `${statePath}.tmp.${process.pid}`;
-  await writeFile(tmpPath, JSON.stringify(state, null, 2));
-  await rename(tmpPath, statePath);
-}
-
 async function recordDeferred({
   stateDir,
   logsDir,
@@ -69,23 +160,26 @@ async function recordDeferred({
   paneCurrentCommand = '',
 }) {
   const nowIso = nextState.last_notified_at;
-  await writeStopNudgeState(statePath, {
+  const teamDir = join(stateDir, 'team', teamName);
+  const wroteState = await writeStopNudgeStateIfTeamExists(teamDir, statePath, {
     ...nextState,
     delivery: 'deferred',
     reason,
     pane_current_command: paneCurrentCommand || null,
   }).catch(() => {});
-  await appendWorkerStopEvent(stateDir, teamName, {
-    event_id: `worker-stop-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
-    team: teamName,
-    type: 'worker_stop_leader_nudge',
-    worker: workerName,
-    to_worker: 'leader-fixed',
-    delivery: 'deferred',
-    reason,
-    created_at: nowIso,
-    source_type: SOURCE_TYPE,
-  });
+  if (wroteState) {
+    await appendWorkerStopEventIfTeamExists(stateDir, teamName, {
+      event_id: `worker-stop-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+      team: teamName,
+      type: 'worker_stop_leader_nudge',
+      worker: workerName,
+      to_worker: 'leader-fixed',
+      delivery: 'deferred',
+      reason,
+      created_at: nowIso,
+      source_type: SOURCE_TYPE,
+    }).catch(() => {});
+  }
   await logTmuxHookEvent(logsDir, {
     timestamp: nowIso,
     type: 'leader_notification_deferred',
@@ -119,30 +213,58 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
   const { teamName, workerName } = workerContext || {};
   if (!teamName || !workerName || !stateDir) return { ok: false, result: 'unresolved' };
 
-  const workerDir = join(stateDir, 'team', teamName, 'workers', workerName);
+  const teamDir = join(stateDir, 'team', teamName);
+  const workerDir = join(teamDir, 'workers', workerName);
   const statePath = join(workerDir, 'worker-stop-nudge.json');
+  const teamStatePath = join(teamDir, 'worker-stop-nudge.json');
   const nowMs = Date.now();
   const nowIso = new Date(nowMs).toISOString();
+  const cooldownMs = resolveWorkerStopCooldownMs();
+  const nextState = {
+    last_notified_at_ms: nowMs,
+    last_notified_at: nowIso,
+    team: teamName,
+    worker: workerName,
+    source_type: SOURCE_TYPE,
+  };
+  let tmuxSession = '';
+  let leaderPaneId = '';
+
+  if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+    return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+  }
+
+  const lock = await acquireTeamStopNudgeLock(teamDir, nowMs, cooldownMs);
+  if (!lock.acquired) {
+    return { ok: true, result: lock.reason || TEAM_LOCK_HELD_REASON };
+  }
+
+  try {
+    if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+    }
+
+  const teamExisting = (await readJsonIfExists(teamStatePath, null)) || {};
+  const teamLastNotifiedMs = asNumber(teamExisting.last_notified_at_ms) ?? 0;
+  if ((nowMs - teamLastNotifiedMs) < cooldownMs) {
+    return { ok: true, result: 'suppressed_team_cooldown' };
+  }
+
   const existing = (await readJsonIfExists(statePath, null)) || {};
   const lastNotifiedMs = asNumber(existing.last_notified_at_ms) ?? 0;
-  const cooldownMs = resolveWorkerStopCooldownMs();
   if ((nowMs - lastNotifiedMs) < cooldownMs) {
     return { ok: true, result: 'suppressed_cooldown' };
   }
 
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return { ok: false, result: 'unresolved' };
-  const { tmuxSession, leaderPaneId } = teamInfo;
+  ({ tmuxSession, leaderPaneId } = teamInfo);
   const tmuxTarget = await resolveCanonicalLeaderPaneId(leaderPaneId);
-  const nextState = {
-    last_notified_at_ms: nowMs,
-    last_notified_at: nowIso,
-    team: teamName,
-    worker: workerName,
-    source_type: SOURCE_TYPE,
-  };
 
   if (!tmuxTarget) {
+    if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+    }
     await recordDeferred({
       stateDir,
       logsDir,
@@ -164,6 +286,9 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     requireIdle: false,
   });
   if (!paneGuard.ok) {
+    if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+    }
     await recordDeferred({
       stateDir,
       logsDir,
@@ -179,12 +304,15 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     return { ok: true, result: 'deferred' };
   }
 
+  if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+    return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+  }
+
   const prompt =
     `[OMX] ${workerName} native Stop allowed. `
     + `Run \`omx team status ${teamName}\`, read worker messages/results, then assign next task, reconcile completion, or shut down. `
     + DEFAULT_MARKER;
 
-  try {
     const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
     let deliveryMode = 'sent';
     if (leaderHasActiveTask) {
@@ -204,22 +332,28 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
       if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
     }
 
-    await writeStopNudgeState(statePath, {
+    const deliveryState = {
       ...nextState,
       delivery: deliveryMode,
       leader_pane_id: leaderPaneId || null,
       tmux_target: tmuxTarget,
-    });
-    await appendWorkerStopEvent(stateDir, teamName, {
-      event_id: `worker-stop-nudge-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
-      team: teamName,
-      type: 'worker_stop_leader_nudge',
-      worker: workerName,
-      to_worker: 'leader-fixed',
-      delivery: deliveryMode,
-      created_at: nowIso,
-      source_type: SOURCE_TYPE,
-    });
+    };
+    const wroteWorkerState = await writeStopNudgeStateIfTeamExists(teamDir, statePath, deliveryState);
+    const wroteTeamState = wroteWorkerState
+      ? await writeStopNudgeStateIfTeamExists(teamDir, teamStatePath, deliveryState)
+      : false;
+    if (wroteTeamState) {
+      await appendWorkerStopEventIfTeamExists(stateDir, teamName, {
+        event_id: `worker-stop-nudge-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+        team: teamName,
+        type: 'worker_stop_leader_nudge',
+        worker: workerName,
+        to_worker: 'leader-fixed',
+        delivery: deliveryMode,
+        created_at: nowIso,
+        source_type: SOURCE_TYPE,
+      }).catch(() => {});
+    }
     await logTmuxHookEvent(logsDir, {
       timestamp: nowIso,
       type: 'worker_stop_leader_nudge',
@@ -241,6 +375,11 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     }).catch(() => {});
     return { ok: true, result: deliveryMode };
   } catch (err) {
+    if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
+      return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
+    }
+    // Worker Stop is already allowed before this helper runs; nudge failures are
+    // surfaced as deferred operational evidence instead of re-blocking Stop.
     await recordDeferred({
       stateDir,
       logsDir,
@@ -253,5 +392,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
       leaderPaneId,
     });
     return { ok: true, result: 'deferred' };
+  } finally {
+    await releaseTeamStopNudgeLock(lock.lockDir);
   }
 }

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

@@ -21,7 +21,7 @@ import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
 import { resolveInvocationSessionId, resolveManagedCurrentPane, resolveManagedSessionContext, verifyManagedPaneTarget } from './managed-tmux.js';
 import { evaluatePaneInjectionReadiness, mapPaneInjectionReadinessReason, sendPaneInput } from './team-tmux-guard.js';
-import { listActiveSkills, readVisibleSkillActiveState } from '../../state/skill-active.js';
+import { listActiveSkills, readVisibleSkillActiveStateForStateDir } from '../../state/skill-active.js';
 import {
   normalizeTmuxHookConfig,
   pickActiveMode,
@@ -99,12 +99,14 @@ 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; stateDir: string } | null> {
-  const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir).catch(() => [stateDir]);
-  const dirs = [...scopedDirs];
-  if (!dirs.map((dir) => resolvePath(dir)).includes(resolvePath(stateDir))) {
-    dirs.push(stateDir);
-  }
+async function resolvePreferredModePane(
+  stateDir: string,
+  allowedModes: string[],
+  options: { includeRootFallback?: boolean } = {},
+): Promise<{ mode: string; state: any; pane: string; stateDir: string } | null> {
+  const dirs = await getScopedStateDirsForCurrentSession(stateDir, undefined, {
+    includeRootFallback: options.includeRootFallback !== false,
+  }).catch(() => [stateDir]);
   for (const dir of dirs) {
     for (const mode of allowedModes || []) {
       const path = join(dir, `${mode}-state.json`);
@@ -189,12 +191,18 @@ async function validateResolvedInjectionOwnership({
   return { ok: true };
 }
 
-async function readVisibleAllowedModes(
+export async function readVisibleAllowedModes(
   cwd: string,
   stateDir: string,
   payload: any,
   allowedModes: string[],
-): Promise<{ canonicalPresent: boolean; allowedSet: Set<string> | null; preferredMode: string | null }> {
+): Promise<{
+  canonicalPresent: boolean;
+  activeSkillCount: number;
+  allowedSet: Set<string> | null;
+  preferredMode: string | null;
+  sessionScoped: boolean;
+}> {
   const candidateSessionIds = [
     await readCurrentSessionId(stateDir).catch(() => undefined),
     resolveInvocationSessionId(payload),
@@ -203,41 +211,49 @@ async function readVisibleAllowedModes(
     .filter(Boolean);
 
   for (const sessionId of candidateSessionIds) {
-    const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+    const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
     if (!canonicalState) continue;
 
+    const activeSkills = listActiveSkills(canonicalState);
     const allowedSet = new Set(
-      listActiveSkills(canonicalState)
+      activeSkills
         .map((entry) => entry.skill)
         .filter((skill) => allowedModes.includes(skill)),
     );
     return {
       canonicalPresent: true,
+      activeSkillCount: activeSkills.length,
       allowedSet,
       preferredMode: pickActiveMode([...allowedSet], allowedModes),
+      sessionScoped: true,
     };
   }
 
   if (candidateSessionIds.length === 0) {
-    const rootCanonicalState = await readVisibleSkillActiveState(cwd).catch(() => null);
+    const rootCanonicalState = await readVisibleSkillActiveStateForStateDir(stateDir).catch(() => null);
     if (rootCanonicalState) {
+      const activeSkills = listActiveSkills(rootCanonicalState);
       const allowedSet = new Set(
-        listActiveSkills(rootCanonicalState)
+        activeSkills
           .map((entry) => entry.skill)
           .filter((skill) => allowedModes.includes(skill)),
       );
       return {
         canonicalPresent: true,
+        activeSkillCount: activeSkills.length,
         allowedSet,
         preferredMode: pickActiveMode([...allowedSet], allowedModes),
+        sessionScoped: false,
       };
     }
   }
 
   return {
     canonicalPresent: false,
+    activeSkillCount: 0,
     allowedSet: null,
     preferredMode: null,
+    sessionScoped: candidateSessionIds.length > 0,
   };
 }
 
@@ -415,10 +431,11 @@ export async function handleTmuxInjection({
   state.recent_keys = pruneRecentKeys(state.recent_keys, now);
   const canonicalModeState = await readVisibleAllowedModes(cwd, stateDir, payload, config.allowed_modes).catch(() => ({
     canonicalPresent: false,
+    activeSkillCount: 0,
     allowedSet: null,
     preferredMode: null,
   }));
-  if (canonicalModeState.canonicalPresent && !canonicalModeState.preferredMode) {
+  if (canonicalModeState.canonicalPresent && canonicalModeState.activeSkillCount > 0 && !canonicalModeState.preferredMode) {
     const nextState = {
       ...state,
       last_reason: 'mode_not_allowed',
@@ -468,12 +485,10 @@ export async function handleTmuxInjection({
     }
   };
   try {
-    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
+    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir, undefined, {
+      includeRootFallback: !canonicalModeState.canonicalPresent && !canonicalModeState.sessionScoped,
+    });
     await scanActiveModeStateDirs(scopedDirs);
-
-    if (!pickActiveMode(activeModes, config.allowed_modes) && !scannedStateDirs.has(resolvePath(stateDir))) {
-      await scanActiveModeStateDirs([stateDir], true);
-    }
   } catch {
     // Non-fatal
   }
@@ -483,6 +498,7 @@ export async function handleTmuxInjection({
     canonicalModeState.canonicalPresent
       ? (canonicalModeState.preferredMode ? [canonicalModeState.preferredMode] : [])
       : config.allowed_modes,
+    { includeRootFallback: !canonicalModeState.sessionScoped },
   ).catch(() => null);
   const mode = canonicalModeState.canonicalPresent
     ? canonicalModeState.preferredMode

package/src/scripts/notify-hook.ts

@@ -68,6 +68,11 @@ import {
 } from './notify-hook/team-worker.js';
 import { DEFAULT_MARKER } from './tmux-hook-engine.js';
 import { sameFilePath } from '../utils/paths.js';
+import {
+  MAX_NOTIFY_ARGV_JSON_BYTES,
+  extractRawJsonStringField,
+  utf8ByteLength,
+} from './hook-payload-guard.js';
 
 const RALPH_ACTIVE_PROGRESS_PHASES = new Set([
   'start',
@@ -257,6 +262,78 @@ function classifyIdleNotificationPhase(message: unknown): 'idle' | 'progress' |
   return 'idle';
 }
 
+
+function isExplicitAutopilotActivationText(text: string): boolean {
+  return /(?:^|[^\w])\$autopilot\b/i.test(text)
+    || /^\s*\/autopilot\b/i.test(text)
+    || /^\s*(?:please\s+)?autopilot(?:\s+(?:this|mode|workflow|skill|loop|now))?\s*[.!]?\s*$/i.test(text)
+    || /\b(?:use|run|start|enable|launch|invoke|activate|resume|continue)\s+(?:the\s+)?autopilot(?:\s+(?:mode|workflow|skill|loop|now))?\s*[.!]?\s*$/i.test(text)
+    || /\bautopilot\s+(?:mode|workflow|skill|loop)\b/i.test(text);
+}
+
+function looksLikeAutopilotTerminalHandoff(text: string): boolean {
+  return /\bAutopilot complete\b/i.test(text)
+    || /\btask_complete\b/i.test(text)
+    || /\bautopilot\b[\s\S]{0,120}\b(?:complete|completed|finished)\b/i.test(text);
+}
+
+function isTerminalModeStateObject(value: unknown, mode: string): boolean {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const state = value as Record<string, unknown>;
+  if (safeString(state.mode).trim() !== mode) return false;
+  if (state.active === true) return false;
+  const phase = safeString(state.current_phase || state.currentPhase).trim().toLowerCase().replace(/_/g, '-');
+  if (['complete', 'completed', 'failed', 'cancelled', 'canceled', 'stopped', 'user-stopped'].includes(phase)) return true;
+  const outcome = safeString(state.run_outcome || state.outcome || state.lifecycle_outcome || state.terminal_outcome).trim().toLowerCase();
+  return ['finish', 'finished', 'complete', 'completed', 'failed', 'cancelled', 'canceled'].includes(outcome)
+    || safeString(state.completed_at || state.completedAt).trim() !== '';
+}
+
+function terminalStateMatchesNotifyTurn(state: Record<string, unknown>, payload: Record<string, unknown>): boolean {
+  const payloadTurnId = safeString(payload['turn-id'] || payload.turn_id || '').trim();
+  const stateTurnId = safeString(state.turn_id || state.turnId || '').trim();
+  const payloadThreadId = safeString(payload['thread-id'] || payload.thread_id || '').trim();
+  const stateThreadId = safeString(state.thread_id || state.threadId || '').trim();
+
+  if (payloadTurnId || stateTurnId) {
+    if (!payloadTurnId || !stateTurnId || payloadTurnId !== stateTurnId) return false;
+    return !payloadThreadId || !stateThreadId || payloadThreadId === stateThreadId;
+  }
+
+  return Boolean(payloadThreadId && stateThreadId && payloadThreadId === stateThreadId);
+}
+
+async function hasTerminalAutopilotStateForNotifyTurn(
+  stateDir: string,
+  sessionId: string,
+  payload: Record<string, unknown>,
+): Promise<boolean> {
+  const state = await readScopedJsonIfExists(
+    stateDir,
+    'autopilot-state.json',
+    sessionId || undefined,
+    null,
+    { includeRootFallback: true },
+  );
+  return isTerminalModeStateObject(state, 'autopilot')
+    && terminalStateMatchesNotifyTurn(state as Record<string, unknown>, payload);
+}
+
+async function shouldSuppressAutopilotTerminalReplayActivation(
+  stateDir: string,
+  payload: Record<string, unknown>,
+  isAutopilotActivation: boolean,
+  sessionId: string,
+): Promise<boolean> {
+  if (!isTurnCompletePayload(payload) && !isNotifyFallbackTaskCompletePayload(payload)) return false;
+  if (!isAutopilotActivation) return false;
+
+  const lastAssistantMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
+  if (!looksLikeAutopilotTerminalHandoff(lastAssistantMessage) && !isNotifyFallbackTaskCompletePayload(payload)) return false;
+
+  return hasTerminalAutopilotStateForNotifyTurn(stateDir, sessionId, payload);
+}
+
 function buildIdleNotificationFingerprint(payload: Record<string, unknown>): string {
   const lastAssistantMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
   const summary = summarizeIdleNotificationMessage(lastAssistantMessage);
@@ -285,6 +362,9 @@ async function main() {
   if (!rawPayload || rawPayload.startsWith('-')) {
     process.exit(0);
   }
+  if (utf8ByteLength(rawPayload) > MAX_NOTIFY_ARGV_JSON_BYTES) {
+    process.exit(0);
+  }
 
   let payload;
   try {
@@ -633,16 +713,28 @@ 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 { detectKeywords, recordSkillActivation } = await import('../hooks/keyword-detector.js');
     if (latestUserInput) {
+      const activationSessionId = getEffectiveSessionId();
+      const isAutopilotActivation = detectKeywords(latestUserInput)
+        .some((match) => match.skill === 'autopilot')
+        || isExplicitAutopilotActivationText(latestUserInput);
+      const suppressTerminalReplay = await shouldSuppressAutopilotTerminalReplayActivation(
+        stateDir,
+        payload,
+        isAutopilotActivation,
+        activationSessionId,
+      );
+      if (!suppressTerminalReplay) {
         await recordSkillActivation({
           stateDir,
           sourceCwd: cwd,
           text: latestUserInput,
-          sessionId: getEffectiveSessionId(),
+          sessionId: activationSessionId,
           threadId: payloadThreadId,
           turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
         });
+      }
     }
   } catch {
     // Non-fatal: keyword detector module may not be built yet
@@ -654,8 +746,11 @@ async function main() {
     // Non-fatal: lifecycle sync should not block the hook
   }
 
-  const deepInterviewStateActive = await isDeepInterviewStateActive(stateDir, getEffectiveSessionId());
-  const deepInterviewInputLockActive = await isDeepInterviewInputLockActive(stateDir, getEffectiveSessionId());
+  const effectiveSessionId = getEffectiveSessionId();
+  const deepInterviewStateActive = effectiveSessionId
+    ? await isDeepInterviewStateActive(stateDir, effectiveSessionId)
+    : await isDeepInterviewStateActive(stateDir, undefined);
+  const deepInterviewInputLockActive = await isDeepInterviewInputLockActive(stateDir, effectiveSessionId);
 
   // 4.55. Notify leader when individual worker transitions to idle (worker session only)
   if (isTeamWorker && parsedTeamWorker && !deepInterviewStateActive) {
@@ -909,8 +1004,12 @@ async function logFatalNotifyHookError(err: unknown): Promise<void> {
   try {
     const rawPayload = process.argv[process.argv.length - 1];
     if (rawPayload && !rawPayload.startsWith('-')) {
-      const payload = JSON.parse(rawPayload) as Record<string, unknown>;
-      cwd = safeString(payload.cwd || payload['cwd'] || cwd) || cwd;
+      if (utf8ByteLength(rawPayload) <= MAX_NOTIFY_ARGV_JSON_BYTES) {
+        const payload = JSON.parse(rawPayload) as Record<string, unknown>;
+        cwd = safeString(payload.cwd || payload['cwd'] || cwd) || cwd;
+      } else {
+        cwd = extractRawJsonStringField(rawPayload, ['cwd']) || cwd;
+      }
     }
   } catch {
     // Keep notification hook failures silent in Codex TUI surfaces.