oh-my-codex 0.8.11 → 0.8.13

package/scripts/notify-fallback-watcher.js

@@ -6,6 +6,14 @@ import { spawnSync } from 'child_process';
 import { dirname, join, resolve } from 'path';
 import { homedir } from 'os';
 import { drainPendingTeamDispatch } from './notify-hook/team-dispatch.js';
+import { resolveNudgePaneTarget } from './notify-hook/auto-nudge.js';
+import { checkPaneReadyForTeamSendKeys } from './notify-hook/team-tmux-guard.js';
+import {
+  isLeaderStale,
+  maybeNudgeTeamLeader,
+  resolveLeaderStalenessThresholdMs,
+} from './notify-hook/team-leader-nudge.js';
+import { DEFAULT_MARKER } from './tmux-hook-engine.js';
 
 function argValue(name, fallback = '') {
   const idx = process.argv.indexOf(name);
@@ -35,7 +43,10 @@ function isPidAlive(pid) {
 const cwd = resolve(argValue('--cwd', process.cwd()));
 const notifyScript = resolve(argValue('--notify-script', join(cwd, 'scripts', 'notify-hook.js')));
 const runOnce = process.argv.includes('--once');
-const pollMs = Math.max(50, asNumber(argValue('--poll-ms', '700'), 700));
+// Keep fallback control-plane ticks comfortably below the default dispatch
+// ack budget so leaderless team dispatch + stale-alert recovery do not feel
+// laggy between native notify-hook turns.
+const pollMs = Math.max(50, asNumber(argValue('--poll-ms', '250'), 250));
 const parentPid = Math.trunc(asNumber(argValue('--parent-pid', String(process.ppid || 0)), process.ppid || 0));
 const startedAt = Date.now();
 const fileWindowMs = runOnce ? 15000 : 30000;
@@ -56,6 +67,9 @@ const stateDir = join(omxDir, 'state');
 const statePath = join(stateDir, 'notify-fallback-state.json');
 const pidFilePath = resolve(argValue('--pid-file', join(stateDir, 'notify-fallback.pid')));
 const logPath = join(logsDir, `notify-fallback-${new Date().toISOString().split('T')[0]}.jsonl`);
+const RALPH_CONTINUE_TEXT = 'Ralph loop active continue';
+const RALPH_CONTINUE_CADENCE_MS = 60_000;
+const RALPH_TERMINAL_PHASES = new Set(['complete', 'failed', 'cancelled']);
 
 const fileState = new Map();
 const seenTurnKeys = new Set();
@@ -69,11 +83,185 @@ let lastDispatchDrain = {
   last_result: null,
   last_error: null,
 };
+let leaderNudgeRuns = 0;
+let lastLeaderNudge = {
+  enabled: true,
+  leader_only: safeString(process.env.OMX_TEAM_WORKER || '').trim() === '',
+  stale_threshold_ms: null,
+  precomputed_leader_stale: null,
+  last_tick_at: null,
+  last_error: null,
+};
+let lastRalphContinueSteer = {
+  enabled: true,
+  cadence_ms: RALPH_CONTINUE_CADENCE_MS,
+  message: RALPH_CONTINUE_TEXT,
+  active: false,
+  last_state_check_at: null,
+  last_sent_at: '',
+  last_reason: 'init',
+  state_path: '',
+  pane_id: '',
+  pane_current_command: '',
+  current_phase: '',
+};
+let lastParentGuard = {
+  reason: '',
+  state_path: '',
+  current_phase: '',
+};
 
 function eventLog(event) {
   return appendFile(logPath, `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`).catch(() => {});
 }
 
+function normalizeRalphContinueSteerState(raw) {
+  if (!raw || typeof raw !== 'object') return { ...lastRalphContinueSteer };
+  return {
+    enabled: raw.enabled !== false,
+    cadence_ms: Number.isFinite(raw.cadence_ms) && raw.cadence_ms > 0 ? raw.cadence_ms : RALPH_CONTINUE_CADENCE_MS,
+    message: safeString(raw.message) || RALPH_CONTINUE_TEXT,
+    active: raw.active === true,
+    last_state_check_at: safeString(raw.last_state_check_at) || null,
+    last_sent_at: safeString(raw.last_sent_at),
+    last_reason: safeString(raw.last_reason) || 'init',
+    state_path: safeString(raw.state_path),
+    pane_id: safeString(raw.pane_id),
+    pane_current_command: safeString(raw.pane_current_command),
+    current_phase: safeString(raw.current_phase),
+  };
+}
+
+function hasRalphTerminalState(raw) {
+  if (!raw || typeof raw !== 'object') return true;
+  if (raw.active !== true) return true;
+  const phase = safeString(raw.current_phase).trim().toLowerCase();
+  if (phase && RALPH_TERMINAL_PHASES.has(phase)) return true;
+  if (safeString(raw.completed_at).trim()) return true;
+  return false;
+}
+
+async function loadPersistedWatcherState() {
+  const persisted = await readFile(statePath, 'utf-8')
+    .then((content) => JSON.parse(content))
+    .catch(() => null);
+  lastRalphContinueSteer = normalizeRalphContinueSteerState(persisted?.ralph_continue_steer);
+}
+
+async function resolveActiveRalphState() {
+  const candidateDirs = [];
+  const sessionPath = join(stateDir, 'session.json');
+  try {
+    const session = JSON.parse(await readFile(sessionPath, 'utf-8'));
+    const sessionId = safeString(session?.session_id).trim();
+    if (sessionId) {
+      candidateDirs.push(join(stateDir, 'sessions', sessionId));
+    }
+  } catch {
+    // No active session file; fall back to root state only.
+  }
+  if (!candidateDirs.includes(stateDir)) candidateDirs.push(stateDir);
+
+  for (const dir of candidateDirs) {
+    const path = join(dir, 'ralph-state.json');
+    if (!existsSync(path)) continue;
+    const parsed = await readFile(path, 'utf-8')
+      .then((content) => JSON.parse(content))
+      .catch(() => null);
+    if (!parsed || typeof parsed !== 'object') continue;
+    if (hasRalphTerminalState(parsed)) {
+      return {
+        active: false,
+        reason: 'terminal',
+        path,
+        state: parsed,
+      };
+    }
+    return {
+      active: true,
+      reason: 'active',
+      path,
+      state: parsed,
+    };
+  }
+
+  return {
+    active: false,
+    reason: 'cleared',
+    path: '',
+    state: null,
+  };
+}
+
+async function emitRalphContinueSteer(paneId, message) {
+  const markedText = `${message} ${DEFAULT_MARKER}`;
+  await new Promise((resolve) => {
+    const typed = spawnSync('tmux', ['send-keys', '-t', paneId, '-l', markedText], { encoding: 'utf-8' });
+    if (typed.status !== 0) throw new Error((typed.stderr || typed.stdout || '').trim() || 'tmux send-keys failed');
+    setTimeout(resolve, 100);
+  });
+  await new Promise((resolve) => {
+    const submitA = spawnSync('tmux', ['send-keys', '-t', paneId, 'C-m'], { encoding: 'utf-8' });
+    if (submitA.status !== 0) throw new Error((submitA.stderr || submitA.stdout || '').trim() || 'tmux send-keys C-m failed');
+    setTimeout(resolve, 100);
+  });
+  const submitB = spawnSync('tmux', ['send-keys', '-t', paneId, 'C-m'], { encoding: 'utf-8' });
+  if (submitB.status !== 0) {
+    throw new Error((submitB.stderr || submitB.stdout || '').trim() || 'tmux send-keys C-m failed');
+  }
+}
+
+async function runRalphContinueSteerTick() {
+  const now = Date.now();
+  const nowIso = new Date(now).toISOString();
+  const activeRalph = await resolveActiveRalphState();
+  lastRalphContinueSteer = {
+    ...lastRalphContinueSteer,
+    active: activeRalph.active,
+    current_phase: safeString(activeRalph.state?.current_phase),
+    last_state_check_at: nowIso,
+    last_reason: activeRalph.reason,
+    state_path: activeRalph.path,
+    pane_current_command: '',
+  };
+
+  if (!activeRalph.active) return;
+
+  const lastSentMs = Date.parse(lastRalphContinueSteer.last_sent_at);
+  if (Number.isFinite(lastSentMs) && now - lastSentMs < RALPH_CONTINUE_CADENCE_MS) {
+    lastRalphContinueSteer.last_reason = 'cooldown';
+    return;
+  }
+
+  const paneId = safeString(activeRalph.state?.tmux_pane_id).trim() || await resolveNudgePaneTarget(stateDir);
+  if (!paneId) {
+    lastRalphContinueSteer.last_reason = 'pane_missing';
+    lastRalphContinueSteer.pane_id = '';
+    return;
+  }
+
+  const paneGuard = await checkPaneReadyForTeamSendKeys(paneId);
+  lastRalphContinueSteer.pane_id = paneId;
+  lastRalphContinueSteer.pane_current_command = paneGuard.paneCurrentCommand || '';
+  if (!paneGuard.ok) {
+    lastRalphContinueSteer.last_reason = paneGuard.reason || 'pane_guard_blocked';
+    return;
+  }
+
+  await emitRalphContinueSteer(paneId, RALPH_CONTINUE_TEXT);
+  lastRalphContinueSteer.last_sent_at = nowIso;
+  lastRalphContinueSteer.last_reason = 'sent';
+  await eventLog({
+    type: 'ralph_continue_steer',
+    reason: 'sent',
+    pane_id: paneId,
+    state_path: activeRalph.path,
+    current_phase: safeString(activeRalph.state?.current_phase) || null,
+    cadence_ms: RALPH_CONTINUE_CADENCE_MS,
+    message: RALPH_CONTINUE_TEXT,
+  });
+}
+
 async function readPidFilePid(path) {
   const raw = await readFile(path, 'utf-8');
   const trimmed = raw.trim();
@@ -151,6 +339,17 @@ async function writeState(extra = {}) {
       run_count: dispatchDrainRuns,
       ...lastDispatchDrain,
     },
+    leader_nudge: {
+      enabled: true,
+      run_count: leaderNudgeRuns,
+      ...lastLeaderNudge,
+    },
+    ralph_continue_steer: {
+      ...lastRalphContinueSteer,
+      enabled: true,
+      cadence_ms: RALPH_CONTINUE_CADENCE_MS,
+      message: RALPH_CONTINUE_TEXT,
+    },
     ...extra,
   };
   await writeFile(statePath, JSON.stringify(state, null, 2)).catch(() => {});
@@ -177,6 +376,30 @@ async function requestShutdown(reason, signal = null) {
 async function enforceLifecycleGuards() {
   if (runOnce) return false;
   if (parentIsGone()) {
+    const activeRalph = await resolveActiveRalphState();
+    if (activeRalph.active) {
+      const currentPhase = safeString(activeRalph.state?.current_phase);
+      const nextParentGuard = {
+        reason: 'parent_gone_deferred_for_active_ralph',
+        state_path: activeRalph.path,
+        current_phase: currentPhase,
+      };
+      if (
+        lastParentGuard.reason !== nextParentGuard.reason
+        || lastParentGuard.state_path !== nextParentGuard.state_path
+        || lastParentGuard.current_phase !== nextParentGuard.current_phase
+      ) {
+        await eventLog({
+          type: 'watcher_parent_guard',
+          reason: nextParentGuard.reason,
+          state_path: nextParentGuard.state_path,
+          current_phase: currentPhase || null,
+        });
+        lastParentGuard = nextParentGuard;
+      }
+      return false;
+    }
+    lastParentGuard = { reason: '', state_path: '', current_phase: '' };
     await requestShutdown('parent_gone');
     return true;
   }
@@ -340,6 +563,72 @@ async function pollFiles() {
   }
 }
 
+async function runLeaderNudgeTick() {
+  const startedIso = new Date().toISOString();
+  const leaderOnly = safeString(process.env.OMX_TEAM_WORKER || '').trim() === '';
+  const staleThresholdMs = resolveLeaderStalenessThresholdMs();
+
+  if (!leaderOnly) {
+    leaderNudgeRuns += 1;
+    lastLeaderNudge = {
+      enabled: true,
+      leader_only: false,
+      stale_threshold_ms: staleThresholdMs,
+      precomputed_leader_stale: null,
+      last_tick_at: startedIso,
+      last_error: 'worker_context',
+    };
+    await eventLog({
+      type: 'leader_nudge_tick',
+      leader_only: false,
+      run_count: leaderNudgeRuns,
+      reason: 'worker_context',
+      stale_threshold_ms: staleThresholdMs,
+    });
+    return;
+  }
+
+  try {
+    const preComputedLeaderStale = await isLeaderStale(stateDir, staleThresholdMs, Date.now());
+    await maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderStale });
+    leaderNudgeRuns += 1;
+    lastLeaderNudge = {
+      enabled: true,
+      leader_only: true,
+      stale_threshold_ms: staleThresholdMs,
+      precomputed_leader_stale: preComputedLeaderStale,
+      last_tick_at: startedIso,
+      last_error: null,
+    };
+    await eventLog({
+      type: 'leader_nudge_tick',
+      leader_only: true,
+      run_count: leaderNudgeRuns,
+      stale_threshold_ms: staleThresholdMs,
+      precomputed_leader_stale: preComputedLeaderStale,
+      reason: 'leader_nudge_checked',
+    });
+  } catch (err) {
+    leaderNudgeRuns += 1;
+    lastLeaderNudge = {
+      enabled: true,
+      leader_only: true,
+      stale_threshold_ms: staleThresholdMs,
+      precomputed_leader_stale: null,
+      last_tick_at: startedIso,
+      last_error: err instanceof Error ? err.message : safeString(err),
+    };
+    await eventLog({
+      type: 'leader_nudge_tick',
+      leader_only: true,
+      run_count: leaderNudgeRuns,
+      stale_threshold_ms: staleThresholdMs,
+      reason: 'leader_nudge_failed',
+      error: lastLeaderNudge.last_error,
+    });
+  }
+}
+
 async function runDispatchDrainTick() {
   const startedIso = new Date().toISOString();
   try {
@@ -383,6 +672,8 @@ async function tick() {
   await ensureTrackedFiles();
   await pollFiles();
   await runDispatchDrainTick();
+  await runLeaderNudgeTick();
+  await runRalphContinueSteerTick();
   await writeState();
   if (await enforceLifecycleGuards()) return;
   setTimeout(() => {
@@ -403,6 +694,7 @@ async function main() {
   }
 
   await registerPidFile();
+  await loadPersistedWatcherState();
   await eventLog({
     type: 'watcher_start',
     cwd,
@@ -423,6 +715,8 @@ async function main() {
     await ensureTrackedFiles();
     await pollFiles();
     await runDispatchDrainTick();
+    await runLeaderNudgeTick();
+    await runRalphContinueSteerTick();
     await writeState();
     await eventLog({ type: 'watcher_once_complete', seen_turns: seenTurnKeys.size });
     process.exit(0);

package/scripts/notify-hook/auto-nudge.js

@@ -10,7 +10,8 @@ import { asNumber, safeString } from './utils.js';
 import { readJsonIfExists, getScopedStateDirsForCurrentSession, readdir } from './state-io.js';
 import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
-import { DEFAULT_MARKER } from '../tmux-hook-engine.js';
+import { checkPaneReadyForTeamSendKeys } from './team-tmux-guard.js';
+import { buildCapturePaneArgv, DEFAULT_MARKER } from '../tmux-hook-engine.js';
 
 export const SKILL_ACTIVE_STATE_FILE = 'skill-active-state.json';
 export const DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS = ['yes', 'y', 'proceed', 'continue', 'ok', 'sure', 'go ahead', 'next i should'];
@@ -178,6 +179,8 @@ export const DEFAULT_STALL_PATTERNS = [
   'would you like',
   'shall i',
   'next i can',
+  'continue with',
+  'continue on',
   'do you want me to',
   'let me know if',
   'do you want',
@@ -186,6 +189,9 @@ export const DEFAULT_STALL_PATTERNS = [
   'just let me know',
   'i can also',
   'i could also',
+  'pick up with',
+  'next step',
+  'next steps',
   'ready to proceed',
   'should i',
   'whenever you',
@@ -249,9 +255,7 @@ export function detectStallPattern(text, patterns) {
 
 export async function capturePane(paneId, lines = 10) {
   try {
-    const result = await runProcess('tmux', [
-      'capture-pane', '-t', paneId, '-p', '-l', String(lines),
-    ], 3000);
+    const result = await runProcess('tmux', buildCapturePaneArgv(paneId, lines), 3000);
     return result.stdout || '';
   } catch {
     return '';
@@ -336,6 +340,18 @@ export async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
     if (skillState?.phase === 'completing' && !detected) return;
     if (!detected || !paneId) return;
 
+    const paneGuard = await checkPaneReadyForTeamSendKeys(paneId);
+    if (!paneGuard.ok) {
+      await logTmuxHookEvent(logsDir, {
+        timestamp: new Date().toISOString(),
+        type: 'auto_nudge_skipped',
+        pane_id: paneId,
+        reason: paneGuard.reason,
+        source,
+      }).catch(() => {});
+      return;
+    }
+
     const deepInterviewLockActive = isDeepInterviewAutoApprovalLocked(skillState) && !releaseReason;
     if (deepInterviewLockActive && isBlockedAutoApprovalInput(config.response, skillState.input_lock?.blocked_inputs)) {
       const blockedMessage = skillState.input_lock?.message || DEEP_INTERVIEW_INPUT_LOCK_MESSAGE;

package/scripts/notify-hook/team-dispatch.js

@@ -4,7 +4,14 @@ import { dirname, join, resolve } from 'path';
 import { safeString } from './utils.js';
 import { runProcess } from './process-runner.js';
 import { resolvePaneTarget } from './tmux-injection.js';
-import { buildCapturePaneArgv, buildPaneInModeArgv, buildSendKeysArgv } from '../tmux-hook-engine.js';
+import {
+  buildCapturePaneArgv,
+  buildPaneInModeArgv,
+  buildSendKeysArgv,
+  normalizeTmuxCapture,
+  paneHasActiveTask,
+  paneLooksReady,
+} from '../tmux-hook-engine.js';
 
 function readJson(path, fallback) {
   return readFile(path, 'utf8')
@@ -260,18 +267,14 @@ function resolveWorkerCliForRequest(request, config) {
   return 'codex';
 }
 
-function normalizeCaptureText(value) {
-  return safeString(value).replace(/\r/g, '').replace(/\s+/g, ' ').trim();
-}
-
 function capturedPaneContainsTrigger(captured, trigger) {
   if (!captured || !trigger) return false;
-  return normalizeCaptureText(captured).includes(normalizeCaptureText(trigger));
+  return normalizeTmuxCapture(captured).includes(normalizeTmuxCapture(trigger));
 }
 
 function capturedPaneContainsTriggerNearTail(captured, trigger, nonEmptyTailLines = 24) {
   if (!captured || !trigger) return false;
-  const normalizedTrigger = normalizeCaptureText(trigger);
+  const normalizedTrigger = normalizeTmuxCapture(trigger);
   if (!normalizedTrigger) return false;
   const lines = safeString(captured)
     .split('\n')
@@ -279,57 +282,7 @@ function capturedPaneContainsTriggerNearTail(captured, trigger, nonEmptyTailLine
     .filter((line) => line.length > 0);
   if (lines.length === 0) return false;
   const tail = lines.slice(-Math.max(1, nonEmptyTailLines)).join(' ');
-  return normalizeCaptureText(tail).includes(normalizedTrigger);
-}
-
-// Ported from src/team/tmux-session.ts:949-963 — detects active CLI task indicators.
-function paneHasActiveTask(captured) {
-  const lines = safeString(captured)
-    .split('\n')
-    .map((line) => line.replace(/\r/g, '').trim())
-    .filter((line) => line.length > 0);
-  const tail = lines.slice(-40);
-  if (tail.some((line) => /\b\d+\s+background terminal running\b/i.test(line))) return true;
-  if (tail.some((line) => /esc to interrupt/i.test(line))) return true;
-  if (tail.some((line) => /\bbackground terminal running\b/i.test(line))) return true;
-  if (tail.some((line) => /^•\s.+\(.+•\s*esc to interrupt\)$/i.test(line))) return true;
-  // Claude active generation lines
-  if (tail.some((line) => /^[·✻]\s+[A-Za-z][A-Za-z0-9''-]*(?:\s+[A-Za-z][A-Za-z0-9''-]*){0,3}(?:…|\.{3})$/u.test(line))) return true;
-  return false;
-}
-
-function paneIsBootstrapping(captured) {
-  const lines = safeString(captured)
-    .split('\n')
-    .map((line) => line.replace(/\r/g, '').trim())
-    .filter((line) => line.length > 0);
-  return lines.some((line) =>
-    /\b(loading|initializing|starting up)\b/i.test(line)
-    || /\bmodel:\s*loading\b/i.test(line)
-    || /\bconnecting\s+to\b/i.test(line),
-  );
-}
-
-function paneLooksReady(captured) {
-  const content = safeString(captured).trimEnd();
-  if (content === '') return false;
-
-  const lines = content
-    .split('\n')
-    .map((line) => line.replace(/\r/g, ''))
-    .map((line) => line.trimEnd())
-    .filter((line) => line.trim() !== '');
-
-  if (paneIsBootstrapping(content)) return false;
-
-  const lastLine = lines.length > 0 ? lines[lines.length - 1] : '';
-  if (/^\s*[›>❯]\s*/u.test(lastLine)) return true;
-
-  const hasCodexPromptLine = lines.some((line) => /^\s*›\s*/u.test(line));
-  const hasClaudePromptLine = lines.some((line) => /^\s*❯\s*/u.test(line));
-  if (hasCodexPromptLine || hasClaudePromptLine) return true;
-
-  return false;
+  return normalizeTmuxCapture(tail).includes(normalizedTrigger);
 }
 
 const INJECT_VERIFY_DELAY_MS = 250;

package/scripts/notify-hook/team-leader-nudge.js

@@ -53,6 +53,40 @@ export function resolveLeaderProgressStallThresholdMs() {
   return 120_000;
 }
 
+function buildStatusCheckReminder(teamName) {
+  return `Next: check messages; keep orchestrating; if done, gracefully shut down: omx team shutdown ${teamName}.`;
+}
+
+function buildMailboxCheckReminder(teamName) {
+  return `Next: read messages; keep orchestrating; if done, gracefully shut down: omx team shutdown ${teamName}.`;
+}
+
+function buildWorkerStartEvidenceReminder(teamName, workerName) {
+  return `Next: check ${workerName} msg/output, confirm task in omx team status ${teamName}, then reassign/nudge.`;
+}
+
+function buildLeaderActionGuidance(teamName, {
+  allWorkersIdle = false,
+  workerPanesAlive = false,
+  taskCounts = {},
+} = {}) {
+  const pending = Number.isFinite(taskCounts.pending) ? taskCounts.pending : 0;
+  const blocked = Number.isFinite(taskCounts.blocked) ? taskCounts.blocked : 0;
+  const inProgress = Number.isFinite(taskCounts.in_progress) ? taskCounts.in_progress : 0;
+  const tasksComplete = pending === 0 && blocked === 0 && inProgress === 0;
+  const pendingFollowUpTasks = allWorkersIdle && pending > 0 && blocked === 0 && inProgress === 0;
+
+  if (pendingFollowUpTasks) {
+    return workerPanesAlive
+      ? 'Next: assign the next follow-up task to this idle team.'
+      : 'Next: launch a new team for the next task set.';
+  }
+  if (allWorkersIdle && tasksComplete) {
+    return `Next: omx team shutdown ${teamName}.`;
+  }
+  return buildStatusCheckReminder(teamName);
+}
+
 export async function checkWorkerPanesAlive(tmuxTarget, workerPaneIds = []) {
   const sessionName = tmuxTarget.split(':')[0];
   try {
@@ -492,6 +526,11 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
       : [];
     const allWorkersIdle = workerStates.length > 0 && workerStates.every((state) => state === 'idle' || state === 'done');
     const progressSnapshot = await readTeamProgressSnapshot(stateDir, teamName, workerNames);
+    const leaderActionGuidance = buildLeaderActionGuidance(teamName, {
+      allWorkersIdle,
+      workerPanesAlive: paneStatus.alive,
+      taskCounts: progressSnapshot.taskCounts,
+    });
     const prevProgress = nudgeState.progress_by_team[teamName] && typeof nudgeState.progress_by_team[teamName] === 'object'
       ? nudgeState.progress_by_team[teamName]
       : {};
@@ -543,7 +582,10 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     // Stale-leader follow-up is the only periodic visible nudge path.
     // This keeps the leader pane quieter when the leader is not actually stale.
     const stalePanesNudge = paneStatus.alive && leaderStale;
-    const stalledTeamNudge = teamProgressStalled && leaderStale && (dueByTime || prevReason !== 'leader_stale_with_stalled_team');
+    const stalledTeamReason = leaderStale ? 'leader_stale_with_stalled_team' : 'stalled_team_progress';
+    const previousStalledTeamNudge =
+      prevReason === 'leader_stale_with_stalled_team' || prevReason === 'stalled_team_progress';
+    const stalledTeamNudge = teamProgressStalled && (dueByTime || !previousStalledTeamNudge);
     const staleFollowupDue = stalePanesNudge && dueByTime;
 
     if (!shouldSendAllIdleNudge && !hasNewMessage && !stalledTeamNudge && !staleFollowupDue) continue;
@@ -553,32 +595,37 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     if (shouldSendAllIdleNudge) {
       nudgeReason = 'all_workers_idle';
       const N = workerNames.length;
-      text = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. Ready for next instructions.`;
+      text = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. ${leaderActionGuidance}`;
     } else if (ackWithoutStartEvidence) {
       nudgeReason = ACK_WITHOUT_START_EVIDENCE_REASON;
       text =
         `Team ${teamName}: ${ackWithoutStartEvidence.worker} said "${ackWithoutStartEvidence.body}" `
-        + `but has no work-start evidence yet (status: ${ackWithoutStartEvidence.statusState}, no owned in_progress task). `
-        + `Run: omx team status ${teamName}`;
+        + `but has no start evidence (status: ${ackWithoutStartEvidence.statusState}). `
+        + buildWorkerStartEvidenceReminder(teamName, ackWithoutStartEvidence.worker);
     } else if (stalledTeamNudge) {
-      nudgeReason = 'leader_stale_with_stalled_team';
+      nudgeReason = stalledTeamReason;
       const { pending, in_progress, blocked } = progressSnapshot.taskCounts;
       const missingSignals = progressSnapshot.missingSignalWorkers > 0
-        ? `; ${progressSnapshot.missingSignalWorkers} worker signal${progressSnapshot.missingSignalWorkers === 1 ? '' : 's'} missing`
+        ? `; ${progressSnapshot.missingSignalWorkers} signal${progressSnapshot.missingSignalWorkers === 1 ? '' : 's'} missing`
         : '';
+      const stallPrefix = leaderStale ? 'leader stale, ' : 'worker panes stalled, ';
       text =
-        `Team ${teamName}: leader stale, no team progress for ${formatDurationMs(stalledForMs)} `
-        + `(pending:${pending} in_progress:${in_progress} blocked:${blocked}${missingSignals}). `
-        + `Run: omx team status ${teamName}`;
+        `Team ${teamName}: ${stallPrefix}no progress ${formatDurationMs(stalledForMs)}. `
+        + `${leaderActionGuidance} `
+        + `(p:${pending} ip:${in_progress} b:${blocked}${missingSignals})`;
     } else if (stalePanesNudge && hasNewMessage) {
       nudgeReason = 'stale_leader_with_messages';
-      text = `Team ${teamName}: leader stale, ${paneStatus.paneCount} pane(s) active, ${messages.length} msg(s) pending. Run: omx team status ${teamName}`;
+      text =
+        `Team ${teamName}: leader stale, ${paneStatus.paneCount} pane(s) active, ${messages.length} msg(s) pending. `
+        + buildMailboxCheckReminder(teamName);
     } else if (staleFollowupDue) {
       nudgeReason = 'stale_leader_panes_alive';
-      text = `Team ${teamName}: leader stale, ${paneStatus.paneCount} worker pane(s) still active. Run: omx team status ${teamName}`;
+      text =
+        `Team ${teamName}: leader stale, ${paneStatus.paneCount} worker pane(s) still active. `
+        + leaderActionGuidance;
     } else if (hasNewMessage) {
       nudgeReason = 'new_mailbox_message';
-      text = `Team ${teamName}: ${messages.length} msg(s) for leader. Run: omx team status ${teamName}`;
+      text = `Team ${teamName}: ${messages.length} msg(s) for leader. ${buildMailboxCheckReminder(teamName)}`;
     } else {
       continue;
     }