oh-my-codex 0.3.9 → 0.4.0

package/scripts/hook-derived-watcher.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+
+import { existsSync } from 'fs';
+import { appendFile, mkdir, readFile, readdir, stat, writeFile } from 'fs/promises';
+import { dirname, join, resolve } from 'path';
+import { homedir } from 'os';
+
+function argValue(name, fallback = '') {
+  const idx = process.argv.indexOf(name);
+  if (idx < 0 || idx + 1 >= process.argv.length) return fallback;
+  return process.argv[idx + 1];
+}
+
+function asNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+const cwd = resolve(argValue('--cwd', process.cwd()));
+const runOnce = process.argv.includes('--once');
+const pollMs = Math.max(250, asNumber(argValue('--poll-ms', process.env.OMX_HOOK_DERIVED_POLL_MS || '800'), 800));
+const maxFileAgeMs = Math.max(10_000, asNumber(argValue('--file-age-ms', process.env.OMX_HOOK_DERIVED_FILE_AGE_MS || '90000'), 90000));
+
+const omxDir = join(cwd, '.omx');
+const logsDir = join(omxDir, 'logs');
+const stateDir = join(omxDir, 'state');
+const watcherStatePath = join(stateDir, 'hook-derived-watcher-state.json');
+const logPath = join(logsDir, `hook-derived-watcher-${new Date().toISOString().split('T')[0]}.jsonl`);
+
+const fileState = new Map();
+let stopping = false;
+let flushedOnShutdown = false;
+
+function safeString(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function derivedLog(entry) {
+  return appendFile(logPath, `${JSON.stringify({ timestamp: new Date().toISOString(), ...entry })}\n`).catch(() => {});
+}
+
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+function sessionDirs() {
+  const now = new Date();
+  const today = join(
+    homedir(),
+    '.codex',
+    'sessions',
+    String(now.getUTCFullYear()),
+    String(now.getUTCMonth() + 1).padStart(2, '0'),
+    String(now.getUTCDate()).padStart(2, '0')
+  );
+  const yesterdayDate = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+  const yesterday = join(
+    homedir(),
+    '.codex',
+    'sessions',
+    String(yesterdayDate.getUTCFullYear()),
+    String(yesterdayDate.getUTCMonth() + 1).padStart(2, '0'),
+    String(yesterdayDate.getUTCDate()).padStart(2, '0')
+  );
+  return Array.from(new Set([today, yesterday]));
+}
+
+async function readFirstLine(path) {
+  const content = await readFile(path, 'utf-8');
+  const idx = content.indexOf('\n');
+  return idx >= 0 ? content.slice(0, idx) : content;
+}
+
+function shouldTrackSessionMeta(line) {
+  const parsed = parseJsonLine(line);
+  if (!parsed || parsed.type !== 'session_meta' || !parsed.payload) return null;
+  const payload = parsed.payload;
+  if (safeString(payload.cwd) !== cwd) return null;
+  const threadId = safeString(payload.id);
+  if (!threadId) return null;
+  return {
+    threadId,
+    sessionId: threadId,
+  };
+}
+
+async function discoverRolloutFiles() {
+  const now = Date.now();
+  const discovered = [];
+  for (const dir of sessionDirs()) {
+    if (!existsSync(dir)) continue;
+    const names = await readdir(dir).catch(() => []);
+    for (const name of names) {
+      if (!name.startsWith('rollout-') || !name.endsWith('.jsonl')) continue;
+      const path = join(dir, name);
+      const st = await stat(path).catch(() => null);
+      if (!st) continue;
+      if (now - st.mtimeMs > maxFileAgeMs) continue;
+      discovered.push(path);
+    }
+  }
+  discovered.sort();
+  return discovered;
+}
+
+function inferDerivedEvent(parsed, meta) {
+  if (!parsed || parsed.type !== 'event_msg' || !parsed.payload) return null;
+
+  const payload = parsed.payload;
+  const payloadType = safeString(payload.type).toLowerCase();
+  const timestamp = safeString(parsed.timestamp) || new Date().toISOString();
+  const turnId = safeString(payload.turn_id || parsed.turn_id || parsed.id);
+
+  const base = {
+    schema_version: '1',
+    timestamp,
+    source: 'derived',
+    context: {
+      parser_reason: '',
+      payload_type: payloadType || 'unknown',
+    },
+    session_id: meta.sessionId,
+    thread_id: meta.threadId,
+    turn_id: turnId || undefined,
+  };
+
+  if (['tool_call_start', 'tool_use_start', 'tool_start', 'tool_invocation_start'].includes(payloadType)) {
+    return {
+      ...base,
+      event: 'pre-tool-use',
+      confidence: 0.8,
+      parser_reason: `payload_type:${payloadType}`,
+      context: {
+        ...base.context,
+        parser_reason: `payload_type:${payloadType}`,
+        tool_name: safeString(payload.tool_name || payload.tool || payload.name),
+      },
+    };
+  }
+
+  if (['tool_call_end', 'tool_use_end', 'tool_end', 'tool_invocation_end'].includes(payloadType)) {
+    return {
+      ...base,
+      event: 'post-tool-use',
+      confidence: 0.8,
+      parser_reason: `payload_type:${payloadType}`,
+      context: {
+        ...base.context,
+        parser_reason: `payload_type:${payloadType}`,
+        tool_name: safeString(payload.tool_name || payload.tool || payload.name),
+        tool_ok: payload.ok === true,
+      },
+    };
+  }
+
+  if (payloadType === 'assistant_message') {
+    const message = safeString(payload.text || payload.message || payload.content);
+    const looksLikeQuestion = /\?|\b(can you|could you|please provide|need input|what should)/i.test(message);
+    if (looksLikeQuestion) {
+      return {
+        ...base,
+        event: 'needs-input',
+        confidence: 0.55,
+        parser_reason: 'assistant_message_heuristic_question',
+        context: {
+          ...base.context,
+          parser_reason: 'assistant_message_heuristic_question',
+          preview: message.slice(0, 200),
+        },
+      };
+    }
+  }
+
+  return null;
+}
+
+async function dispatchDerivedEvent(event) {
+  try {
+    const { dispatchHookEvent } = await import('../dist/hooks/extensibility/dispatcher.js');
+    await dispatchHookEvent(event, {
+      cwd,
+      allowTeamWorkerSideEffects: false,
+    });
+    await derivedLog({
+      type: 'derived_event_dispatch',
+      event: event.event,
+      source: event.source,
+      confidence: event.confidence,
+      thread_id: event.thread_id,
+      turn_id: event.turn_id,
+      parser_reason: event.parser_reason,
+      ok: true,
+    });
+  } catch (err) {
+    await derivedLog({
+      type: 'derived_event_dispatch',
+      event: event.event,
+      source: event.source,
+      thread_id: event.thread_id,
+      turn_id: event.turn_id,
+      parser_reason: event.parser_reason,
+      ok: false,
+      error: err instanceof Error ? err.message : 'dispatch_failed',
+    });
+  }
+}
+
+async function ensureTrackedFiles() {
+  const files = await discoverRolloutFiles();
+  for (const path of files) {
+    if (fileState.has(path)) continue;
+    const firstLine = await readFirstLine(path).catch(() => '');
+    const meta = shouldTrackSessionMeta(firstLine);
+    if (!meta) continue;
+    const size = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
+    const offset = runOnce ? 0 : size;
+    fileState.set(path, {
+      ...meta,
+      offset,
+      partial: '',
+      dispatched: 0,
+    });
+  }
+}
+
+async function processLine(meta, line) {
+  const parsed = parseJsonLine(line);
+  const derived = inferDerivedEvent(parsed, meta);
+  if (!derived) return;
+  await dispatchDerivedEvent(derived);
+  meta.dispatched += 1;
+}
+
+async function pollFiles() {
+  for (const [path, meta] of fileState.entries()) {
+    const currentSize = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
+    if (currentSize <= meta.offset) continue;
+
+    const content = await readFile(path, 'utf-8').catch(() => '');
+    if (!content) continue;
+
+    const delta = content.slice(meta.offset);
+    meta.offset = currentSize;
+    const merged = meta.partial + delta;
+    const lines = merged.split('\n');
+    meta.partial = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      await processLine(meta, line);
+    }
+  }
+}
+
+async function writeState() {
+  await mkdir(stateDir, { recursive: true }).catch(() => {});
+  const tracked = Array.from(fileState.values()).reduce((sum, item) => sum + item.dispatched, 0);
+  const state = {
+    pid: process.pid,
+    started_at: new Date().toISOString(),
+    cwd,
+    poll_ms: pollMs,
+    max_file_age_ms: maxFileAgeMs,
+    tracked_files: fileState.size,
+    dispatched_events: tracked,
+  };
+  await writeFile(watcherStatePath, JSON.stringify(state, null, 2)).catch(() => {});
+}
+
+async function flushOnce(reason) {
+  if (flushedOnShutdown) return;
+  flushedOnShutdown = true;
+  await ensureTrackedFiles();
+  await pollFiles();
+  await writeState();
+  await derivedLog({ type: 'watcher_flush', reason });
+}
+
+async function tick() {
+  if (stopping) return;
+  await ensureTrackedFiles();
+  await pollFiles();
+  await writeState();
+  setTimeout(tick, pollMs);
+}
+
+function shutdown(signal) {
+  stopping = true;
+  flushOnce(`signal:${signal}`)
+    .finally(() => derivedLog({ type: 'watcher_stop', signal }))
+    .finally(() => process.exit(0));
+}
+
+async function main() {
+  if (process.env.OMX_HOOK_DERIVED_SIGNALS !== '1') {
+    process.exit(0);
+  }
+
+  await mkdir(dirname(logPath), { recursive: true }).catch(() => {});
+  await mkdir(stateDir, { recursive: true }).catch(() => {});
+
+  await derivedLog({
+    type: 'watcher_start',
+    cwd,
+    poll_ms: pollMs,
+    max_file_age_ms: maxFileAgeMs,
+    once: runOnce,
+  });
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGHUP', () => shutdown('SIGHUP'));
+
+  if (runOnce) {
+    await flushOnce('once');
+    await derivedLog({ type: 'watcher_once_complete' });
+    process.exit(0);
+  }
+
+  await tick();
+}
+
+main().catch(async (err) => {
+  await mkdir(dirname(logPath), { recursive: true }).catch(() => {});
+  await derivedLog({
+    type: 'watcher_error',
+    reason: 'fatal',
+    error: err instanceof Error ? err.message : 'unknown_error',
+  });
+  process.exit(1);
+});

package/scripts/notify-hook.js

@@ -437,7 +437,63 @@ function resolveLeaderNudgeIntervalMs() {
   return 120_000;
 }
 
-async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir }) {
+function resolveLeaderStalenessThresholdMs() {
+  const raw = safeString(process.env.OMX_TEAM_LEADER_STALE_MS || '');
+  const parsed = asNumber(raw);
+  // Default: 3 minutes. Guard against unreasonable values.
+  if (parsed !== null && parsed >= 10_000 && parsed <= 30 * 60_000) return parsed;
+  return 180_000;
+}
+
+async function checkWorkerPanesAlive(tmuxTarget) {
+  // Check if the team tmux session has worker panes running.
+  // tmuxTarget is either "omx-team-foo" or "session:window".
+  const sessionName = tmuxTarget.split(':')[0];
+  try {
+    const result = await runProcess('tmux', ['list-panes', '-t', sessionName, '-F', '#{pane_id} #{pane_pid}'], 2000);
+    const lines = (result.stdout || '')
+      .split('\n')
+      .map(l => l.trim())
+      .filter(Boolean);
+    return { alive: lines.length > 0, paneCount: lines.length };
+  } catch {
+    return { alive: false, paneCount: 0 };
+  }
+}
+
+async function isLeaderStale(stateDir, thresholdMs, nowMs) {
+  // Check HUD state (updated by the notify hook on each leader turn) for staleness.
+  const hudStatePath = join(stateDir, 'hud-state.json');
+  const hudState = await readJsonIfExists(hudStatePath, null);
+  if (!hudState || typeof hudState !== 'object') return true;
+  const lastTurnAt = safeString(hudState.last_turn_at || '');
+  if (!lastTurnAt) return true;
+  const lastMs = Date.parse(lastTurnAt);
+  if (!Number.isFinite(lastMs)) return true;
+  return (nowMs - lastMs) >= thresholdMs;
+}
+
+async function emitTeamNudgeEvent(cwd, teamName, reason, nowIso) {
+  // Write a team_leader_nudge event to the team's events.ndjson log.
+  const eventsDir = join(cwd, '.omx', 'state', 'team', teamName, 'events');
+  const eventsPath = join(eventsDir, 'events.ndjson');
+  try {
+    await mkdir(eventsDir, { recursive: true });
+    const event = {
+      event_id: `nudge-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+      team: teamName,
+      type: 'team_leader_nudge',
+      worker: 'leader-fixed',
+      reason,
+      created_at: nowIso,
+    };
+    await appendFile(eventsPath, JSON.stringify(event) + '\n');
+  } catch {
+    // Best effort
+  }
+}
+
+async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderStale }) {
   const intervalMs = resolveLeaderNudgeIntervalMs();
   const nowMs = Date.now();
   const nowIso = new Date().toISOString();
@@ -467,6 +523,9 @@ async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir }) {
     // Non-critical
   }
 
+  // Use pre-computed staleness (captured before HUD state was updated this turn)
+  const leaderStale = typeof preComputedLeaderStale === 'boolean' ? preComputedLeaderStale : false;
+
   for (const teamName of activeTeamNames) {
     // Resolve tmux target (session:window) from manifest/config. Best effort.
     let tmuxTarget = '';
@@ -483,6 +542,9 @@ async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir }) {
     }
     if (!tmuxTarget) continue;
 
+    // Check if worker panes are still alive in tmux
+    const paneStatus = await checkWorkerPanesAlive(tmuxTarget);
+
     let mailbox = null;
     try {
       const mailboxPath = join(omxDir, 'state', 'team', teamName, 'mailbox', 'leader-fixed.json');
@@ -503,17 +565,51 @@ async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir }) {
 
     const hasNewMessage = newestId && newestId !== prevMsgId;
     const dueByTime = !Number.isFinite(prevAtMs) || (nowMs - prevAtMs >= intervalMs);
-    if (!hasNewMessage && !dueByTime) continue;
 
+    // New condition: worker panes alive + leader stale = always nudge
+    const stalePanesNudge = paneStatus.alive && leaderStale;
+
+    if (!hasNewMessage && !dueByTime && !stalePanesNudge) continue;
+
+    // Build contextual nudge message
     const msgCount = messages.length;
-    const text = hasNewMessage
-      ? `Team ${teamName}: ${msgCount} msg(s) for leader. Run: omx team status ${teamName}`
-      : `Team ${teamName} active. Run: omx team status ${teamName}`;
+    let nudgeReason = '';
+    let text = '';
+    if (stalePanesNudge && hasNewMessage) {
+      nudgeReason = 'stale_leader_with_messages';
+      text = `Team ${teamName}: leader stale, ${paneStatus.paneCount} pane(s) active, ${msgCount} msg(s) pending. Run: omx team status ${teamName}`;
+    } else if (stalePanesNudge) {
+      nudgeReason = 'stale_leader_panes_alive';
+      text = `Team ${teamName}: leader stale, ${paneStatus.paneCount} worker pane(s) still active. Run: omx team status ${teamName}`;
+    } else if (hasNewMessage) {
+      nudgeReason = 'new_mailbox_message';
+      text = `Team ${teamName}: ${msgCount} msg(s) for leader. Run: omx team status ${teamName}`;
+    } else {
+      nudgeReason = 'periodic_check';
+      text = `Team ${teamName} active. Run: omx team status ${teamName}`;
+    }
     const capped = text.length > 180 ? `${text.slice(0, 177)}...` : text;
 
     try {
-      await runProcess('tmux', ['display-message', '-t', tmuxTarget, '--', capped], 1200);
+      await runProcess('tmux', ['send-keys', '-t', tmuxTarget, capped, 'C-m', 'C-m'], 1200);
       nudgeState.last_nudged_by_team[teamName] = { at: nowIso, last_message_id: newestId || prevMsgId || '' };
+
+      // Emit team event for the nudge
+      await emitTeamNudgeEvent(cwd, teamName, nudgeReason, nowIso);
+
+      // Log the nudge
+      try {
+        await logTmuxHookEvent(logsDir, {
+          timestamp: nowIso,
+          type: 'team_leader_nudge',
+          team: teamName,
+          tmux_target: tmuxTarget,
+          reason: nudgeReason,
+          pane_count: paneStatus.paneCount,
+          leader_stale: leaderStale,
+          message_count: msgCount,
+        });
+      } catch { /* ignore */ }
     } catch (err) {
       // Best effort. Log only in debug mode to avoid noise.
       try {
@@ -522,6 +618,7 @@ async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir }) {
           type: 'team_leader_nudge',
           team: teamName,
           tmux_target: tmuxTarget,
+          reason: nudgeReason,
           error: safeString(err && err.message ? err.message : err),
         });
       } catch { /* ignore */ }
@@ -812,6 +909,22 @@ function parseTeamWorkerEnv(rawValue) {
   return { teamName: match[1], workerName: match[2] };
 }
 
+async function dispatchNativeHookEvent(cwd, eventName, payload, context = {}) {
+  try {
+    const { buildNativeHookEvent } = await import('../dist/hooks/extensibility/events.js');
+    const { dispatchHookEvent } = await import('../dist/hooks/extensibility/dispatcher.js');
+    const event = buildNativeHookEvent(eventName, context, {
+      session_id: safeString(payload.session_id || payload['session-id'] || ''),
+      thread_id: safeString(payload['thread-id'] || payload.thread_id || ''),
+      turn_id: safeString(payload['turn-id'] || payload.turn_id || ''),
+      mode: safeString(payload.mode || ''),
+    });
+    await dispatchHookEvent(event, { cwd });
+  } catch {
+    // Non-fatal: extensibility modules may not be built yet
+  }
+}
+
 async function main() {
   const rawPayload = process.argv[process.argv.length - 1];
   if (!rawPayload || rawPayload.startsWith('-')) {
@@ -968,6 +1081,17 @@ async function main() {
     }
   }
 
+  // 3.5. Pre-compute leader staleness BEFORE updating HUD state (used by nudge in step 6)
+  let preComputedLeaderStale = false;
+  if (!isTeamWorker) {
+    try {
+      const stalenessMs = resolveLeaderStalenessThresholdMs();
+      preComputedLeaderStale = await isLeaderStale(stateDir, stalenessMs, Date.now());
+    } catch {
+      // Non-critical
+    }
+  }
+
   // 4. Write HUD state summary for `omx hud` (lead session only)
   if (!isTeamWorker) {
     const hudStatePath = join(stateDir, 'hud-state.json');
@@ -1026,11 +1150,48 @@ async function main() {
   // 6. Team leader nudge (lead session only): remind the leader to check teammate/mailbox state.
   if (!isTeamWorker) {
     try {
-      await maybeNudgeTeamLeader({ cwd, stateDir, logsDir });
+      await maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderStale });
     } catch {
       // Non-critical
     }
   }
+
+  // 7. Dispatch native turn-complete hook event (best effort, post-dedupe)
+  await dispatchNativeHookEvent(cwd, 'turn-complete', payload, {
+    source: safeString(payload.source || 'native'),
+    type: safeString(payload.type || 'agent-turn-complete'),
+    input_messages: normalizeInputMessages(payload),
+    output_preview: safeString(payload['last-assistant-message'] || payload.last_assistant_message || '').slice(0, 400),
+  });
+
+  // 8. Dispatch session-idle lifecycle notification (lead session only, best effort)
+  if (!isTeamWorker) {
+    try {
+      const { notifyLifecycle } = await import('../dist/notifications/index.js');
+      const sessionJsonPath = join(stateDir, 'session.json');
+      let notifySessionId = '';
+      try {
+        const sessionData = JSON.parse(await readFile(sessionJsonPath, 'utf-8'));
+        notifySessionId = safeString(sessionData && sessionData.session_id ? sessionData.session_id : '');
+      } catch { /* no session file */ }
+
+      if (notifySessionId) {
+        await notifyLifecycle('session-idle', {
+          sessionId: notifySessionId,
+          projectPath: cwd,
+        });
+        await dispatchNativeHookEvent(cwd, 'session-idle', {
+          ...payload,
+          session_id: notifySessionId,
+        }, {
+          project_path: cwd,
+          reason: 'post_turn_idle_notification',
+        });
+      }
+    } catch {
+      // Non-fatal: notification module may not be built or config may not exist
+    }
+  }
 }
 
 async function readdir(dir) {

package/scripts/tmux-hook-engine.js

@@ -149,10 +149,11 @@ export function buildSendKeysArgv({ paneTarget, prompt, dryRun }) {
   // 1) literal prompt bytes, 2) explicit carriage return.
   return {
     typeArgv: ['send-keys', '-t', paneTarget, '-l', prompt],
-    // Some panes/shells swallow one of these key names; send both.
+    // Codex CLI uses raw input mode where 'Enter' key name is unreliable;
+    // send 'C-m' (carriage return) twice for reliable prompt submission.
     submitArgv: [
       ['send-keys', '-t', paneTarget, 'C-m'],
-      ['send-keys', '-t', paneTarget, 'Enter'],
+      ['send-keys', '-t', paneTarget, 'C-m'],
     ],
   };
 }