oh-my-codex 0.6.4 → 0.7.0

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.
+```

package/skills/configure-openclaw/SKILL.md

@@ -0,0 +1,267 @@
+---
+name: configure-openclaw
+description: Configure OpenClaw notification gateway via natural language
+triggers:
+  - "configure openclaw"
+  - "setup openclaw"
+  - "openclaw notifications"
+  - "openclaw gateway"
+---
+
+# Configure OpenClaw Notifications
+
+Set up OpenClaw as a notification gateway so OMX can route session events through your own HTTP endpoint or CLI command.
+
+## What is OpenClaw?
+
+OpenClaw is a self-hosted notification gateway that lets you receive OMX events however you want — HTTP webhooks to your own server, shell commands, or any integration you build. Unlike platform-specific notifiers (Discord, Slack), OpenClaw gives you full control over message routing and format.
+
+**Two gateway modes:**
+- **HTTP Gateway** — OMX POSTs JSON events to your HTTP endpoint
+- **CLI Command Gateway** — OMX runs a shell command with event data as arguments or stdin
+
+## How This Skill Works
+
+This is an interactive, natural-language configuration skill. Walk the user through setup by asking questions with AskUserQuestion. Write the result to `~/.codex/.omx-config.json`.
+
+## Step 1: Detect Existing Configuration
+
+```bash
+CONFIG_FILE="$HOME/.codex/.omx-config.json"
+
+if [ -f "$CONFIG_FILE" ]; then
+  HAS_OPENCLAW=$(jq -r '.notifications.openclaw.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+  GATEWAY_TYPE=$(jq -r '.notifications.openclaw.gatewayType // empty' "$CONFIG_FILE" 2>/dev/null)
+  ENDPOINT=$(jq -r '.notifications.openclaw.endpoint // empty' "$CONFIG_FILE" 2>/dev/null)
+  COMMAND=$(jq -r '.notifications.openclaw.command // empty' "$CONFIG_FILE" 2>/dev/null)
+
+  if [ "$HAS_OPENCLAW" = "true" ]; then
+    echo "EXISTING_CONFIG=true"
+    echo "GATEWAY_TYPE=$GATEWAY_TYPE"
+    [ -n "$ENDPOINT" ] && echo "ENDPOINT=$ENDPOINT"
+    [ -n "$COMMAND" ] && echo "COMMAND=$COMMAND"
+  else
+    echo "EXISTING_CONFIG=false"
+  fi
+else
+  echo "NO_CONFIG_FILE"
+fi
+```
+
+If existing config is found, show the user what's currently configured and ask if they want to update or reconfigure.
+
+## Step 2: Choose Gateway Type
+
+Use AskUserQuestion:
+
+**Question:** "Which OpenClaw gateway mode do you want to use?"
+
+**Options:**
+1. **HTTP Gateway** - OMX sends a POST request with JSON to your endpoint. Good for web servers, n8n, Zapier webhooks, or any HTTP-capable service.
+2. **CLI Command Gateway** - OMX runs a shell command you specify. Good for local scripts, custom notification tools, or anything shell-scriptable.
+
+## Step 3A: HTTP Gateway Setup
+
+If user chose HTTP:
+
+Use AskUserQuestion:
+
+**Question:** "Enter your OpenClaw HTTP endpoint URL. OMX will POST JSON event data to this URL."
+
+The user types their URL in the "Other" field.
+
+**Validate** the URL:
+- Must start with `http://` or `https://`
+- If invalid, explain the format and ask again
+
+### Optional: Secret Header
+
+Use AskUserQuestion:
+
+**Question:** "Add an authorization header to secure requests? (Optional)"
+
+**Options:**
+1. **Yes, add Bearer token** - Sends `Authorization: Bearer <token>`
+2. **Yes, add custom header** - Specify header name and value
+3. **No auth header** - Open endpoint (use firewall rules or IP allowlist instead)
+
+If they want a Bearer token or custom header, collect the values.
+
+## Step 3B: CLI Command Gateway Setup
+
+If user chose CLI Command:
+
+Use AskUserQuestion:
+
+**Question:** "Enter the shell command OMX should run for each notification event. Use these placeholders:
+- `{event}` — event name (e.g. session-end)
+- `{session_id}` — session identifier
+- `{project}` — project name/path
+- `{message}` — formatted notification message
+
+Example: `notify-send 'OMX: {event}' '{message}'`
+Example: `~/.local/bin/my-notifier --event {event} --msg '{message}'`"
+
+The user types their command in the "Other" field.
+
+**IMPORTANT: Dual activation gate for CLI Command gateways**
+
+CLI command gateways require TWO environment variables to be set:
+- `OMX_OPENCLAW=1` — enables the OpenClaw gateway
+- `OMX_OPENCLAW_COMMAND=1` — specifically enables CLI command execution
+
+This two-gate design prevents accidental command execution when only the config file is present. Remind the user to set both in their shell profile.
+
+## Step 4: Map Events
+
+Use AskUserQuestion with multiSelect:
+
+**Question:** "Which events should be routed through OpenClaw?"
+
+**Options (multiSelect: true):**
+1. **Session end (Recommended)** - When a Codex session finishes
+2. **Input needed** - When Codex is waiting for your response
+3. **Session start** - When a new session begins
+4. **Session continuing** - When a persistent mode keeps the session alive
+
+Default selection: session-end + ask-user-question.
+
+## Step 5: Write Configuration
+
+Read the existing config, merge the OpenClaw settings, and write back:
+
+```bash
+CONFIG_FILE="$HOME/.codex/.omx-config.json"
+mkdir -p "$(dirname "$CONFIG_FILE")"
+
+if [ -f "$CONFIG_FILE" ]; then
+  EXISTING=$(cat "$CONFIG_FILE")
+else
+  EXISTING='{}'
+fi
+```
+
+### For HTTP Gateway:
+
+```bash
+# ENDPOINT, AUTH_HEADER_NAME, AUTH_HEADER_VALUE are collected from user
+echo "$EXISTING" | jq \
+  --arg endpoint "$ENDPOINT" \
+  --arg headerName "$AUTH_HEADER_NAME" \
+  --arg headerValue "$AUTH_HEADER_VALUE" \
+  '.notifications = (.notifications // {enabled: true}) |
+   .notifications.enabled = true |
+   .notifications.openclaw = {
+     enabled: true,
+     gatewayType: "http",
+     endpoint: $endpoint,
+     headers: (if $headerName == "" then null else {($headerName): $headerValue} end)
+   }' > "$CONFIG_FILE"
+```
+
+### For CLI Command Gateway:
+
+```bash
+# COMMAND is collected from user
+echo "$EXISTING" | jq \
+  --arg command "$COMMAND" \
+  '.notifications = (.notifications // {enabled: true}) |
+   .notifications.enabled = true |
+   .notifications.openclaw = {
+     enabled: true,
+     gatewayType: "command",
+     command: $command
+   }' > "$CONFIG_FILE"
+```
+
+### Add event-specific config if user didn't select all events:
+
+```bash
+# Example: disable session-start if not selected
+echo "$(cat "$CONFIG_FILE")" | jq \
+  '.notifications.events = (.notifications.events // {}) |
+   .notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"
+```
+
+## Step 6: Explain Activation Gates
+
+Regardless of gateway type, explain the activation model:
+
+```
+OpenClaw Activation Gates
+─────────────────────────
+OpenClaw requires environment variables to be set before it activates.
+This prevents accidental notifications in shared or CI environments.
+
+For HTTP Gateway:
+  export OMX_OPENCLAW=1
+
+For CLI Command Gateway (requires both):
+  export OMX_OPENCLAW=1
+  export OMX_OPENCLAW_COMMAND=1
+
+Add these to your ~/.zshrc or ~/.bashrc.
+```
+
+## Step 7: Test the Configuration
+
+After writing config, offer to test:
+
+Use AskUserQuestion:
+
+**Question:** "Send a test notification through OpenClaw to verify the setup?"
+
+**Options:**
+1. **Yes, test now (Recommended)** - Run a test dispatch
+2. **No, I'll test later** - Skip testing
+
+### If testing HTTP Gateway:
+
+```bash
+curl -s -o /dev/null -w "%{http_code}" \
+  -H "Content-Type: application/json" \
+  ${AUTH_HEADER_NAME:+-H "$AUTH_HEADER_NAME: $AUTH_HEADER_VALUE"} \
+  -d '{"event":"test","message":"OMX OpenClaw test notification","session_id":"test"}' \
+  "$ENDPOINT"
+```
+
+### If testing CLI Command Gateway:
+
+Replace placeholders in the command with test values and run it.
+
+Report success or failure. If it fails, help debug (check URL accessibility, command path, permissions).
+
+## Step 8: Confirm
+
+Display the final configuration summary:
+
+```
+OpenClaw Gateway Configured!
+
+  Type:     HTTP / CLI Command
+  Endpoint: https://your-server/omx-hook  (HTTP only)
+  Command:  notify-send 'OMX' '{message}'  (CLI only)
+  Events:   session-end, ask-user-question
+
+Config saved to: ~/.codex/.omx-config.json
+
+Activation (add to ~/.zshrc or ~/.bashrc):
+  export OMX_OPENCLAW=1
+  export OMX_OPENCLAW_COMMAND=1   # CLI Command gateways only
+
+To reconfigure: /configure-openclaw
+To configure other platforms: /configure-notifications
+```
+
+## Environment Variable Reference
+
+```bash
+# Required for all OpenClaw gateways
+export OMX_OPENCLAW=1
+
+# Required additionally for CLI Command gateways
+export OMX_OPENCLAW_COMMAND=1
+
+# HTTP gateway: override endpoint URL
+export OMX_OPENCLAW_URL="https://your-server/omx-hook"
+```