claudecode-omc 4.5.7 → 4.8.0

package/skills/ccg/SKILL.md

@@ -1,44 +1,44 @@
 ---
 name: ccg
-description: Claude-Codex-Gemini tri-model orchestration - fans out backend tasks to Codex and frontend/UI tasks to Gemini in parallel, then Claude synthesizes results
+description: Claude-Codex-Gemini tri-model orchestration via ask-codex + ask-gemini, then Claude synthesizes results
 ---
 
 # CCG - Claude-Codex-Gemini Tri-Model Orchestration
 
-CCG spawns a tmux team with Codex and Gemini CLI workers running in parallel panes, then Claude synthesizes the results. Use this for tasks that benefit from multiple AI perspectives simultaneously.
+CCG routes through `ask-codex` and `ask-gemini` (CLI advisor flow), then Claude synthesizes both outputs into one answer.
+
+Use this when you want parallel external perspectives without launching tmux team workers.
 
 ## When to Use
 
-- Backend/analysis + frontend/UI work that can run truly in parallel
-- Code review from multiple perspectives (architecture + style simultaneously)
-- Research tasks where different models have complementary strengths
-- Any task you want to split across Codex (analytical) and Gemini (design/creative) workers
+- Backend/analysis + frontend/UI work in one request
+- Code review from multiple perspectives (architecture + design/UX)
+- Cross-validation where Codex and Gemini may disagree
+- Fast advisor-style parallel input without team runtime orchestration
 
 ## Requirements
 
 - **Codex CLI**: `npm install -g @openai/codex` (or `@openai/codex`)
 - **Gemini CLI**: `npm install -g @google/gemini-cli`
-- **tmux**: Must be running inside a tmux session
-- If either CLI is unavailable, CCG falls back to Claude-only execution
+- `omc ask` command available
+- If either CLI is unavailable, continue with whichever provider is available and note the limitation
 
 ## How It Works
 
-```
-1. Claude decomposes the request into:
-   - Backend/analytical tasks → Codex worker
-   - Frontend/UI/design tasks → Gemini worker
+```text
+1. Claude decomposes the request into two advisor prompts:
+   - Codex prompt (analysis/architecture/backend)
+   - Gemini prompt (UX/design/docs/alternatives)
 
-2. mcp__team__omc_run_team_start creates a tmux session with 2 workers:
-   omc-team-{name}
-   ├── Leader pane (Claude orchestrates)
-   ├── Worker pane 1: codex CLI (analytical tasks)
-   └── Worker pane 2: gemini CLI (design tasks)
+2. Claude runs:
+   - /oh-my-claudecode:ask-codex "<codex prompt>"
+   - /oh-my-claudecode:ask-gemini "<gemini prompt>"
 
-3. Workers read tasks from inbox files and write done.json on completion
+   (equivalent CLI path: `omc ask codex ...` + `omc ask gemini ...`)
 
-4. mcp__team__omc_run_team_wait blocks until all workers finish
+3. Artifacts are written under `.omc/artifacts/ask/`
 
-5. Claude reads taskResults and synthesizes into final output
+4. Claude synthesizes both outputs into one final response
 ```
 
 ## Execution Protocol
@@ -46,82 +46,65 @@ CCG spawns a tmux team with Codex and Gemini CLI workers running in parallel pan
 When invoked, Claude MUST follow this workflow:
 
 ### 1. Decompose Request
-Split the user's request into:
-- **Codex tasks**: code analysis, architecture review, backend logic, security review, test strategy
-- **Gemini tasks**: UI/UX design, documentation, visual analysis, large-context file review
-- **Synthesis task**: Claude combines results (always done by Claude, not delegated)
+Split the user request into:
 
-Choose a short `teamName` slug (e.g., `ccg-auth-review`).
+- **Codex prompt:** architecture, correctness, backend, risks, test strategy
+- **Gemini prompt:** UX/content clarity, alternatives, edge-case usability, docs polish
+- **Synthesis plan:** how to reconcile conflicts
 
-### 2. Start the team (non-blocking)
+### 2. Invoke ask skills
 
-Call `mcp__team__omc_run_team_start` — spawns workers in the background and returns a `jobId` immediately:
+Use skill routing first:
 
-```
-mcp__team__omc_run_team_start({
-  "teamName": "ccg-{slug}",
-  "agentTypes": ["codex", "gemini"],
-  "tasks": [
-    {"subject": "Codex task: ...", "description": "Full description of analytical work..."},
-    {"subject": "Gemini task: ...", "description": "Full description of design/UI work..."}
-  ],
-  "cwd": "{cwd}"
-})
+```bash
+/oh-my-claudecode:ask-codex <codex prompt>
+/oh-my-claudecode:ask-gemini <gemini prompt>
 ```
 
-Returns: `{ "jobId": "omc-...", "pid": 12345, "message": "Team started in background..." }`
+Equivalent direct CLI:
 
-### 3. Wait for completion
+```bash
+omc ask codex "<codex prompt>"
+omc ask gemini "<gemini prompt>"
+```
 
-Call `mcp__team__omc_run_team_wait` — blocks internally until done:
+### 3. Collect artifacts
 
-```
-mcp__team__omc_run_team_wait({
-  "job_id": "{jobId}",
-  "timeout_ms": 60000
-})
-```
+Read latest ask artifacts from:
 
-> **Timeout guidance:** `timeout_ms` is optional; the default wait timeout is fine.
-> If wait times out, workers/panes keep running. Call `omc_run_team_wait` again to keep
-> waiting. Use `omc_run_team_cleanup` only for explicit cancel intent.
-
-Returns when done:
-```json
-{
-  "status": "completed|failed",
-  "result": {
-    "taskResults": [
-      {"taskId": "1", "status": "completed", "summary": "..."},
-      {"taskId": "2", "status": "completed", "summary": "..."}
-    ]
-  }
-}
+```text
+.omc/artifacts/ask/codex-*.md
+.omc/artifacts/ask/gemini-*.md
 ```
 
-### 4. Synthesize Results
+### 4. Synthesize
 
-Parse `result.taskResults` and synthesize Codex + Gemini outputs into a unified response for the user.
+Return one unified answer with:
 
-## Fallback (CLIs Not Available)
+- Agreed recommendations
+- Conflicting recommendations (explicitly called out)
+- Chosen final direction + rationale
+- Action checklist
 
-CLI availability is checked by the MCP runtime automatically. If a CLI is not installed, the worker exits with `command not found`. In that case, fall back to Claude Task agents:
+## Fallbacks
 
-```
-[CCG] Codex/Gemini CLI not found. Falling back to Claude-only execution.
-```
+If one provider is unavailable:
+
+- Continue with available provider + Claude synthesis
+- Clearly note missing perspective and risk
+
+If both unavailable:
 
-Use standard Claude Task agents instead:
-- `Task(subagent_type="oh-my-claudecode:executor", model="sonnet", ...)` for analytical tasks
-- `Task(subagent_type="oh-my-claudecode:designer", model="sonnet", ...)` for design tasks
+- Fall back to Claude-only answer and state CCG external advisors were unavailable
 
 ## Invocation
 
-```
-/oh-my-claudecode:ccg [task description]
+```bash
+/oh-my-claudecode:ccg <task description>
 ```
 
 Example:
-```
-/oh-my-claudecode:ccg Review this PR - check architecture and code quality (Codex) and UI components (Gemini)
+
+```bash
+/oh-my-claudecode:ccg Review this PR - architecture/security via Codex and UX/readability via Gemini
 ```

package/skills/configure-notifications/SKILL.md

@@ -935,3 +935,279 @@ Offer to send a test notification with the new template.
 ## Related
 
 - `/oh-my-claudecode:configure-openclaw` — Configure OpenClaw gateway integration
+
+---
+
+## Custom Integration (OpenClaw, n8n, CLI, etc.)
+
+Configure custom webhooks and CLI commands for services beyond the native Discord/Telegram/Slack integrations.
+
+### Routing
+
+If the user says "custom integration", "openclaw", "n8n", "webhook", "cli command", or similar → follow this section.
+
+### Migration from OpenClaw
+
+If `~/.claude/omc_config.openclaw.json` exists, detect and offer migration:
+
+**Step 1: Detect Legacy Config**
+```bash
+LEGACY_CONFIG="$HOME/.claude/omc_config.openclaw.json"
+if [ -f "$LEGACY_CONFIG" ]; then
+  echo "LEGACY_FOUND=true"
+  # Check if already migrated
+  if jq -e '.customIntegrations.integrations[] | select(.preset == "openclaw")' "$CONFIG_FILE" >/dev/null 2>&1; then
+    echo "ALREADY_MIGRATED=true"
+  else
+    echo "ALREADY_MIGRATED=false"
+  fi
+else
+  echo "LEGACY_FOUND=false"
+fi
+```
+
+**Step 2: Offer Migration**
+If legacy found and not migrated:
+
+**Question:** "Existing OpenClaw configuration detected. Would you like to migrate it to the new format?"
+
+**Options:**
+1. **Yes, migrate now** - Convert legacy config to custom integration
+2. **No, configure fresh** - Skip migration and start new
+3. **Show me the legacy config first** - Display current OpenClaw settings
+
+If migrate:
+- Read `omc_config.openclaw.json`
+- Transform to custom integration format
+- Save to `.omc-config.json`
+- Backup legacy to `omc_config.openclaw.json.bak`
+- Show success message
+
+### Custom Integration Wizard
+
+**Step 1: Select Integration Type**
+
+**Question:** "Which type of custom integration would you like to configure?"
+
+**Options:**
+1. **OpenClaw Gateway** - Wake external automations and AI agents
+2. **n8n Webhook** - Trigger n8n workflows
+3. **ClawdBot** - Send notifications to ClawdBot
+4. **Generic Webhook** - Custom HTTPS webhook
+5. **Generic CLI Command** - Execute shell command on events
+
+### OpenClaw/n8n/ClawdBot Preset Flow
+
+**Step 2: Gateway URL**
+
+**Question:** "What is your gateway/webhook URL?"
+
+**Validation:**
+- Must be HTTPS (except localhost for development)
+- Must be valid URL format
+
+**Step 3: Authentication (Optional)**
+
+**Question:** "Does your gateway require authentication?"
+
+**Options:**
+1. **Bearer token** - Authorization: Bearer <token>
+2. **Custom header** - Name and value
+3. **No authentication**
+
+If Bearer: ask for token
+If Custom: ask for header name and value
+
+**Step 4: Events**
+
+Use AskUserQuestion with multiSelect:
+
+**Question:** "Which events should trigger this integration?"
+
+**Options (with defaults from preset):**
+- session-start
+- session-end
+- session-stop
+- session-idle
+- ask-user-question
+
+Default for OpenClaw: session-start, session-end, stop
+Default for n8n: session-end, ask-user-question
+
+**Step 5: Test**
+
+**Question:** "Send a test notification to verify the configuration?"
+
+**Options:**
+1. **Yes, test now** - Send test webhook
+2. **No, skip test**
+
+If test:
+```bash
+# For webhook integrations
+curl -X POST \
+  -H "Content-Type: application/json" \
+  ${AUTH_HEADER:+"-H \"$AUTH_HEADER\""} \
+  -d '{"event":"test","instruction":"OMC test notification","timestamp":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"}' \
+  "$WEBHOOK_URL"
+```
+
+Show result (HTTP status, any error).
+
+**Step 6: Write Configuration**
+
+Merge into `.omc-config.json`:
+
+```json
+{
+  "notifications": { /* existing native configs */ },
+  "customIntegrations": {
+    "enabled": true,
+    "integrations": [
+      {
+        "id": "my-openclaw",
+        "type": "webhook",
+        "preset": "openclaw",
+        "enabled": true,
+        "config": {
+          "url": "https://my-gateway.example.com/wake",
+          "method": "POST",
+          "headers": {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer ..."
+          },
+          "bodyTemplate": "{\\"event\\":\\"{{event}}\\",\\"instruction\\":\\"Session {{sessionId}} {{event}}\\",\\"timestamp\\":\\"{{timestamp}}\\"}",
+          "timeout": 10000
+        },
+        "events": ["session-start", "session-end"]
+      }
+    ]
+  }
+}
+```
+
+### Generic Webhook Flow
+
+**Step 2: URL**
+Ask for webhook URL (HTTPS required).
+
+**Step 3: Method**
+Ask for HTTP method (GET, POST, PUT, PATCH, DELETE). Default: POST.
+
+**Step 4: Headers**
+Ask for headers in "Name: Value" format, one per line. Default: Content-Type: application/json
+
+**Step 5: Body Template**
+Show available template variables and ask for body template (JSON or other format).
+
+Default:
+```json
+{
+  "event": "{{event}}",
+  "sessionId": "{{sessionId}}",
+  "projectName": "{{projectName}}",
+  "timestamp": "{{timestamp}}"
+}
+```
+
+**Step 6: Timeout**
+Ask for timeout in milliseconds (1000-60000). Default: 10000.
+
+**Step 7: Events**
+Multi-select events.
+
+**Step 8: Test and Save**
+Same as preset flow.
+
+### Generic CLI Command Flow
+
+**Step 2: Command**
+
+**Question:** "What command should be executed? (single executable, no arguments)"
+
+**Example:** `curl`, `/usr/local/bin/my-script`, `notify-send`
+
+**Validation:**
+- No spaces
+- No shell metacharacters
+
+**Step 3: Arguments**
+
+**Question:** "Command arguments (use {{variable}} for dynamic values). Enter one per line."
+
+**Example:**
+```
+-X
+POST
+-d
+{"event":"{{event}}","session":"{{sessionId}}"}
+https://my-api.com/notify
+```
+
+Show available template variables reference.
+
+**Step 4: Timeout**
+Ask for timeout (1000-60000ms). Default: 5000.
+
+**Step 5: Events**
+Multi-select events.
+
+**Step 6: Test and Save**
+
+For test, execute command with test values:
+```bash
+$COMMAND "${ARGS[@]//{{event}}/test}"
+```
+
+Show stdout/stderr and exit code.
+
+### Managing Custom Integrations
+
+**List existing:**
+```bash
+jq '.customIntegrations.integrations[] | {id, type, preset, enabled, events}' "$CONFIG_FILE"
+```
+
+**Disable/Enable:**
+```bash
+# Disable
+jq '.customIntegrations.integrations = [.customIntegrations.integrations[] | if .id == "my-integration" then .enabled = false else . end]' "$CONFIG_FILE"
+
+# Enable
+jq '.customIntegrations.integrations = [.customIntegrations.integrations[] | if .id == "my-integration" then .enabled = true else . end]' "$CONFIG_FILE"
+```
+
+**Remove:**
+```bash
+jq '.customIntegrations.integrations = [.customIntegrations.integrations[] | select(.id != "my-integration")]' "$CONFIG_FILE"
+```
+
+### Template Variables Reference
+
+All custom integrations support these template variables:
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{{sessionId}}` | Unique session ID | `sess_abc123` |
+| `{{projectPath}}` | Full project path | `/home/user/my-project` |
+| `{{projectName}}` | Project directory name | `my-project` |
+| `{{timestamp}}` | ISO 8601 timestamp | `2026-03-05T14:30:00Z` |
+| `{{event}}` | Event name | `session-end` |
+| `{{duration}}` | Human-readable duration | `45s` |
+| `{{durationMs}}` | Duration in milliseconds | `45000` |
+| `{{reason}}` | Stop/end reason | `completed` |
+| `{{tmuxSession}}` | tmux session name | `claude:my-project` |
+
+Session-end only:
+- `{{agentsSpawned}}`, `{{agentsCompleted}}`, `{{modesUsed}}`, `{{contextSummary}}`
+
+Ask-user-question only:
+- `{{question}}`
+
+---
+
+## Related
+
+- Template variables: `src/notifications/template-variables.ts`
+- Validation: `src/notifications/validation.ts`
+- Presets: `src/notifications/presets.ts`

package/skills/configure-openclaw/SKILL.md

@@ -1,3 +1,66 @@
+---
+name: configure-openclaw
+description: DEPRECATED - Use configure-notifications with Custom Integration instead
+triggers:
+  - "configure openclaw"
+  - "setup openclaw"
+  - "openclaw gateway"
+  - "openclaw setup"
+---
+
+# Configure OpenClaw (DEPRECATED)
+
+> **DEPRECATED**: This skill is deprecated and will be removed in a future version.
+> Please use `/oh-my-claudecode:configure-notifications` and select "Custom Integration (OpenClaw, n8n, CLI, etc.)" instead.
+> 
+> The new approach provides:
+> - Same OpenClaw functionality
+> - Additional presets (n8n, ClawdBot)
+> - Generic webhook and CLI support
+> - Migration tool for existing configs
+
+---
+
+## Migration Notice
+
+When this skill is invoked, show the deprecation warning and redirect:
+
+**Message to display:**
+```
+⚠️  DEPRECATION NOTICE
+
+The /configure-openclaw skill is deprecated and will be removed in a future version.
+
+Please use instead:
+  /oh-my-claudecode:configure-notifications
+
+Then select: "Custom Integration (OpenClaw, n8n, CLI, etc.)" → "OpenClaw Gateway"
+
+The new wizard will:
+1. Detect your existing OpenClaw config (if any)
+2. Offer to migrate it automatically
+3. Provide the same functionality with better UX
+```
+
+**AskUserQuestion:**
+
+**Question:** "The configure-openclaw skill is deprecated. How would you like to proceed?"
+
+**Options:**
+1. **Open the new configure-notifications wizard (Recommended)** - Redirect to the new skill
+2. **Continue with legacy setup** - Use this deprecated skill anyway
+3. **Learn more about the migration** - Show detailed migration information
+
+If option 1: Redirect to `/oh-my-claudecode:configure-notifications`
+If option 2: Continue with legacy instructions below
+If option 3: Show detailed migration guide
+
+---
+
+## Legacy Instructions
+
+The following instructions are kept for backward compatibility but will be removed.
+
 ---
 name: configure-openclaw
 description: Configure OpenClaw gateway integration for waking external automations and AI agents on hook events