claudecode-omc 4.5.7 → 4.7.4

package/skills/cancel/SKILL.md

@@ -51,7 +51,8 @@ Active modes are still cancelled in dependency order:
 6. Ultrapilot (standalone)
 7. Pipeline (standalone)
 8. Team (Claude Code native)
-9. Plan Consensus (standalone)
+9. OMC Teams (tmux CLI workers)
+10. Plan Consensus (standalone)
 
 ## Force Clear All
 
@@ -70,6 +71,7 @@ Steps under the hood:
 2. `state_clear` runs once per session to drop that session’s files.
 3. A global `state_clear` without `session_id` removes legacy files under `.omc/state/*.json`, `.omc/state/swarm*.db`, and compatibility artifacts (see list).
 4. Team artifacts (`~/.claude/teams/*/`, `~/.claude/tasks/*/`, `.omc/state/team-state.json`) are best-effort cleared as part of the legacy fallback.
+   - Cancel for native team does NOT affect omc-teams state, and vice versa.
 
 Every `state_clear` command honors the `session_id` argument, so even force mode still uses the session-aware paths first before deleting legacy files.
 
@@ -88,6 +90,7 @@ Legacy compatibility list (removed only under `--force`/`--all`):
 - `.omc/state/ultrapilot-state.json`
 - `.omc/state/ultrapilot-ownership.json`
 - `.omc/state/pipeline-state.json`
+- `.omc/state/omc-teams-state.json`
 - `.omc/state/plan-consensus.json`
 - `.omc/state/ralplan-state.json`
 - `.omc/state/boulder.json`
@@ -205,127 +208,42 @@ Team "{team_name}" cancelled:
 4. Wait briefly for shutdown responses (15s per member timeout)
 5. Re-read config.json to check for remaining members (reconciliation pass)
 6. Call `TeamDelete()` to clean up
-7. Remove any local state: `rm -f .omc/state/team-state.json`
+7. Clear team state: `state_clear(mode="team", session_id)`
 8. Report structured summary to user
 
 #### If Autopilot Active
 
-Call `cancelAutopilot()` from `src/hooks/autopilot/cancel.ts:27-78`:
+Autopilot handles its own cleanup including linked ralph and ultraqa.
 
-```bash
-# Autopilot handles its own cleanup + ralph + ultraqa
-# Just mark autopilot as inactive (preserves state for resume)
-if [[ -f .omc/state/autopilot-state.json ]]; then
-  # Clean up ralph if active
-  if [[ -f .omc/state/ralph-state.json ]]; then
-    RALPH_STATE=$(cat .omc/state/ralph-state.json)
-    LINKED_UW=$(echo "$RALPH_STATE" | jq -r '.linked_ultrawork // false')
-
-    # Clean linked ultrawork first
-    if [[ "$LINKED_UW" == "true" ]] && [[ -f .omc/state/ultrawork-state.json ]]; then
-      rm -f .omc/state/ultrawork-state.json
-      echo "Cleaned up: ultrawork (linked to ralph)"
-    fi
-
-    # Clean ralph
-    rm -f .omc/state/ralph-state.json
-    rm -f .omc/state/ralph-verification.json
-    echo "Cleaned up: ralph"
-  fi
-
-  # Clean up ultraqa if active
-  if [[ -f .omc/state/ultraqa-state.json ]]; then
-    rm -f .omc/state/ultraqa-state.json
-    echo "Cleaned up: ultraqa"
-  fi
-
-  # Mark autopilot inactive but preserve state
-  CURRENT_STATE=$(cat .omc/state/autopilot-state.json)
-  CURRENT_PHASE=$(echo "$CURRENT_STATE" | jq -r '.phase // "unknown"')
-  echo "$CURRENT_STATE" | jq '.active = false' > .omc/state/autopilot-state.json
-
-  echo "Autopilot cancelled at phase: $CURRENT_PHASE. Progress preserved for resume."
-  echo "Run /oh-my-claudecode:autopilot to resume."
-fi
-```
+1. Read autopilot state via `state_read(mode="autopilot", session_id)` to get current phase
+2. Check for linked ralph via `state_read(mode="ralph", session_id)`:
+   - If ralph is active and has `linked_ultrawork: true`, clear ultrawork first: `state_clear(mode="ultrawork", session_id)`
+   - Clear ralph: `state_clear(mode="ralph", session_id)`
+3. Check for linked ultraqa via `state_read(mode="ultraqa", session_id)`:
+   - If active, clear it: `state_clear(mode="ultraqa", session_id)`
+4. Mark autopilot inactive (preserve state for resume) via `state_write(mode="autopilot", session_id, state={active: false, ...existing})`
 
 #### If Ralph Active (but not Autopilot)
 
-Call `clearRalphState()` + `clearLinkedUltraworkState()` from `src/hooks/ralph-loop/index.ts:147-182`:
-
-```bash
-if [[ -f .omc/state/ralph-state.json ]]; then
-  # Check if ultrawork is linked
-  RALPH_STATE=$(cat .omc/state/ralph-state.json)
-  LINKED_UW=$(echo "$RALPH_STATE" | jq -r '.linked_ultrawork // false')
-
-  # Clean linked ultrawork first
-  if [[ "$LINKED_UW" == "true" ]] && [[ -f .omc/state/ultrawork-state.json ]]; then
-    UW_STATE=$(cat .omc/state/ultrawork-state.json)
-    UW_LINKED=$(echo "$UW_STATE" | jq -r '.linked_to_ralph // false')
-
-    # Only clear if it was linked to ralph
-    if [[ "$UW_LINKED" == "true" ]]; then
-      rm -f .omc/state/ultrawork-state.json
-      echo "Cleaned up: ultrawork (linked to ralph)"
-    fi
-  fi
-
-  # Clean ralph state
-  rm -f .omc/state/ralph-state.json
-  rm -f .omc/state/ralph-plan-state.json
-  rm -f .omc/state/ralph-verification.json
-
-  echo "Ralph cancelled. Persistent mode deactivated."
-fi
-```
+1. Read ralph state via `state_read(mode="ralph", session_id)` to check for linked ultrawork
+2. If `linked_ultrawork: true`:
+   - Read ultrawork state to verify `linked_to_ralph: true`
+   - If linked, clear ultrawork: `state_clear(mode="ultrawork", session_id)`
+3. Clear ralph: `state_clear(mode="ralph", session_id)`
 
 #### If Ultrawork Active (standalone, not linked)
 
-Call `deactivateUltrawork()` from `src/hooks/ultrawork/index.ts:150-173`:
-
-```bash
-if [[ -f .omc/state/ultrawork-state.json ]]; then
-  # Check if linked to ralph
-  UW_STATE=$(cat .omc/state/ultrawork-state.json)
-  LINKED=$(echo "$UW_STATE" | jq -r '.linked_to_ralph // false')
-
-  if [[ "$LINKED" == "true" ]]; then
-    echo "Ultrawork is linked to Ralph. Use /oh-my-claudecode:cancel to cancel both."
-    exit 1
-  fi
-
-  # Remove local state
-  rm -f .omc/state/ultrawork-state.json
-
-  echo "Ultrawork cancelled. Parallel execution mode deactivated."
-fi
-```
+1. Read ultrawork state via `state_read(mode="ultrawork", session_id)`
+2. If `linked_to_ralph: true`, warn user to cancel ralph instead (which cascades)
+3. Otherwise clear: `state_clear(mode="ultrawork", session_id)`
 
 #### If UltraQA Active (standalone)
 
-Call `clearUltraQAState()` from `src/hooks/ultraqa/index.ts:107-120`:
-
-```bash
-if [[ -f .omc/state/ultraqa-state.json ]]; then
-  rm -f .omc/state/ultraqa-state.json
-  echo "UltraQA cancelled. QA cycling workflow stopped."
-fi
-```
+Clear directly: `state_clear(mode="ultraqa", session_id)`
 
 #### No Active Modes
 
-```bash
-echo "No active OMC modes detected."
-echo ""
-echo "Checked for:"
-echo "  - Autopilot (.omc/state/autopilot-state.json)"
-echo "  - Ralph (.omc/state/ralph-state.json)"
-echo "  - Ultrawork (.omc/state/ultrawork-state.json)"
-echo "  - UltraQA (.omc/state/ultraqa-state.json)"
-echo ""
-echo "Use --force to clear all state files anyway."
-```
+Report: "No active OMC modes detected. Use --force to clear all state files anyway."
 
 ## Implementation Notes
 

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`