claudecode-omc 4.4.4 → 4.4.6

package/scripts/test-codex-gemini-team.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Live test: spawn a 2-worker tmux team with Codex + Gemini CLI workers.
+ * Must be run inside tmux. Panes will appear in the current window.
+ * Usage: node scripts/test-codex-gemini-team.mjs
+ */
+import { startTeam, monitorTeam, shutdownTeam } from '../dist/team/runtime.js';
+
+const CWD = process.cwd();
+
+const config = {
+  teamName: 'cgtest',
+  workerCount: 2,
+  agentTypes: ['codex', 'gemini'],
+  tasks: [
+    {
+      subject: 'Write a haiku about tmux split panes',
+      description: [
+        'Write a haiku (3 lines, 5-7-5 syllables) about tmux split panes.',
+        'Save the haiku to the file: ' + CWD + '/done.json',
+        'The file should be valid JSON: {"taskId":"1","status":"completed","summary":"<your haiku here>","completedAt":"' + new Date().toISOString() + '"}',
+        'Write the file and exit.',
+      ].join(' '),
+    },
+    {
+      subject: 'Write a haiku about AI collaboration',
+      description: [
+        'Write a haiku (3 lines, 5-7-5 syllables) about AI models collaborating.',
+        'Save the haiku to the file: ' + CWD + '/farewell.txt',
+        'The file should contain just the haiku text.',
+        'Write the file and exit.',
+      ].join(' '),
+    },
+  ],
+  cwd: CWD,
+};
+
+console.log('\n🚀 Starting tmux team "cgtest" with Codex + Gemini workers...\n');
+
+const runtime = await startTeam(config);
+
+console.log('✅ Team started!');
+console.log(`   tmux target  : ${runtime.sessionName}`);
+console.log(`   workers      : ${runtime.workerNames.join(', ')}`);
+console.log(`   pane IDs     : ${runtime.workerPaneIds.join(', ')}`);
+console.log('\n⏳ Monitoring... (polling every 5s, timeout 120s)\n');
+
+const deadline = Date.now() + 120_000;
+let done = false;
+
+while (Date.now() < deadline && !done) {
+  await new Promise(r => setTimeout(r, 5000));
+  const snap = await monitorTeam(runtime.teamName, runtime.cwd, runtime.workerPaneIds);
+  const { pending, inProgress, completed, failed } = snap.taskCounts;
+  console.log(`   [${new Date().toLocaleTimeString()}] phase=${snap.phase}  pending=${pending} inProgress=${inProgress} completed=${completed} failed=${failed}`);
+  snap.deadWorkers.forEach(w => console.log(`   ⚠️  dead worker: ${w}`));
+  if (snap.phase === 'completed' || snap.phase === 'failed') {
+    done = true;
+  }
+}
+
+if (!done) {
+  console.log('\n⚠️  Timeout — shutting down anyway\n');
+}
+
+console.log('\n🛑 Shutting down team...');
+await shutdownTeam(runtime.teamName, runtime.sessionName, runtime.cwd, 15_000, runtime.workerPaneIds, runtime.leaderPaneId);
+console.log('✅ Team shut down cleanly.\n');
+
+// Show results
+import { readFileSync, existsSync } from 'fs';
+if (existsSync(CWD + '/done.json')) {
+  const d = JSON.parse(readFileSync(CWD + '/done.json', 'utf-8'));
+  console.log('📄 Codex result (done.json):', d.summary || d);
+}
+if (existsSync(CWD + '/farewell.txt')) {
+  console.log('📄 Gemini result (farewell.txt):\n' + readFileSync(CWD + '/farewell.txt', 'utf-8'));
+}

package/skills/AGENTS.md

@@ -31,7 +31,7 @@ Skills are reusable workflow templates that can be invoked via `/oh-my-claudecod
 | File | Skill | Purpose |
 |-----------|-------|---------|
 | `plan/SKILL.md` | plan | Strategic planning with interview workflow |
-| `ralplan/SKILL.md` | ralplan | Iterative planning (Planner+Architect+Critic) |
+| `ralplan/SKILL.md` | ralplan | Iterative planning (Planner+Architect+Critic) with RALPLAN-DR structured deliberation (`--deliberate` for high-risk) |
 | `review/SKILL.md` | review | Review plan with Critic |
 | `analyze/SKILL.md` | analyze | Deep analysis and investigation |
 | `ralph-init/SKILL.md` | ralph-init | Initialize PRD for structured ralph |
@@ -197,4 +197,7 @@ Some skills activate automatically based on context:
 | git-master | Git operations detected |
 | cancel | "stop", "cancel", "abort" |
 
-<!-- MANUAL: -->
+<!-- MANUAL:
+- Team runtime wait semantics: `omc_run_team_wait.timeout_ms` only limits the wait call and does not stop workers.
+- `timeoutSeconds` is removed from `omc_run_team_start`; use explicit `omc_run_team_cleanup` for intentional worker pane termination.
+-->

package/skills/analyze/SKILL.md

@@ -4,7 +4,7 @@ description: Deep analysis and investigation
 ---
 
 <Purpose>
-Analyze performs deep investigation of architecture, bugs, performance issues, and dependencies. It routes to the architect agent or Codex MCP for thorough analysis and returns structured findings with evidence.
+Analyze performs deep investigation of architecture, bugs, performance issues, and dependencies. It routes to the architect Claude agent for thorough analysis and returns structured findings with evidence.
 </Purpose>
 
 <Use_When>
@@ -27,26 +27,20 @@ Deep investigation requires a different approach than quick lookups or code chan
 </Why_This_Exists>
 
 <Execution_Policy>
-- Prefer Codex MCP for analysis when available (faster, lower cost)
-- Fall back to architect Claude agent when Codex is unavailable
-- Always provide context files to the analysis tool for grounded reasoning
+- Route analysis to the architect Claude agent for thorough investigation
+- Always gather context files before spawning the architect agent for grounded reasoning
 - Return structured findings, not just raw observations
 </Execution_Policy>
 
 <Steps>
 1. **Identify the analysis type**: Architecture, bug investigation, performance, or dependency analysis
 2. **Gather relevant context**: Read or identify the key files involved
-3. **Route to analyzer**:
-   - Preferred: `ask_codex` with `agent_role: "architect"` and relevant `context_files`
-   - Fallback: `Task(subagent_type="oh-my-claudecode:architect", model="opus", prompt="Analyze: ...")`
+3. **Route to analyzer**: `Task(subagent_type="oh-my-claudecode:architect", model="opus", prompt="Analyze: ...")`
 4. **Return structured findings**: Present the analysis with evidence, file references, and actionable recommendations
 </Steps>
 
 <Tool_Usage>
-- Before first MCP tool use, run the 3-step discovery: (1) `ToolSearch("mcp")`, (2) select the full name from results (e.g., `mcp__x__ask_codex`), (3) fall back to the equivalent Claude agent only if step 1 returns empty. Never use `ToolSearch("ask_codex")` as the primary search -- it can return false negatives even when MCP tools are present.
-- Use `ask_codex` with `agent_role: "architect"` as the preferred analysis route
-- Pass `context_files` with all relevant source files for grounded analysis
-- Use `Task(subagent_type="oh-my-claudecode:architect", model="opus", ...)` as fallback when ToolSearch finds no MCP tools or Codex is unavailable
+- Use `Task(subagent_type="oh-my-claudecode:architect", model="opus", ...)` as the primary analysis route
 - For broad analysis, use `explore` agent first to identify relevant files before routing to architect
 </Tool_Usage>
 

package/skills/autopilot/SKILL.md

@@ -46,9 +46,8 @@ Most non-trivial software tasks require coordinated phases: understanding requir
    - Output: `.omc/plans/autopilot-impl.md`
 
 3. **Phase 2 - Execution**: Implement the plan using Ralph + Ultrawork
-   - Executor-low (Haiku): Simple tasks
-   - Executor (Sonnet): Standard tasks
-   - Executor-high (Opus): Complex tasks
+   - Executor (Sonnet): Standard implementation tasks
+   - Deep-executor (Opus): Complex autonomous tasks
    - Run independent tasks in parallel
 
 4. **Phase 3 - QA**: Cycle until all tests pass (UltraQA mode)
@@ -62,18 +61,14 @@ Most non-trivial software tasks require coordinated phases: understanding requir
    - Code-reviewer: Quality review
    - All must approve; fix and re-validate on rejection
 
-6. **Phase 5 - Cleanup**: Delete all state files on successful completion
-   - Remove `.omc/state/autopilot-state.json`, `ralph-state.json`, `ultrawork-state.json`, `ultraqa-state.json`
-   - Run `/oh-my-claudecode:cancel` for clean exit
 </Steps>
 
 <Tool_Usage>
-- Before first MCP tool use, call `ToolSearch("mcp")` to discover deferred MCP tools
-- Use `ask_codex` with `agent_role: "architect"` for Phase 4 architecture validation
-- Use `ask_codex` with `agent_role: "security-reviewer"` for Phase 4 security review
-- Use `ask_codex` with `agent_role: "code-reviewer"` for Phase 4 quality review
-- Agents form their own analysis first, then consult Codex for cross-validation
-- If ToolSearch finds no MCP tools or Codex is unavailable, proceed without it -- never block on external tools
+- Use `Task(subagent_type="oh-my-claudecode:architect", ...)` for Phase 4 architecture validation
+- Use `Task(subagent_type="oh-my-claudecode:security-reviewer", ...)` for Phase 4 security review
+- Use `Task(subagent_type="oh-my-claudecode:code-reviewer", ...)` for Phase 4 quality review
+- Agents form their own analysis first, then spawn Claude Task agents for cross-validation
+- Never block on external tools; proceed with available agents if delegation fails
 </Tool_Usage>
 
 <Examples>
@@ -117,21 +112,17 @@ Why bad: This is an exploration/brainstorming request. Respond conversationally
 <Advanced>
 ## Configuration
 
-Optional settings in `.claude/settings.json`:
+Default values used internally (passed programmatically via the `config` parameter to `initAutopilot`):
 
 ```json
 {
-  "omc": {
-    "autopilot": {
-      "maxIterations": 10,
-      "maxQaCycles": 5,
-      "maxValidationRounds": 3,
-      "pauseAfterExpansion": false,
-      "pauseAfterPlanning": false,
-      "skipQa": false,
-      "skipValidation": false
-    }
-  }
+  "maxIterations": 10,
+  "maxQaCycles": 5,
+  "maxValidationRounds": 3,
+  "pauseAfterExpansion": false,
+  "pauseAfterPlanning": false,
+  "skipQa": false,
+  "skipValidation": false
 }
 ```
 
@@ -148,7 +139,7 @@ If autopilot was cancelled or failed, run `/oh-my-claudecode:autopilot` again to
 
 ## Troubleshooting
 
-**Stuck in a phase?** Check TODO list for blocked tasks, review `.omc/autopilot-state.json`, or cancel and resume.
+**Stuck in a phase?** Check TODO list for blocked tasks, review `.omc/state/autopilot-state.json`, or cancel and resume.
 
 **QA cycles exhausted?** The same error 3 times indicates a fundamental issue. Review the error pattern; manual intervention may be needed.
 

package/skills/ccg/SKILL.md

@@ -3,136 +3,125 @@ 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
 ---
 
-# CCG (Claude-Codex-Gemini) Orchestration
+# CCG - Claude-Codex-Gemini Tri-Model Orchestration
 
-## Overview
+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 is a tri-model orchestration pattern:
+## When to Use
 
-- **Claude** — Orchestrator/conductor: decomposes requests, fans out work, synthesizes results
-- **Codex** (OpenAI) — Backend/code engine: architecture, APIs, security, code analysis
-- **Gemini** (Google) — Frontend/design processor: UI components, styling, visual design, large-context tasks
+- 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
 
-Claude fans Codex and Gemini out **in parallel**, then synthesizes their outputs into a unified solution.
+## Requirements
 
-## Trigger
+- **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
 
-Activated when the user says `ccg` or `claude-codex-gemini` in their prompt.
+## How It Works
 
-## Execution Protocol
-
-**ANNOUNCE immediately**: `"CCG MODE ENABLED — Orchestrating Claude + Codex + Gemini"`
-
-### Phase 1: Decompose
+```
+1. Claude decomposes the request into:
+   - Backend/analytical tasks → Codex worker
+   - Frontend/UI/design tasks → Gemini worker
 
-Analyze the request and split into:
-- **Backend tasks** → Codex (APIs, data models, business logic, tests, security)
-- **Frontend tasks** → Gemini (UI components, styling, layout, responsive design)
-- **Synthesis tasks** → Claude (integration, cross-cutting concerns, final wiring)
+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)
 
-### Phase 2: Fan-Out (Parallel)
+3. Workers read tasks from inbox files and write done.json on completion
 
-Run Codex and Gemini **simultaneously** using background mode.
+4. mcp__team__omc_run_team_wait blocks until all workers finish
 
-**Codex — backend**:
-1. Write prompt to `.omc/prompts/codex-{purpose}-{timestamp}.md`
-2. Call `ask_codex` MCP tool:
-   - `agent_role`: pick from `architect`, `executor`, `code-reviewer`, `security-reviewer`, `planner`, `critic`
-   - `prompt_file`: the file you just wrote
-   - `output_file`: `.omc/prompts/codex-{purpose}-{timestamp}-output.md`
-   - `context_files`: relevant source files
-   - `background: true` for non-blocking execution
+5. Claude reads taskResults and synthesizes into final output
+```
 
-**Gemini — frontend**:
-1. Write prompt to `.omc/prompts/gemini-{purpose}-{timestamp}.md`
-2. Call `ask_gemini` MCP tool:
-   - `agent_role`: pick from `designer`, `writer`, `vision`
-   - `prompt_file`: the file you just wrote
-   - `output_file`: `.omc/prompts/gemini-{purpose}-{timestamp}-output.md`
-   - `files`: relevant source files
-   - `background: true` for non-blocking execution
+## Execution Protocol
 
-### Phase 3: Await Results
+When invoked, Claude MUST follow this workflow:
 
-Use `wait_for_job` (or poll with `check_job_status`) for both jobs. Wait for both to complete before synthesizing.
+### 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)
 
-### Phase 4: Synthesize
+Choose a short `teamName` slug (e.g., `ccg-auth-review`).
 
-Claude reads both output files and:
-1. Reconciles any conflicts (e.g., API shape vs component props)
-2. Integrates backend + frontend solutions into a cohesive whole
-3. Applies cross-cutting concerns (error handling, typing, auth)
-4. Implements any remaining integration glue code
+### 2. Start the team (non-blocking)
 
-## MCP Tool Selection Guide
+Call `mcp__team__omc_run_team_start` — spawns workers in the background and returns a `jobId` immediately:
 
-### Use Codex (`ask_codex`) for:
-- REST/GraphQL API design and implementation
-- Database schema, migrations, data models
-- Backend business logic and services
-- Security audit and vulnerability analysis
-- Architecture review and refactoring
-- Test strategy, TDD, unit/integration tests
-- Build errors and TypeScript issues
+```
+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}"
+})
+```
 
-**Roles**: `architect`, `code-reviewer`, `security-reviewer`, `executor`, `planner`, `critic`, `test-engineer`
+Returns: `{ "jobId": "omc-...", "pid": 12345, "message": "Team started in background..." }`
 
-### Use Gemini (`ask_gemini`) for:
-- React/Vue/Svelte component implementation
-- CSS, Tailwind, styled-components
-- Responsive layouts and visual design
-- UI/UX review and heuristic audits
-- Large-scale documentation (1M token context)
-- Image/screenshot/diagram analysis
+### 3. Wait for completion
 
-**Roles**: `designer`, `writer`, `vision`
+Call `mcp__team__omc_run_team_wait` — blocks internally until done:
 
-## Fallback
+```
+mcp__team__omc_run_team_wait({
+  "job_id": "{jobId}",
+  "timeout_ms": 60000
+})
+```
 
-If **Codex MCP unavailable** → use `Task(subagent_type="oh-my-claudecode:executor", model="sonnet")` for backend tasks.
+> **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": "..."}
+    ]
+  }
+}
+```
 
-If **Gemini MCP unavailable** → use `Task(subagent_type="oh-my-claudecode:designer", model="sonnet")` for frontend tasks.
+### 4. Synthesize Results
 
-If **both unavailable** → use Claude directly with the standard agent catalog.
+Parse `result.taskResults` and synthesize Codex + Gemini outputs into a unified response for the user.
 
-## Example
+## Fallback (CLIs Not Available)
 
-**User**: `ccg Add a user profile page with a REST API endpoint and React frontend`
+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:
 
 ```
-CCG MODE ENABLED — Orchestrating Claude + Codex + Gemini
-
-Decomposition:
-  Backend  → Codex: /api/users/:id endpoint, Prisma user model, auth middleware
-  Frontend → Gemini: React UserProfile component, avatar, form, responsive layout
-
-Fan-out (parallel):
-  [Codex]  Implementing REST endpoint + data layer...
-  [Gemini] Designing UserProfile component + styling...
-
-[Both complete]
-
-Synthesis:
-  - Align API response type with React component props
-  - Wire fetch hook to /api/users/:id endpoint
-  - Add error boundary and loading state across layers
-  - Export unified UserProfilePage with data fetching
+[CCG] Codex/Gemini CLI not found. Falling back to Claude-only execution.
 ```
 
-## Integration with Other Skills
-
-CCG composes with other OMC modes:
-
-| Combination | Effect |
-|-------------|--------|
-| `ccg ralph` | CCG loop with ralph persistence until verified complete |
-| `ccg ultrawork` | CCG with max parallelism within each model |
-| `ccg team` | CCG orchestration within a multi-agent team |
+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
 
-## Cancellation
+## Invocation
 
-Stop active CCG work: say `cancelomc` or run `/oh-my-claudecode:cancel`.
-
-## State
+```
+/oh-my-claudecode:ccg [task description]
+```
 
-CCG does not maintain persistent state files. Each invocation is stateless — Claude manages the workflow inline. MCP job IDs are tracked in-context during the session.
+Example:
+```
+/oh-my-claudecode:ccg Review this PR - check architecture and code quality (Codex) and UI components (Gemini)
+```

package/skills/configure-notifications/SKILL.md

@@ -758,3 +758,180 @@ Env vars are auto-detected by the notification system without needing `.omc-conf
 | Here | `<!here>` | `<!here>` |
 | Everyone | `<!everyone>` | `<!everyone>` |
 | User Group | `<!subteam^GROUP_ID>` | `<!subteam^S1234567890>` |
+
+---
+
+## Platform Activation Flags
+
+All notification platforms require activation via CLI flags per session:
+
+- `omc --telegram` — Activates Telegram notifications (sets `OMC_TELEGRAM=1`)
+- `omc --discord` — Activates Discord notifications (sets `OMC_DISCORD=1`)
+- `omc --slack` — Activates Slack notifications (sets `OMC_SLACK=1`)
+- `omc --webhook` — Activates webhook notifications (sets `OMC_WEBHOOK=1`)
+- `omc --openclaw` — Activates OpenClaw gateway integration (sets `OMC_OPENCLAW=1`)
+
+Without these flags, configured platforms remain dormant. This prevents unwanted notifications during development while keeping configuration persistent.
+
+**Examples:**
+- `omc --telegram --discord` — Telegram + Discord active
+- `omc --telegram --slack --webhook` — Telegram + Slack + Webhook active
+- `omc --telegram --openclaw` — Telegram + OpenClaw active
+- `omc` — No notifications sent (all platforms require explicit activation)
+
+---
+
+## Hook Event Templates
+
+Customize notification messages per event and per platform using `omc_config.hook.json`.
+
+### Routing
+
+If the trigger or argument contains "hook", "template", or "customize messages" → follow this section.
+
+### Step 1: Detect Existing Hook Config
+
+Check if `~/.claude/omc_config.hook.json` exists. If it does, show the current configuration. If not, explain what it does.
+
+```
+Hook event templates let you customize the notification messages sent to each platform.
+You can set different messages for Discord vs Telegram vs Slack, and control which
+events fire on which platform.
+
+Config file: ~/.claude/omc_config.hook.json
+```
+
+### Step 2: Choose Event to Configure
+
+Use AskUserQuestion:
+
+**Question:** "Which event would you like to configure templates for?"
+
+**Options:**
+1. **session-end** - When a Claude session finishes (most common)
+2. **ask-user-question** - When Claude is waiting for input
+3. **session-idle** - When Claude finishes and waits for input
+4. **session-start** - When a new session begins
+
+### Step 3: Show Available Variables
+
+Display the template variables available for the chosen event:
+
+```
+Available template variables:
+
+RAW FIELDS:
+  {{sessionId}}      - Session identifier
+  {{timestamp}}      - ISO timestamp
+  {{tmuxSession}}    - tmux session name
+  {{projectPath}}    - Full project directory path
+  {{projectName}}    - Project directory basename
+  {{reason}}         - Stop/end reason
+  {{activeMode}}     - Active OMC mode name
+  {{question}}       - Question text (ask-user-question only)
+  {{agentName}}      - Agent name (agent-call only)
+  {{agentType}}      - Agent type (agent-call only)
+
+COMPUTED (smart formatting):
+  {{duration}}       - Human-readable duration (e.g., "5m 23s")
+  {{time}}           - Locale time string
+  {{modesDisplay}}   - Comma-separated modes or empty
+  {{iterationDisplay}} - "3/10" format or empty
+  {{agentDisplay}}   - "2/5 completed" or empty
+  {{projectDisplay}} - Project name with fallbacks
+  {{footer}}         - tmux + project info line
+  {{tmuxTailBlock}}  - Recent output in code fence or empty
+  {{reasonDisplay}}  - Reason with "unknown" fallback
+
+CONDITIONALS:
+  {{#if variableName}}content shown when truthy{{/if}}
+```
+
+### Step 4: Collect Template
+
+Use AskUserQuestion:
+
+**Question:** "Enter the message template for this event (use {{variables}} for dynamic content)"
+
+**Options:**
+1. **Use default template** - Keep the built-in message format
+2. **Simple summary** - Short one-line format
+3. **Custom** - Enter your own template
+
+If "Simple summary", use a pre-built compact template:
+- session-end: `{{projectDisplay}} session ended ({{duration}}) — {{reasonDisplay}}`
+- ask-user-question: `Input needed on {{projectDisplay}}: {{question}}`
+- session-idle: `{{projectDisplay}} is idle. {{#if reason}}Reason: {{reason}}{{/if}}`
+- session-start: `Session started: {{projectDisplay}} at {{time}}`
+
+### Step 5: Per-Platform Overrides
+
+Use AskUserQuestion:
+
+**Question:** "Do you want different messages for specific platforms?"
+
+**Options:**
+1. **No, same for all (Recommended)** - Use the same template everywhere
+2. **Yes, customize per platform** - Set different templates for Discord, Telegram, Slack
+
+If per-platform: ask for each enabled platform's template separately.
+
+### Step 6: Write Configuration
+
+Read or create `~/.claude/omc_config.hook.json` and merge the new settings:
+
+```json
+{
+  "version": 1,
+  "enabled": true,
+  "events": {
+    "<event-name>": {
+      "enabled": true,
+      "template": "<user-provided-template>",
+      "platforms": {
+        "discord": { "template": "<discord-specific>" },
+        "telegram": { "template": "<telegram-specific>" }
+      }
+    }
+  }
+}
+```
+
+### Step 7: Validate and Test
+
+Validate the template using `validateTemplate()` to check for unknown variables. If any are found, warn the user and offer to correct.
+
+Offer to send a test notification with the new template.
+
+### Example Config
+
+```json
+{
+  "version": 1,
+  "enabled": true,
+  "events": {
+    "session-end": {
+      "enabled": true,
+      "template": "Session {{sessionId}} ended after {{duration}}. Reason: {{reasonDisplay}}",
+      "platforms": {
+        "discord": {
+          "template": "**Session Complete** | `{{projectDisplay}}` | {{duration}} | {{reasonDisplay}}"
+        },
+        "telegram": {
+          "template": "Done: {{projectDisplay}} ({{duration}})\n{{#if contextSummary}}Summary: {{contextSummary}}{{/if}}"
+        }
+      }
+    },
+    "ask-user-question": {
+      "enabled": true,
+      "template": "{{#if question}}{{question}}{{/if}}\nWaiting for input on {{projectDisplay}}"
+    }
+  }
+}
+```
+
+---
+
+## Related
+
+- `/oh-my-claudecode:configure-openclaw` — Configure OpenClaw gateway integration