oh-my-codex 0.4.0 → 0.4.2

package/scripts/notify-hook.js

@@ -10,17 +10,20 @@
  * 2. Updates state for active workflow modes
  * 3. Tracks subagent activity
  * 4. Triggers desktop notifications if configured
+ * 5. Auto-nudges Codex when it stalls with permission-asking patterns
  */
 
 import { writeFile, appendFile, mkdir, readFile, rename } from 'fs/promises';
 import { join, resolve as resolvePath } from 'path';
 import { existsSync } from 'fs';
 import { spawn } from 'child_process';
+import { homedir } from 'os';
 import {
   normalizeTmuxHookConfig,
   pickActiveMode,
   evaluateInjectionGuards,
   buildSendKeysArgv,
+  DEFAULT_MARKER,
 } from './tmux-hook-engine.js';
 
 const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
@@ -233,6 +236,198 @@ function readJsonIfExists(path, fallback) {
     .catch(() => fallback);
 }
 
+// ---------------------------------------------------------------------------
+// Auto-nudge: detect Codex "asking for permission" stall patterns and
+// automatically send a continuation prompt so the agent keeps working.
+// ---------------------------------------------------------------------------
+
+const DEFAULT_STALL_PATTERNS = [
+  'if you want',
+  'would you like',
+  'shall i',
+  'next i can',
+  'do you want me to',
+  'let me know if',
+  'do you want',
+  'want me to',
+  'let me know',
+  'just let me know',
+  'i can also',
+  'i could also',
+  'ready to proceed',
+  'should i',
+  'whenever you',
+  'say go',
+  'say yes',
+  'type continue',
+  'and i\'ll continue',
+  'and i\'ll proceed',
+  'keep driving',
+  'keep pushing',
+  'move forward',
+  'drive forward',
+  'proceed from here',
+  'i\'ll continue from',
+];
+
+function normalizeAutoNudgeConfig(raw) {
+  if (!raw || typeof raw !== 'object') {
+    return {
+      enabled: true,
+      patterns: DEFAULT_STALL_PATTERNS,
+      response: 'yes, proceed',
+      delaySec: 3,
+      maxNudgesPerSession: Infinity,
+    };
+  }
+  return {
+    enabled: raw.enabled !== false,
+    patterns: Array.isArray(raw.patterns) && raw.patterns.length > 0
+      ? raw.patterns.filter(p => typeof p === 'string' && p.trim() !== '')
+      : DEFAULT_STALL_PATTERNS,
+    response: typeof raw.response === 'string' && raw.response.trim() !== ''
+      ? raw.response
+      : 'yes, proceed',
+    delaySec: typeof raw.delaySec === 'number' && raw.delaySec >= 0 && raw.delaySec <= 60
+      ? raw.delaySec
+      : 3,
+    maxNudgesPerSession: typeof raw.maxNudgesPerSession === 'number' && raw.maxNudgesPerSession > 0
+      ? raw.maxNudgesPerSession
+      : Infinity,
+  };
+}
+
+async function loadAutoNudgeConfig() {
+  const codexHomePath = process.env.CODEX_HOME || join(homedir(), '.codex');
+  const configPath = join(codexHomePath, '.omx-config.json');
+  const raw = await readJsonIfExists(configPath, null);
+  if (!raw || typeof raw !== 'object') return normalizeAutoNudgeConfig(null);
+  return normalizeAutoNudgeConfig(raw.autoNudge);
+}
+
+function detectStallPattern(text, patterns) {
+  if (!text || typeof text !== 'string') return false;
+  // Broader tail window (~800 chars / ~15-20 lines) for context
+  const tail = text.slice(-800).toLowerCase();
+  const lowerPatterns = patterns.map(p => p.toLowerCase());
+  // Focus on last few lines where stall prompts typically appear
+  const lines = tail.split('\n').filter(l => l.trim());
+  const hotZone = lines.slice(-3).join('\n');
+  // Primary: check last few lines (highest signal)
+  if (lowerPatterns.some(p => hotZone.includes(p))) return true;
+  // Secondary: check broader tail window
+  return lowerPatterns.some(p => tail.includes(p));
+}
+
+async function capturePane(paneId, lines = 10) {
+  try {
+    const result = await runProcess('tmux', [
+      'capture-pane', '-t', paneId, '-p', '-l', String(lines),
+    ], 3000);
+    return result.stdout || '';
+  } catch {
+    return '';
+  }
+}
+
+async function resolveNudgePaneTarget(stateDir) {
+  // 1. Try TMUX_PANE env var (inherited from the Codex process)
+  const envPane = safeString(process.env.TMUX_PANE || '');
+  if (envPane) return envPane;
+
+  // 2. Fallback: check active mode states for tmux_pane_id
+  try {
+    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
+    for (const dir of scopedDirs) {
+      const files = await readdir(dir).catch(() => []);
+      for (const f of files) {
+        if (!f.endsWith('-state.json')) continue;
+        const path = join(dir, f);
+        try {
+          const state = JSON.parse(await readFile(path, 'utf-8'));
+          if (state && state.active && state.tmux_pane_id) {
+            return safeString(state.tmux_pane_id);
+          }
+        } catch {
+          // skip malformed state
+        }
+      }
+    }
+  } catch {
+    // Non-critical
+  }
+
+  return '';
+}
+
+async function maybeAutoNudge({ cwd, stateDir, logsDir, payload }) {
+  const config = await loadAutoNudgeConfig();
+  if (!config.enabled) return;
+
+  // Check nudge count against session limit
+  const nudgeStatePath = join(stateDir, 'auto-nudge-state.json');
+  let nudgeState = await readJsonIfExists(nudgeStatePath, null);
+  if (!nudgeState || typeof nudgeState !== 'object') {
+    nudgeState = { nudgeCount: 0, lastNudgeAt: '' };
+  }
+  const nudgeCount = asNumber(nudgeState.nudgeCount) ?? 0;
+  if (Number.isFinite(config.maxNudgesPerSession) && nudgeCount >= config.maxNudgesPerSession) return;
+
+  // Resolve pane target early (needed for both capture-pane check and sending)
+  const paneId = await resolveNudgePaneTarget(stateDir);
+
+  // Check last assistant message for stall patterns (fast path)
+  const lastMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
+  let detected = detectStallPattern(lastMessage, config.patterns);
+  let source = 'payload';
+
+  // Fallback: capture the last 10 lines of tmux pane output
+  if (!detected && paneId) {
+    const captured = await capturePane(paneId);
+    detected = detectStallPattern(captured, config.patterns);
+    source = 'capture-pane';
+  }
+
+  if (!detected || !paneId) return;
+
+  // Short delay to let the agent settle before nudging
+  if (config.delaySec > 0) {
+    await new Promise(r => setTimeout(r, config.delaySec * 1000));
+  }
+
+  const nowIso = new Date().toISOString();
+  try {
+    // Send the response text as literal bytes, then submit with double C-m
+    // Codex CLI needs C-m sent twice with a short delay for reliable prompt submission
+    const markedResponse = `${config.response} ${DEFAULT_MARKER}`;
+    await runProcess('tmux', ['send-keys', '-t', paneId, '-l', markedResponse], 3000);
+    await new Promise(r => setTimeout(r, 100));
+    await runProcess('tmux', ['send-keys', '-t', paneId, 'C-m'], 3000);
+    await new Promise(r => setTimeout(r, 100));
+    await runProcess('tmux', ['send-keys', '-t', paneId, 'C-m'], 3000);
+
+    nudgeState.nudgeCount = nudgeCount + 1;
+    nudgeState.lastNudgeAt = nowIso;
+    await writeFile(nudgeStatePath, JSON.stringify(nudgeState, null, 2)).catch(() => {});
+
+    await logTmuxHookEvent(logsDir, {
+      timestamp: nowIso,
+      type: 'auto_nudge',
+      pane_id: paneId,
+      response: config.response,
+      source,
+      nudge_count: nudgeState.nudgeCount,
+    });
+  } catch (err) {
+    await logTmuxHookEvent(logsDir, {
+      timestamp: nowIso,
+      type: 'auto_nudge',
+      pane_id: paneId,
+      error: err instanceof Error ? err.message : safeString(err),
+    }).catch(() => {});
+  }
+}
+
 function runProcess(command, args, timeoutMs = 3000) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
@@ -589,9 +784,14 @@ async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderS
       text = `Team ${teamName} active. Run: omx team status ${teamName}`;
     }
     const capped = text.length > 180 ? `${text.slice(0, 177)}...` : text;
+    const markedText = `${capped} ${DEFAULT_MARKER}`;
 
     try {
-      await runProcess('tmux', ['send-keys', '-t', tmuxTarget, capped, 'C-m', 'C-m'], 1200);
+      await runProcess('tmux', ['send-keys', '-t', tmuxTarget, '-l', markedText], 3000);
+      await new Promise(r => setTimeout(r, 100));
+      await runProcess('tmux', ['send-keys', '-t', tmuxTarget, 'C-m'], 3000);
+      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 || '' };
 
       // Emit team event for the nudge
@@ -909,6 +1109,133 @@ function parseTeamWorkerEnv(rawValue) {
   return { teamName: match[1], workerName: match[2] };
 }
 
+function resolveAllWorkersIdleCooldownMs() {
+  const raw = safeString(process.env.OMX_TEAM_ALL_IDLE_COOLDOWN_MS || '');
+  const parsed = asNumber(raw);
+  // Default: 60 seconds. Guard against unreasonable values.
+  if (parsed !== null && parsed >= 5_000 && parsed <= 10 * 60_000) return parsed;
+  return 60_000;
+}
+
+async function readWorkerStatusState(stateDir, teamName, workerName) {
+  if (!workerName) return 'unknown';
+  const statusPath = join(stateDir, 'team', teamName, 'workers', workerName, 'status.json');
+  try {
+    if (!existsSync(statusPath)) return 'unknown';
+    const raw = await readFile(statusPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.state === 'string') return parsed.state;
+    return 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+async function readTeamWorkersForIdleCheck(stateDir, teamName) {
+  // Try manifest.v2.json first (preferred), then config.json
+  const manifestPath = join(stateDir, 'team', teamName, 'manifest.v2.json');
+  const configPath = join(stateDir, 'team', teamName, 'config.json');
+  const srcPath = existsSync(manifestPath) ? manifestPath : existsSync(configPath) ? configPath : null;
+  if (!srcPath) return null;
+
+  try {
+    const raw = await readFile(srcPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') return null;
+    const workers = parsed.workers;
+    if (!Array.isArray(workers) || workers.length === 0) return null;
+    const tmuxSession = safeString(parsed.tmux_session || '').trim();
+    return { workers, tmuxSession };
+  } catch {
+    return null;
+  }
+}
+
+async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir, parsedTeamWorker }) {
+  const { teamName, workerName } = parsedTeamWorker;
+  const nowMs = Date.now();
+  const nowIso = new Date(nowMs).toISOString();
+
+  // Only trigger check when this worker is idle
+  const myState = await readWorkerStatusState(stateDir, teamName, workerName);
+  if (myState !== 'idle') return;
+
+  // 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;
+
+  // Check cooldown to prevent notification spam
+  const idleStatePath = join(stateDir, 'team', teamName, 'all-workers-idle.json');
+  const idleState = (await readJsonIfExists(idleStatePath, null)) || {};
+  const cooldownMs = resolveAllWorkersIdleCooldownMs();
+  const lastNotifiedMs = asNumber(idleState.last_notified_at_ms) ?? 0;
+  if ((nowMs - lastNotifiedMs) < cooldownMs) return;
+
+  // Check if ALL workers are idle (or done)
+  const states = await Promise.all(
+    workers.map(w => readWorkerStatusState(stateDir, teamName, safeString(w && w.name ? w.name : '')))
+  );
+  const allIdle = states.length > 0 && states.every(s => s === 'idle' || s === 'done');
+  if (!allIdle) return;
+
+  const N = workers.length;
+  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 new Promise(r => setTimeout(r, 100));
+    await runProcess('tmux', ['send-keys', '-t', tmuxSession, 'C-m'], 3000);
+    await new Promise(r => setTimeout(r, 100));
+    await runProcess('tmux', ['send-keys', '-t', tmuxSession, 'C-m'], 3000);
+
+    // Update cooldown state (atomic: use a tmp file pattern)
+    const nextIdleState = {
+      ...idleState,
+      last_notified_at_ms: nowMs,
+      last_notified_at: nowIso,
+      worker_count: N,
+    };
+    await writeFile(idleStatePath, JSON.stringify(nextIdleState, null, 2)).catch(() => {});
+
+    // Emit team event for the notification
+    const eventsDir = join(stateDir, 'team', teamName, 'events');
+    const eventsPath = join(eventsDir, 'events.ndjson');
+    try {
+      await mkdir(eventsDir, { recursive: true });
+      const event = {
+        event_id: `all-idle-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+        team: teamName,
+        type: 'all_workers_idle',
+        worker: workerName,
+        worker_count: N,
+        created_at: nowIso,
+      };
+      await appendFile(eventsPath, JSON.stringify(event) + '\n');
+    } catch { /* best effort */ }
+
+    // Log the notification
+    await logTmuxHookEvent(logsDir, {
+      timestamp: nowIso,
+      type: 'all_workers_idle_notification',
+      team: teamName,
+      tmux_target: tmuxSession,
+      worker: workerName,
+      worker_count: N,
+    });
+  } catch (err) {
+    await logTmuxHookEvent(logsDir, {
+      timestamp: nowIso,
+      type: 'all_workers_idle_notification',
+      team: teamName,
+      tmux_target: tmuxSession,
+      worker: workerName,
+      error: err instanceof Error ? err.message : safeString(err),
+    }).catch(() => {});
+  }
+}
+
 async function dispatchNativeHookEvent(cwd, eventName, payload, context = {}) {
   try {
     const { buildNativeHookEvent } = await import('../dist/hooks/extensibility/events.js');
@@ -1137,6 +1464,15 @@ async function main() {
     }
   }
 
+  // 4.6. Notify leader when all workers are idle (worker session only)
+  if (isTeamWorker && parsedTeamWorker) {
+    try {
+      await maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir, parsedTeamWorker });
+    } catch {
+      // Non-critical
+    }
+  }
+
   // 5. Optional tmux prompt injection workaround (non-fatal, opt-in)
   // Skip for team workers - only the lead should inject prompts
   if (!isTeamWorker) {
@@ -1192,6 +1528,15 @@ async function main() {
       // Non-fatal: notification module may not be built or config may not exist
     }
   }
+
+  // 9. Auto-nudge: detect Codex stall patterns ("If you want...", "Shall I...", etc.)
+  //    and automatically send a continuation prompt so the agent keeps working.
+  //    Works for both leader and worker contexts.
+  try {
+    await maybeAutoNudge({ cwd, stateDir, logsDir, payload });
+  } catch {
+    // Non-critical
+  }
 }
 
 async function readdir(dir) {

package/templates/AGENTS.md

@@ -44,7 +44,7 @@ For non-trivial SDK/API/framework usage, delegate to `dependency-expert` to chec
 </delegation_rules>
 
 <child_agent_protocol>
-Codex CLI spawns child agents via the `spawn_agent` tool (requires `collab = true`).
+Codex CLI spawns child agents via the `spawn_agent` tool (requires `multi_agent = true`).
 To inject role-specific behavior, the parent MUST read the role prompt and pass it in the spawned agent message.
 
 Delegation steps: