oh-my-codex 0.6.3 → 0.7.0

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

@@ -68,6 +68,21 @@ export function parseTeamWorkerEnv(rawValue) {
   return { teamName: match[1], workerName: match[2] };
 }
 
+export function resolveWorkerIdleNotifyEnabled() {
+  const raw = safeString(process.env.OMX_TEAM_WORKER_IDLE_NOTIFY || '').trim().toLowerCase();
+  // Default: enabled. Disable with "false", "0", or "off".
+  if (raw === 'false' || raw === '0' || raw === 'off') return false;
+  return true;
+}
+
+export function resolveWorkerIdleCooldownMs() {
+  const raw = safeString(process.env.OMX_TEAM_WORKER_IDLE_COOLDOWN_MS || '');
+  const parsed = asNumber(raw);
+  // Default: 30 seconds. Guard against unreasonable values.
+  if (parsed !== null && parsed >= 5_000 && parsed <= 10 * 60_000) return parsed;
+  return 30_000;
+}
+
 export function resolveAllWorkersIdleCooldownMs() {
   const raw = safeString(process.env.OMX_TEAM_ALL_IDLE_COOLDOWN_MS || '');
   const parsed = asNumber(raw);
@@ -212,3 +227,130 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
     }).catch(() => {});
   }
 }
+
+export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, parsedTeamWorker }) {
+  if (!resolveWorkerIdleNotifyEnabled()) return;
+
+  const { teamName, workerName } = parsedTeamWorker;
+  const nowMs = Date.now();
+  const nowIso = new Date(nowMs).toISOString();
+
+  // Read current worker status (full object for task context)
+  const workerDir = join(stateDir, 'team', teamName, 'workers', workerName);
+  const statusPath = join(workerDir, 'status.json');
+  let currentState = 'unknown';
+  let currentTaskId = '';
+  let currentReason = '';
+  try {
+    if (existsSync(statusPath)) {
+      const parsed = JSON.parse(await readFile(statusPath, 'utf-8'));
+      if (parsed && typeof parsed.state === 'string') currentState = parsed.state;
+      if (parsed && typeof parsed.current_task_id === 'string') currentTaskId = parsed.current_task_id;
+      if (parsed && typeof parsed.reason === 'string') currentReason = parsed.reason;
+    }
+  } catch { /* ignore */ }
+
+  // Read and update previous state for transition detection
+  const prevStatePath = join(workerDir, 'prev-notify-state.json');
+  let prevState = 'unknown';
+  try {
+    if (existsSync(prevStatePath)) {
+      const parsed = JSON.parse(await readFile(prevStatePath, 'utf-8'));
+      if (parsed && typeof parsed.state === 'string') prevState = parsed.state;
+    }
+  } catch { /* ignore */ }
+
+  // Always update prev state (atomic write)
+  try {
+    await mkdir(workerDir, { recursive: true });
+    const tmpPath = prevStatePath + '.tmp.' + process.pid;
+    await writeFile(tmpPath, JSON.stringify({ state: currentState, updated_at: nowIso }, null, 2));
+    await rename(tmpPath, prevStatePath);
+  } catch { /* best effort */ }
+
+  // Only fire on working->idle transition (non-idle to idle)
+  if (currentState !== 'idle') return;
+  if (prevState === 'idle' || prevState === 'done') return;
+
+  // Check per-worker cooldown
+  const cooldownPath = join(workerDir, 'worker-idle-notify.json');
+  const cooldownMs = resolveWorkerIdleCooldownMs();
+  let lastNotifiedMs = 0;
+  try {
+    if (existsSync(cooldownPath)) {
+      const parsed = JSON.parse(await readFile(cooldownPath, 'utf-8'));
+      lastNotifiedMs = asNumber(parsed && parsed.last_notified_at_ms) ?? 0;
+    }
+  } catch { /* ignore */ }
+  if ((nowMs - lastNotifiedMs) < cooldownMs) return;
+
+  // Read team config for tmux target
+  const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
+  if (!teamInfo) return;
+  const { tmuxSession, leaderPaneId } = teamInfo;
+  const tmuxTarget = leaderPaneId || tmuxSession;
+  if (!tmuxTarget) return;
+
+  // Build notification message with context
+  const parts = [`[OMX] ${workerName} idle`];
+  if (prevState && prevState !== 'unknown') parts.push(`(was: ${prevState})`);
+  if (currentTaskId) parts.push(`task: ${currentTaskId}`);
+  if (currentReason) parts.push(`reason: ${currentReason}`);
+  const message = `${parts.join('. ')}. ${DEFAULT_MARKER}`;
+
+  try {
+    await runProcess('tmux', ['send-keys', '-t', tmuxTarget, '-l', message], 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);
+
+    // Update cooldown state
+    try {
+      const tmpPath = cooldownPath + '.tmp.' + process.pid;
+      await writeFile(tmpPath, JSON.stringify({
+        last_notified_at_ms: nowMs,
+        last_notified_at: nowIso,
+        prev_state: prevState,
+      }, null, 2));
+      await rename(tmpPath, cooldownPath);
+    } catch { /* best effort */ }
+
+    // Write event to events.ndjson
+    const eventsDir = join(stateDir, 'team', teamName, 'events');
+    const eventsPath = join(eventsDir, 'events.ndjson');
+    try {
+      await mkdir(eventsDir, { recursive: true });
+      const event = {
+        event_id: `worker-idle-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+        team: teamName,
+        type: 'worker_idle',
+        worker: workerName,
+        prev_state: prevState,
+        task_id: currentTaskId || null,
+        reason: currentReason || null,
+        created_at: nowIso,
+      };
+      await appendFile(eventsPath, JSON.stringify(event) + '\n');
+    } catch { /* best effort */ }
+
+    await logTmuxHookEvent(logsDir, {
+      timestamp: nowIso,
+      type: 'worker_idle_notification',
+      team: teamName,
+      tmux_target: tmuxTarget,
+      worker: workerName,
+      prev_state: prevState,
+      task_id: currentTaskId || null,
+    });
+  } catch (err) {
+    await logTmuxHookEvent(logsDir, {
+      timestamp: nowIso,
+      type: 'worker_idle_notification',
+      team: teamName,
+      tmux_target: tmuxTarget,
+      worker: workerName,
+      error: err instanceof Error ? err.message : safeString(err),
+    }).catch(() => {});
+  }
+}

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

@@ -245,13 +245,13 @@ export async function handleTmuxInjection({
     return;
   }
 
-  const { renderPrompt } = await import('./payload-parser.js');
-  const prompt = renderPrompt(config.prompt_template, {
+  const { renderPrompt, injectLanguageReminder } = await import('./payload-parser.js');
+  const prompt = injectLanguageReminder(renderPrompt(config.prompt_template, {
     mode: mode || 'unknown',
     threadId,
     turnId,
     timestamp: nowIso,
-  });
+  }), sourceText);
   const fallbackPane = safeString(process.env.TMUX_PANE || '');
   const resolution = await resolvePaneTarget(config.target, fallbackPane, cwd, modePane);
   if (!resolution.paneTarget) {

package/scripts/notify-hook.js

@@ -44,6 +44,7 @@ import {
   resolveTeamStateDirForWorker,
   updateWorkerHeartbeat,
   maybeNotifyLeaderAllWorkersIdle,
+  maybeNotifyLeaderWorkerIdle,
 } from './notify-hook/team-worker.js';
 import { DEFAULT_MARKER } from './tmux-hook-engine.js';
 
@@ -129,8 +130,27 @@ async function main() {
           const statePath = join(scopedDir, f);
           const state = JSON.parse(await readFile(statePath, 'utf-8'));
           if (state.active) {
-            state.iteration = (state.iteration || 0) + 1;
-            state.last_turn_at = new Date().toISOString();
+            const nowIso = new Date().toISOString();
+            const nextIteration = (state.iteration || 0) + 1;
+            state.iteration = nextIteration;
+            state.last_turn_at = nowIso;
+
+            const maxIterations = asNumber(state.max_iterations);
+            if (maxIterations !== null && maxIterations > 0 && nextIteration >= maxIterations) {
+              state.active = false;
+              if (typeof state.current_phase !== 'string' || !state.current_phase.trim()) {
+                state.current_phase = 'complete';
+              } else if (!['cancelled', 'failed', 'complete'].includes(state.current_phase)) {
+                state.current_phase = 'complete';
+              }
+              if (typeof state.completed_at !== 'string' || !state.completed_at) {
+                state.completed_at = nowIso;
+              }
+              if (typeof state.stop_reason !== 'string' || !state.stop_reason) {
+                state.stop_reason = 'max_iterations_reached';
+              }
+            }
+
             await writeFile(statePath, JSON.stringify(state, null, 2));
           }
         }
@@ -248,6 +268,15 @@ async function main() {
     }
   }
 
+  // 4.55. Notify leader when individual worker transitions to idle (worker session only)
+  if (isTeamWorker && parsedTeamWorker) {
+    try {
+      await maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, parsedTeamWorker });
+    } catch {
+      // Non-critical
+    }
+  }
+
   // 4.6. Notify leader when all workers are idle (worker session only)
   if (isTeamWorker && parsedTeamWorker) {
     try {
@@ -300,6 +329,7 @@ async function main() {
   if (!isTeamWorker) {
     try {
       const { notifyLifecycle } = await import('../dist/notifications/index.js');
+      const { shouldSendIdleNotification, recordIdleNotificationSent } = await import('../dist/notifications/idle-cooldown.js');
       const sessionJsonPath = join(stateDir, 'session.json');
       let notifySessionId = '';
       try {
@@ -307,11 +337,14 @@ async function main() {
         notifySessionId = safeString(sessionData && sessionData.session_id ? sessionData.session_id : '');
       } catch { /* no session file */ }
 
-      if (notifySessionId) {
-        await notifyLifecycle('session-idle', {
+      if (notifySessionId && shouldSendIdleNotification(stateDir, notifySessionId)) {
+        const idleResult = await notifyLifecycle('session-idle', {
           sessionId: notifySessionId,
           projectPath: cwd,
         });
+        if (idleResult && idleResult.anySuccess) {
+          recordIdleNotificationSent(stateDir, notifySessionId);
+        }
         try {
           const { buildNativeHookEvent } = await import('../dist/hooks/extensibility/events.js');
           const { dispatchHookEvent } = await import('../dist/hooks/extensibility/dispatcher.js');
@@ -334,6 +367,24 @@ async function main() {
     }
   }
 
+  // 8.5. Skill activation tracking: update skill-active-state.json when a keyword is detected.
+  try {
+    const { recordSkillActivation } = await import('../dist/hooks/keyword-detector.js');
+    const inputMessages = normalizeInputMessages(payload);
+    const latestUserInput = safeString(inputMessages.length > 0 ? inputMessages[inputMessages.length - 1] : '');
+    if (latestUserInput) {
+      await recordSkillActivation({
+        stateDir,
+        text: latestUserInput,
+        sessionId: payloadSessionId,
+        threadId: safeString(payload['thread-id'] || payload.thread_id || ''),
+        turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
+      });
+    }
+  } catch {
+    // Non-fatal: keyword detector module may not be built yet
+  }
+
   // 9. Auto-nudge: detect Codex stall patterns and automatically send a continuation prompt.
   //    Works for both leader and worker contexts.
   try {

package/skills/configure-notifications/SKILL.md

@@ -0,0 +1,278 @@
+---
+name: configure-notifications
+description: Configure OMX notifications - unified entry point for all platforms
+triggers:
+  - "configure notifications"
+  - "setup notifications"
+  - "notification settings"
+  - "configure discord"
+  - "configure telegram"
+  - "configure slack"
+  - "configure openclaw"
+  - "setup discord"
+  - "setup telegram"
+  - "setup slack"
+  - "setup openclaw"
+  - "discord notifications"
+  - "telegram notifications"
+  - "slack notifications"
+  - "openclaw notifications"
+  - "discord webhook"
+  - "telegram bot"
+  - "slack webhook"
+---
+
+# Configure OMX Notifications
+
+Unified entry point for setting up notifications across all supported platforms.
+OMX can notify you on Discord, Telegram, Slack, or your own OpenClaw gateway.
+
+## How This Skill Works
+
+This skill detects what's already configured, presents a menu, and delegates to the
+appropriate platform skill. It also handles cross-cutting settings like verbosity,
+notification profiles, reply listener, and idle cooldown.
+
+## Step 1: Detect Currently Configured Platforms
+
+```bash
+CONFIG_FILE="$HOME/.codex/.omx-config.json"
+
+if [ -f "$CONFIG_FILE" ]; then
+  DISCORD_ENABLED=$(jq -r '.notifications.discord.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+  DISCORD_BOT_ENABLED=$(jq -r '.notifications["discord-bot"].enabled // false' "$CONFIG_FILE" 2>/dev/null)
+  TELEGRAM_ENABLED=$(jq -r '.notifications.telegram.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+  SLACK_ENABLED=$(jq -r '.notifications.slack.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+  OPENCLAW_ENABLED=$(jq -r '.notifications.openclaw.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+  NOTIF_ENABLED=$(jq -r '.notifications.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+  VERBOSITY=$(jq -r '.notifications.verbosity // "session"' "$CONFIG_FILE" 2>/dev/null)
+  COOLDOWN=$(jq -r '.notifications.idleCooldownSeconds // 60' "$CONFIG_FILE" 2>/dev/null)
+  REPLY_ENABLED=$(jq -r '.notifications.reply.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+
+  echo "NOTIF_ENABLED=$NOTIF_ENABLED"
+  echo "DISCORD_ENABLED=$DISCORD_ENABLED"
+  echo "DISCORD_BOT_ENABLED=$DISCORD_BOT_ENABLED"
+  echo "TELEGRAM_ENABLED=$TELEGRAM_ENABLED"
+  echo "SLACK_ENABLED=$SLACK_ENABLED"
+  echo "OPENCLAW_ENABLED=$OPENCLAW_ENABLED"
+  echo "VERBOSITY=$VERBOSITY"
+  echo "COOLDOWN=$COOLDOWN"
+  echo "REPLY_ENABLED=$REPLY_ENABLED"
+else
+  echo "NO_CONFIG_FILE"
+fi
+```
+
+## Step 2: Show Current Status and Main Menu
+
+Display a summary of what's configured:
+
+```
+OMX Notification Status
+───────────────────────
+  Discord webhook: enabled / not configured
+  Discord bot:     enabled / not configured
+  Telegram:        enabled / not configured
+  Slack:           enabled / not configured
+  OpenClaw:        enabled / not configured
+
+  Verbosity:       session (default)
+  Idle cooldown:   60s
+  Reply listener:  disabled
+```
+
+Then use AskUserQuestion:
+
+**Question:** "What would you like to configure?"
+
+**Options:**
+1. **Discord** - Webhook or bot notifications to Discord channels
+2. **Telegram** - Bot notifications to personal or group chats
+3. **Slack** - Incoming webhook notifications to Slack channels
+4. **OpenClaw** - Self-hosted HTTP or CLI command gateway
+5. **Cross-cutting settings** - Verbosity, idle cooldown, profiles, reply listener
+6. **Disable all notifications** - Turn off all notification dispatching
+
+## Step 3: Delegate to Platform Skill
+
+Based on the user's choice, invoke the appropriate platform skill:
+
+- **Discord** → invoke `/configure-discord`
+- **Telegram** → invoke `/configure-telegram`
+- **Slack** → invoke `/configure-slack`
+- **OpenClaw** → invoke `/configure-openclaw`
+- **Cross-cutting settings** → continue with Step 4 below
+- **Disable all** → continue with Step 5 below
+
+When delegating, say: "Starting the [Platform] configuration wizard..." and invoke the skill.
+
+## Step 4: Cross-Cutting Settings
+
+If the user chose "Cross-cutting settings":
+
+### 4a. Verbosity
+
+Use AskUserQuestion:
+
+**Question:** "How verbose should notifications be?"
+
+**Options:**
+1. **session (Recommended)** - Start, idle, stop, end events + tmux snippet
+2. **minimal** - Start, stop, end only (no idle events, no tmux tail)
+3. **agent** - All session events plus ask-user-question prompts
+4. **verbose** - Everything including tool call output
+
+Write verbosity to config:
+
+```bash
+echo "$(cat "$CONFIG_FILE")" | jq \
+  --arg verbosity "$VERBOSITY" \
+  '.notifications.verbosity = $verbosity' > "$CONFIG_FILE"
+```
+
+Env var alternative: `OMX_NOTIFY_VERBOSITY=session`
+
+### 4b. Idle Notification Cooldown
+
+Use AskUserQuestion:
+
+**Question:** "How often should idle notifications fire at most? (in seconds)"
+
+**Options:**
+1. **60 seconds (default)** - At most once per minute
+2. **300 seconds** - At most once per 5 minutes
+3. **0 (disabled)** - Send every turn with no throttling
+4. **Custom** - Enter a number of seconds
+
+Write the cooldown to config:
+
+```bash
+echo "$(cat "$CONFIG_FILE")" | jq \
+  --argjson cooldown "$COOLDOWN_SECONDS" \
+  '.notifications.idleCooldownSeconds = $cooldown' > "$CONFIG_FILE"
+```
+
+Env var alternative: `OMX_IDLE_COOLDOWN_SECONDS=60`
+
+### 4c. Notification Profiles
+
+Explain that profiles let the user have different notification configs per context:
+
+```
+Notification Profiles
+─────────────────────
+Profiles let you switch notification targets based on context.
+For example: a "work" profile for your work Slack, a "personal"
+profile for your personal Telegram.
+
+Activate a profile with: OMX_NOTIFY_PROFILE=work
+or set a default: .omx-config.json > notifications.defaultProfile
+```
+
+Use AskUserQuestion:
+
+**Question:** "Would you like to configure notification profiles?"
+
+**Options:**
+1. **Yes** - Set up named profiles
+2. **No, use flat config** - Keep the current single-config setup
+
+If yes, guide the user to manually add profiles under `notifications.profiles` in `.omx-config.json`, and set `defaultProfile`.
+
+### 4d. Reply Listener
+
+Explain the reply listener:
+
+```
+Reply Listener
+──────────────
+The reply listener lets you send messages back to Codex from
+Discord (bot) or Telegram. When OMX asks for input, you can
+reply directly from your phone or messaging app.
+
+Requires:
+  - Discord Bot or Telegram platform configured
+  - OMX_REPLY_ENABLED=true in your shell profile
+  - For Discord: OMX_REPLY_DISCORD_USER_IDS=<your user ID>
+    (only messages from these IDs are accepted for security)
+```
+
+Use AskUserQuestion:
+
+**Question:** "Would you like to enable the reply listener?"
+
+**Options:**
+1. **Yes** - Enable two-way communication from Discord/Telegram
+2. **No** - Keep notifications one-way only
+
+If yes, write to config:
+
+```bash
+echo "$(cat "$CONFIG_FILE")" | jq \
+  '.notifications.reply = (.notifications.reply // {}) |
+   .notifications.reply.enabled = true' > "$CONFIG_FILE"
+```
+
+And remind them to set `OMX_REPLY_ENABLED=true` and (for Discord) `OMX_REPLY_DISCORD_USER_IDS`.
+
+## Step 5: Disable All Notifications
+
+If the user chose "Disable all notifications":
+
+Use AskUserQuestion:
+
+**Question:** "Are you sure you want to disable all notifications?"
+
+**Options:**
+1. **Yes, disable all** - Set notifications.enabled = false
+2. **No, go back** - Return to the main menu
+
+If confirmed:
+
+```bash
+echo "$(cat "$CONFIG_FILE")" | jq \
+  '.notifications.enabled = false' > "$CONFIG_FILE"
+```
+
+Confirm: "Notifications disabled. Re-enable anytime by running /configure-notifications."
+
+## Step 6: After Configuration
+
+After completing any platform or setting configuration, offer to configure another:
+
+Use AskUserQuestion:
+
+**Question:** "Would you like to configure another platform or setting?"
+
+**Options:**
+1. **Yes** - Return to the main menu (Step 2)
+2. **No, I'm done** - Show final summary and exit
+
+## Final Summary
+
+Display a summary of all active notification platforms:
+
+```
+OMX Notification Configuration Complete!
+─────────────────────────────────────────
+  Active platforms:
+    Discord webhook: enabled
+    Telegram:        enabled
+
+  Verbosity:       session
+  Idle cooldown:   60s
+  Reply listener:  disabled
+
+Config saved to: ~/.codex/.omx-config.json
+
+Quick reference — env vars:
+  OMX_DISCORD_WEBHOOK_URL=...
+  OMX_TELEGRAM_BOT_TOKEN=...
+  OMX_TELEGRAM_CHAT_ID=...
+  OMX_SLACK_WEBHOOK_URL=...
+  OMX_NOTIFY_VERBOSITY=session
+  OMX_IDLE_COOLDOWN_SECONDS=60
+  OMX_OPENCLAW=1
+
+Run /configure-notifications again to update any settings.
+```