oh-my-codex 0.3.8 → 0.3.10

package/prompts/planner.md

@@ -26,7 +26,7 @@ Plans that are too vague waste executor time guessing. Plans that are too detail
 
 - Never write code files (.ts, .js, .py, .go, etc.). Only output plans to `.omx/plans/*.md` and drafts to `.omx/drafts/*.md`.
 - Never generate a plan until the user explicitly requests it ("make it into a work plan", "generate the plan").
-- Never start implementation. Always hand off to `/oh-my-codex:start-work`.
+- Never start implementation. Always hand off by presenting actionable next-step commands (see Output Format).
 - Ask ONE question at a time using AskUserQuestion tool. Never batch multiple questions.
 - Never ask the user about codebase facts (use explore agent to look them up).
 - Default to 3-6 step plans. Avoid architecture redesign unless the task requires it.
@@ -41,7 +41,7 @@ Plans that are too vague waste executor time guessing. Plans that are too detail
 4) When user triggers plan generation ("make it into a work plan"), consult analyst (Metis) first for gap analysis.
 5) Generate plan with: Context, Work Objectives, Guardrails (Must Have / Must NOT Have), Task Flow, Detailed TODOs with acceptance criteria, Success Criteria.
 6) Display confirmation summary and wait for explicit user approval.
-7) On approval, hand off to `/oh-my-codex:start-work {plan-name}`.
+7) On approval, present concrete next-step commands the user can copy-paste to begin execution (e.g. `$ralph "execute plan: {plan-name}"` or `$team 3:executor "execute plan: {plan-name}"`).
 
 ## Tool Usage
 
@@ -71,7 +71,7 @@ Plans that are too vague waste executor time guessing. Plans that are too detail
 2. [Deliverable 2]
 
 **Does this plan capture your intent?**
-- "proceed" - Begin implementation via /oh-my-codex:start-work
+- "proceed" - Show executable next-step commands
 - "adjust [X]" - Return to interview to modify
 - "restart" - Discard and start fresh
 

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 */ }
@@ -968,6 +1065,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 +1134,33 @@ 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 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,
+        });
+      }
+    } catch {
+      // Non-fatal: notification module may not be built or config may not exist
+    }
+  }
 }
 
 async function readdir(dir) {

package/skills/team/SKILL.md

@@ -63,7 +63,9 @@ If duplicates exist, remove extras before `omx team` to prevent HUD ending up in
    - `.omx/state/team/<team>/config.json`
    - `.omx/state/team/<team>/manifest.v2.json`
    - `.omx/state/team/<team>/tasks/task-<id>.json`
-4. Apply worker overlay to project `AGENTS.md`
+4. Compose team-scoped worker instructions file at:
+   - `.omx/state/team/<team>/worker-agents.md`
+   - Uses project `AGENTS.md` content (if present) + worker overlay, without mutating project `AGENTS.md`
 5. Split current tmux window into worker panes
 6. Launch workers with `OMX_TEAM_WORKER=<team>/worker-<n>`
 7. Wait for worker readiness (`capture-pane` polling)