oh-my-codex 0.5.1 → 0.6.0

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

@@ -19,6 +19,14 @@ export function resolveLeaderNudgeIntervalMs() {
   return 120_000;
 }
 
+export function resolveLeaderAllIdleNudgeCooldownMs() {
+  const raw = safeString(process.env.OMX_TEAM_LEADER_ALL_IDLE_COOLDOWN_MS || '');
+  const parsed = asNumber(raw);
+  // Default: 30 seconds.
+  if (parsed !== null && parsed >= 5_000 && parsed <= 10 * 60_000) return parsed;
+  return 30_000;
+}
+
 export function resolveLeaderStalenessThresholdMs() {
   const raw = safeString(process.env.OMX_TEAM_LEADER_STALE_MS || '');
   const parsed = asNumber(raw);
@@ -52,6 +60,36 @@ export async function isLeaderStale(stateDir, thresholdMs, nowMs) {
   return (nowMs - lastMs) >= thresholdMs;
 }
 
+async function readWorkerStatusState(stateDir, teamName, workerName) {
+  if (!workerName) return 'unknown';
+  const path = join(stateDir, 'team', teamName, 'workers', workerName, 'status.json');
+  try {
+    if (!existsSync(path)) return 'unknown';
+    const parsed = JSON.parse(await readFile(path, 'utf-8'));
+    return safeString(parsed && parsed.state ? parsed.state : 'unknown') || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+function normalizeMailboxMessages(rawMailbox) {
+  if (Array.isArray(rawMailbox)) return rawMailbox;
+  if (rawMailbox && typeof rawMailbox === 'object' && Array.isArray(rawMailbox.messages)) {
+    return rawMailbox.messages;
+  }
+  return [];
+}
+
+function normalizeMessageIdentity(msg) {
+  if (!msg || typeof msg !== 'object') return '';
+  const explicitId = safeString(msg.message_id || '').trim();
+  if (explicitId) return explicitId;
+  const createdAt = safeString(msg.created_at || msg.timestamp || '').trim();
+  const from = safeString(msg.from_worker || msg.from || '').trim();
+  const body = safeString(msg.body || '').trim();
+  return [createdAt, from, body].filter(Boolean).join('|');
+}
+
 export async function emitTeamNudgeEvent(cwd, teamName, reason, nowIso) {
   const eventsDir = join(cwd, '.omx', 'state', 'team', teamName, 'events');
   const eventsPath = join(eventsDir, 'events.ndjson');
@@ -73,6 +111,7 @@ export async function emitTeamNudgeEvent(cwd, teamName, reason, nowIso) {
 
 export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderStale }) {
   const intervalMs = resolveLeaderNudgeIntervalMs();
+  const idleCooldownMs = resolveLeaderAllIdleNudgeCooldownMs();
   const nowMs = Date.now();
   const nowIso = new Date().toISOString();
   const omxDir = join(cwd, '.omx');
@@ -85,6 +124,9 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
   if (!nudgeState.last_nudged_by_team || typeof nudgeState.last_nudged_by_team !== 'object') {
     nudgeState.last_nudged_by_team = {};
   }
+  if (!nudgeState.last_idle_nudged_by_team || typeof nudgeState.last_idle_nudged_by_team !== 'object') {
+    nudgeState.last_idle_nudged_by_team = {};
+  }
 
   const activeTeamNames = new Set();
   try {
@@ -105,21 +147,28 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
   const leaderStale = typeof preComputedLeaderStale === 'boolean' ? preComputedLeaderStale : false;
 
   for (const teamName of activeTeamNames) {
-    let tmuxTarget = '';
+    let tmuxSession = '';
+    let leaderPaneId = '';
+    let workers = [];
     try {
       const manifestPath = join(omxDir, 'state', 'team', teamName, 'manifest.v2.json');
       const configPath = join(omxDir, 'state', 'team', teamName, 'config.json');
       const srcPath = existsSync(manifestPath) ? manifestPath : configPath;
       if (existsSync(srcPath)) {
         const raw = JSON.parse(await readFile(srcPath, 'utf-8'));
-        tmuxTarget = safeString(raw && raw.tmux_session ? raw.tmux_session : '').trim();
+        tmuxSession = safeString(raw && raw.tmux_session ? raw.tmux_session : '').trim();
+        leaderPaneId = safeString(raw && raw.leader_pane_id ? raw.leader_pane_id : '').trim();
+        if (Array.isArray(raw && raw.workers)) workers = raw.workers;
       }
     } catch {
       // ignore
     }
+    const tmuxTarget = leaderPaneId || tmuxSession;
     if (!tmuxTarget) continue;
 
-    const paneStatus = await checkWorkerPanesAlive(tmuxTarget);
+    const paneStatus = tmuxSession
+      ? await checkWorkerPanesAlive(tmuxSession)
+      : { alive: false, paneCount: 0 };
 
     let mailbox = null;
     try {
@@ -128,9 +177,17 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     } catch {
       mailbox = null;
     }
-    const messages = mailbox && Array.isArray(mailbox.messages) ? mailbox.messages : [];
+    const messages = normalizeMailboxMessages(mailbox);
     const newest = messages.length > 0 ? messages[messages.length - 1] : null;
-    const newestId = newest && typeof newest.message_id === 'string' ? newest.message_id : '';
+    const newestId = normalizeMessageIdentity(newest);
+
+    const workerNames = Array.isArray(workers)
+      ? workers.map((w) => safeString(w && w.name ? w.name : '')).filter(Boolean)
+      : [];
+    const workerStates = workerNames.length > 0
+      ? await Promise.all(workerNames.map((workerName) => readWorkerStatusState(stateDir, teamName, workerName)))
+      : [];
+    const allWorkersIdle = workerStates.length > 0 && workerStates.every((state) => state === 'idle' || state === 'done');
 
     const prev = nudgeState.last_nudged_by_team[teamName] && typeof nudgeState.last_nudged_by_team[teamName] === 'object'
       ? nudgeState.last_nudged_by_team[teamName]
@@ -142,14 +199,26 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     const hasNewMessage = newestId && newestId !== prevMsgId;
     const dueByTime = !Number.isFinite(prevAtMs) || (nowMs - prevAtMs >= intervalMs);
 
+    const prevIdle = nudgeState.last_idle_nudged_by_team[teamName] && typeof nudgeState.last_idle_nudged_by_team[teamName] === 'object'
+      ? nudgeState.last_idle_nudged_by_team[teamName]
+      : {};
+    const prevIdleAtIso = safeString(prevIdle.at || '');
+    const prevIdleAtMs = prevIdleAtIso ? Date.parse(prevIdleAtIso) : NaN;
+    const dueByIdleCooldown = !Number.isFinite(prevIdleAtMs) || (nowMs - prevIdleAtMs >= idleCooldownMs);
+    const shouldSendAllIdleNudge = allWorkersIdle && dueByIdleCooldown;
+
     // stalePanesNudge must respect the same dueByTime rate limit (issue #116)
     const stalePanesNudge = paneStatus.alive && leaderStale;
 
-    if (!hasNewMessage && !dueByTime) continue;
+    if (!shouldSendAllIdleNudge && !hasNewMessage && !dueByTime) continue;
 
     let nudgeReason = '';
     let text = '';
-    if (stalePanesNudge && hasNewMessage) {
+    if (shouldSendAllIdleNudge) {
+      nudgeReason = 'all_workers_idle';
+      const N = workerNames.length;
+      text = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. Ready for next instructions.`;
+    } 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}`;
     } else if (stalePanesNudge) {
@@ -172,6 +241,9 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
       await new Promise(r => setTimeout(r, 100));
       await runProcess('tmux', ['send-keys', '-t', tmuxTarget, 'C-m'], 3000);
       nudgeState.last_nudged_by_team[teamName] = { at: nowIso, last_message_id: newestId || prevMsgId || '' };
+      if (shouldSendAllIdleNudge) {
+        nudgeState.last_idle_nudged_by_team[teamName] = { at: nowIso, worker_count: workerNames.length };
+      }
 
       await emitTeamNudgeEvent(cwd, teamName, nudgeReason, nowIso);
 

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

@@ -104,7 +104,8 @@ export async function readTeamWorkersForIdleCheck(stateDir, teamName) {
     const workers = parsed.workers;
     if (!Array.isArray(workers) || workers.length === 0) return null;
     const tmuxSession = safeString(parsed.tmux_session || '').trim();
-    return { workers, tmuxSession };
+    const leaderPaneId = safeString(parsed.leader_pane_id || '').trim();
+    return { workers, tmuxSession, leaderPaneId };
   } catch {
     return null;
   }
@@ -141,8 +142,9 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   // Read team config to get worker list and leader tmux target
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return;
-  const { workers, tmuxSession } = teamInfo;
-  if (!tmuxSession) return;
+  const { workers, tmuxSession, leaderPaneId } = teamInfo;
+  const tmuxTarget = leaderPaneId || tmuxSession;
+  if (!tmuxTarget) return;
 
   // Check cooldown to prevent notification spam
   const idleStatePath = join(stateDir, 'team', teamName, 'all-workers-idle.json');
@@ -162,11 +164,11 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   const message = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. Ready for next instructions. ${DEFAULT_MARKER}`;
 
   try {
-    await runProcess('tmux', ['send-keys', '-t', tmuxSession, '-l', message], 3000);
+    await runProcess('tmux', ['send-keys', '-t', tmuxTarget, '-l', message], 3000);
     await new Promise(r => setTimeout(r, 100));
-    await runProcess('tmux', ['send-keys', '-t', tmuxSession, 'C-m'], 3000);
+    await runProcess('tmux', ['send-keys', '-t', tmuxTarget, 'C-m'], 3000);
     await new Promise(r => setTimeout(r, 100));
-    await runProcess('tmux', ['send-keys', '-t', tmuxSession, 'C-m'], 3000);
+    await runProcess('tmux', ['send-keys', '-t', tmuxTarget, 'C-m'], 3000);
 
     const nextIdleState = {
       ...idleState,
@@ -195,7 +197,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       timestamp: nowIso,
       type: 'all_workers_idle_notification',
       team: teamName,
-      tmux_target: tmuxSession,
+      tmux_target: tmuxTarget,
       worker: workerName,
       worker_count: N,
     });
@@ -204,7 +206,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       timestamp: nowIso,
       type: 'all_workers_idle_notification',
       team: teamName,
-      tmux_target: tmuxSession,
+      tmux_target: tmuxTarget,
       worker: workerName,
       error: err instanceof Error ? err.message : safeString(err),
     }).catch(() => {});

package/scripts/notify-hook/tmux-injection.js

@@ -21,6 +21,7 @@ import {
   pickActiveMode,
   evaluateInjectionGuards,
   buildSendKeysArgv,
+  buildPaneInModeArgv,
 } from '../tmux-hook-engine.js';
 
 export async function resolveSessionToPane(sessionName) {
@@ -329,6 +330,32 @@ export async function handleTmuxInjection({
     }
   };
 
+  // Scroll-safety guard: skip injection when the user is actively scrolling
+  // (pane is in copy-mode / tmux's scrollback view).  Sending keys to a pane
+  // in copy-mode would exit scrollback and disrupt the user's review session.
+  // We do NOT record the dedupe key here so the injection can be retried on
+  // the next agent-turn event once the pane is no longer in scroll mode.
+  if (config.skip_if_scrolling) {
+    try {
+      const modeResult = await runProcess('tmux', buildPaneInModeArgv(paneTarget), 1000);
+      const paneInMode = safeString(modeResult.stdout).trim();
+      if (paneInMode === '1') {
+        state.last_reason = 'scroll_active';
+        state.last_event_at = nowIso;
+        await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
+        await logTmuxHookEvent(logsDir, {
+          ...baseLog,
+          event: 'injection_skipped',
+          reason: 'scroll_active',
+          pane_target: paneTarget,
+        });
+        return;
+      }
+    } catch {
+      // Non-fatal: if querying copy-mode state fails, proceed with injection.
+    }
+  }
+
   if (config.dry_run) {
     updateStateForAttempt(false, 'dry_run');
     await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});

package/scripts/tmux-hook-engine.js

@@ -74,6 +74,8 @@ export function normalizeTmuxHookConfig(raw) {
     marker,
     dry_run: raw.dry_run === true,
     log_level: logLevel,
+    // Skip injection when the target pane is in copy-mode / scrollback (default: true).
+    skip_if_scrolling: raw.skip_if_scrolling === false ? false : true,
   };
 }
 
@@ -143,6 +145,15 @@ export function evaluateInjectionGuards({
   return { allow: true, reason: 'ok', dedupeKey };
 }
 
+/**
+ * Returns the tmux argv to query whether a pane is currently in copy-mode
+ * (scrollback). The command prints "1" if the pane is in any mode, "0"
+ * otherwise.
+ */
+export function buildPaneInModeArgv(paneTarget) {
+  return ['display-message', '-p', '-t', paneTarget, '#{pane_in_mode}'];
+}
+
 export function buildSendKeysArgv({ paneTarget, prompt, dryRun }) {
   if (dryRun) return null;
   // Use a 2-step send for reliability:

package/skills/team/SKILL.md

@@ -183,7 +183,19 @@ Useful runtime env vars:
 - `OMX_TEAM_AUTO_TRUST=0`
   - Disable auto-advance for trust prompt (default behavior auto-advances)
 - `OMX_TEAM_WORKER_LAUNCH_ARGS`
-  - Extra args passed to worker `codex` launch
+  - Extra args passed to worker launch command
+- `OMX_TEAM_WORKER_CLI`
+  - Worker CLI selector: `auto|codex|claude` (default: `auto`)
+  - `auto` chooses `claude` when worker `--model` contains `claude`, otherwise `codex`
+  - In `claude` mode, workers launch as `claude --dangerously-skip-permissions` and ignore explicit model/config/effort launch overrides (uses default `settings.json`)
+- `OMX_TEAM_WORKER_CLI_MAP`
+  - Per-worker CLI selector (comma-separated `auto|codex|claude`)
+  - Length must be `1` (broadcast) or exactly the team worker count
+  - Example: `OMX_TEAM_WORKER_CLI_MAP=codex,codex,claude,claude`
+  - When present, overrides `OMX_TEAM_WORKER_CLI`
+- `OMX_TEAM_AUTO_INTERRUPT_RETRY`
+  - Trigger submit fallback (default: enabled)
+  - `0` disables adaptive queue->resend escalation
 - `OMX_TEAM_LEADER_NUDGE_MS`
   - Leader nudge interval in ms (default 120000)
 - `OMX_TEAM_STRICT_SUBMIT=1`