claudecode-omc 4.4.10 → 4.7.4

package/skills/hud/SKILL.md

@@ -244,7 +244,9 @@ When agents are running, the HUD shows detailed information on separate lines:
 
 ## Configuration Location
 
-HUD config is stored at: `~/.claude/.omc/hud-config.json`
+HUD config is stored in `~/.claude/settings.json` under the `omcHud` key (or your custom config directory if `CLAUDE_CONFIG_DIR` is set).
+
+Legacy config location (deprecated): `~/.claude/.omc/hud-config.json`
 
 ## Manual Configuration
 
@@ -256,25 +258,55 @@ You can manually edit the config file. Each option can be set individually - any
   "elements": {
     "omcLabel": true,
     "ralph": true,
+    "autopilot": true,
     "prdStory": true,
     "activeSkills": true,
     "lastSkill": true,
     "contextBar": true,
     "agents": true,
+    "agentsFormat": "multiline",
     "backgroundTasks": true,
     "todos": true,
-    "showCache": true,
-    "showCost": true,
+    "thinking": true,
+    "thinkingFormat": "text",
+    "permissionStatus": false,
+    "apiKeySource": false,
+    "profile": true,
+    "promptTime": true,
+    "sessionHealth": true,
+    "useBars": true,
+    "showCallCounts": true,
+    "safeMode": true,
     "maxOutputLines": 4
   },
   "thresholds": {
     "contextWarning": 70,
+    "contextCompactSuggestion": 80,
     "contextCritical": 85,
     "ralphWarning": 7
+  },
+  "staleTaskThresholdMinutes": 30,
+  "contextLimitWarning": {
+    "threshold": 80,
+    "autoCompact": false
   }
 }
 ```
 
+### safeMode
+
+When `safeMode` is `true` (default), the HUD strips ANSI codes and uses ASCII-only output to prevent terminal rendering corruption during concurrent updates. This is especially important on Windows and when using terminal multiplexers.
+
+### agentsFormat Options
+
+- `count`: agents:2
+- `codes`: agents:Oes (type-coded with model tier casing)
+- `codes-duration`: agents:O(2m)es (codes with duration)
+- `detailed`: agents:[architect(2m),explore,exec]
+- `descriptions`: O:analyzing code | e:searching (codes + what they're doing)
+- `tasks`: [analyzing code, searching...] (just descriptions)
+- `multiline`: Multi-line display with full agent details on separate lines
+
 ## Troubleshooting
 
 If the HUD is not showing:

package/skills/omc-doctor/SKILL.md

@@ -49,13 +49,24 @@ ls -la ~/.claude/hooks/*.sh 2>/dev/null
 # Check if CLAUDE.md exists
 ls -la ~/.claude/CLAUDE.md 2>/dev/null
 
-# Check for OMC marker
-grep -q "oh-my-claudecode Multi-Agent System" ~/.claude/CLAUDE.md 2>/dev/null && echo "Has OMC config" || echo "Missing OMC config"
+# Check for OMC markers (<!-- OMC:START --> is the canonical marker)
+grep -q "<!-- OMC:START -->" ~/.claude/CLAUDE.md 2>/dev/null && echo "Has OMC config" || echo "Missing OMC config in CLAUDE.md"
+
+# Check companion files for file-split pattern (e.g. CLAUDE-omc.md)
+ls ~/.claude/CLAUDE-*.md 2>/dev/null
+for f in ~/.claude/CLAUDE-*.md; do
+  [ -f "$f" ] && grep -q "<!-- OMC:START -->" "$f" 2>/dev/null && echo "Has OMC config in companion: $f"
+done
+
+# Check if CLAUDE.md references a companion file
+grep -o "CLAUDE-[^ )]*\.md" ~/.claude/CLAUDE.md 2>/dev/null
 ```
 
 **Diagnosis**:
-- If missing: CRITICAL - CLAUDE.md not configured
-- If missing OMC marker: WARN - outdated CLAUDE.md
+- If CLAUDE.md missing: CRITICAL - CLAUDE.md not configured
+- If `<!-- OMC:START -->` found in CLAUDE.md: OK
+- If `<!-- OMC:START -->` found in a companion file (e.g. `CLAUDE-omc.md`): OK - file-split pattern detected
+- If no OMC markers in CLAUDE.md or any companion file: WARN - outdated CLAUDE.md
 
 ### Step 5: Check for Stale Plugin Cache
 
@@ -69,7 +80,8 @@ node -e "const p=require('path'),f=require('fs'),h=require('os').homedir(),d=pro
 
 ### Step 6: Check for Legacy Curl-Installed Content
 
-Check for legacy agents, commands, and skills installed via curl (before plugin system):
+Check for legacy agents, commands, and skills installed via curl (before plugin system).
+**Important**: Only flag files whose names match actual plugin-provided names. Do NOT flag user's custom agents/commands/skills that are unrelated to OMC.
 
 ```bash
 # Check for legacy agents directory
@@ -83,14 +95,19 @@ ls -la ~/.claude/skills/ 2>/dev/null
 ```
 
 **Diagnosis**:
-- If `~/.claude/agents/` exists with oh-my-claudecode-related files: WARN - legacy agents (now provided by plugin)
-- If `~/.claude/commands/` exists with oh-my-claudecode-related files: WARN - legacy commands (now provided by plugin)
-- If `~/.claude/skills/` exists with oh-my-claudecode-related files: WARN - legacy skills (now provided by plugin)
-
-Look for files like:
-- `architect.md`, `document-specialist.md`, `explore.md`, `executor.md`, etc. in agents/
-- `ultrawork.md`, `deepsearch.md`, etc. in commands/
-- Any oh-my-claudecode-related `.md` files in skills/
+- If `~/.claude/agents/` exists with files matching plugin agent names: WARN - legacy agents (now provided by plugin)
+- If `~/.claude/commands/` exists with files matching plugin command names: WARN - legacy commands (now provided by plugin)
+- If `~/.claude/skills/` exists with files matching plugin skill names: WARN - legacy skills (now provided by plugin)
+- If custom files exist that do NOT match plugin names: OK - these are user custom content, do not flag them
+
+**Known plugin agent names** (check agents/ for these):
+`architect.md`, `document-specialist.md`, `explore.md`, `executor.md`, `debugger.md`, `planner.md`, `analyst.md`, `critic.md`, `verifier.md`, `test-engineer.md`, `build-fixer.md`, `designer.md`, `writer.md`, `qa-tester.md`, `scientist.md`, `security-reviewer.md`, `code-reviewer.md`, `quality-reviewer.md`, `deep-executor.md`
+
+**Known plugin skill names** (check skills/ for these):
+`autopilot`, `ralph`, `ultrawork`, `team`, `ultrapilot`, `pipeline`, `ultraqa`, `plan`, `ralplan`, `analyze`, `build-fix`, `cancel`, `ccg`, `code-review`, `configure-notifications`, `configure-openclaw`, `deepinit`, `external-context`, `hud`, `learn-about-omc`, `learner`, `mcp-setup`, `note`, `omc-doctor`, `omc-help`, `omc-setup`, `omc-teams`, `project-session-manager`, `ralph-init`, `release`, `review`, `sciomc`, `security-review`, `skill`, `tdd`, `trace`, `writer-memory`
+
+**Known plugin command names** (check commands/ for these):
+`ultrawork.md`, `deepsearch.md`
 
 ---
 

package/skills/omc-help/SKILL.md

@@ -51,7 +51,7 @@ This is the **only command** you need to know. It downloads the configuration an
 
 ## For 2.x Users
 
-Your old commands still work! `/ralph`, `/ultrawork`, `/plan`, etc. all function exactly as before.
+Your old commands still work! `/ralph`, `/ultrawork`, `/omc-plan`, etc. all function exactly as before.
 
 But now you don't NEED them - everything is automatic.
 

package/skills/omc-setup/SKILL.md

@@ -606,7 +606,7 @@ console.log('Installed:',v||'(not found)');
 "
 
 # Check npm for latest version
-LATEST_VERSION=$(npm view oh-my-claude-sisyphus version 2>/dev/null)
+LATEST_VERSION=$(npm view claudecode-omc version 2>/dev/null)
 
 if [ -n "$INSTALLED_VERSION" ] && [ -n "$LATEST_VERSION" ]; then
   # Simple version comparison (assumes semantic versioning)
@@ -657,7 +657,7 @@ echo "Default execution mode set to: USER_CHOICE"
 
 ## Step 3.8: Install OMC CLI Tool
 
-The OMC CLI (`omc` command) provides standalone token analytics and management commands (`omc stats`, `omc agents`, `omc tui`).
+The OMC CLI (`omc` command) provides standalone monitoring and analytics commands (HUD statusline + cost/session reporting).
 
 First, check if the CLI is already installed:
 
@@ -676,11 +676,11 @@ If `OMC_CLI_INSTALLED` is `"true"`, skip the rest of this step.
 
 If `OMC_CLI_INSTALLED` is `"false"`, use the AskUserQuestion tool to prompt the user:
 
-**Question:** "Would you like to install the OMC CLI globally for standalone analytics? (`omc stats`, `omc agents`, `omc tui`)"
+**Question:** "Would you like to install the OMC CLI globally for standalone monitoring and analytics? (`omc`, `omc cost`, `omc sessions`)"
 
 **Options:**
-1. **Yes (Recommended)** - Install `oh-my-claude-sisyphus` via `npm install -g`
-2. **No - Skip** - Skip installation (can install manually later with `npm install -g oh-my-claude-sisyphus`)
+1. **Yes (Recommended)** - Install `claudecode-omc` via `npm install -g`
+2. **No - Skip** - Skip installation (can install manually later with `npm install -g claudecode-omc`)
 
 If user chooses **Yes**:
 
@@ -688,10 +688,10 @@ If user chooses **Yes**:
 # Check if npm is available
 if ! command -v npm &>/dev/null; then
   echo "WARNING: npm not found. Cannot install OMC CLI automatically."
-  echo "Install Node.js/npm first, then run: npm install -g oh-my-claude-sisyphus"
+  echo "Install Node.js/npm first, then run: npm install -g claudecode-omc"
 else
   # Install the CLI globally
-  if npm install -g oh-my-claude-sisyphus 2>&1; then
+  if npm install -g claudecode-omc 2>&1; then
     echo "OMC CLI installed successfully."
     # Verify installation
     if command -v omc &>/dev/null; then
@@ -702,8 +702,8 @@ else
     fi
   else
     echo "WARNING: Failed to install OMC CLI (permission issue or network error)."
-    echo "You can install manually later: npm install -g oh-my-claude-sisyphus"
-    echo "Or with sudo: sudo npm install -g oh-my-claude-sisyphus"
+    echo "You can install manually later: npm install -g claudecode-omc"
+    echo "Or with sudo: sudo npm install -g claudecode-omc"
   fi
 fi
 ```
@@ -1039,10 +1039,10 @@ HUD STATUSLINE:
 The status bar now shows OMC state. Restart Claude Code to see it.
 
 CLI ANALYTICS (if installed):
-- omc           - Full dashboard (stats + agents + cost)
-- omc stats     - View token usage and costs
-- omc agents    - See agent breakdown by cost
-- omc tui       - Launch interactive TUI dashboard
+- omc           - Default analytics dashboard
+- omc cost      - View cost reports (daily/weekly/monthly)
+- omc sessions  - Inspect session history
+- omc backfill  - Import transcript analytics
 
 That's it! Just use Claude Code normally.
 ```
@@ -1053,13 +1053,13 @@ That's it! Just use Claude Code normally.
 OMC Setup Complete! (Upgraded from 2.x)
 
 GOOD NEWS: Your existing commands still work!
-- /ralph, /ultrawork, /plan, etc. all still function
+- /ralph, /ultrawork, /omc-plan, etc. all still function
 
 WHAT'S NEW in 3.0:
 You no longer NEED those commands. Everything is automatic now:
 - Just say "don't stop until done" instead of /ralph
 - Just say "fast" or "parallel" instead of /ultrawork
-- Just say "plan this" instead of /plan
+- Just say "plan this" instead of /omc-plan
 - Just say "stop" instead of /cancel
 
 MAGIC KEYWORDS (power-user shortcuts):
@@ -1068,7 +1068,7 @@ MAGIC KEYWORDS (power-user shortcuts):
 | ralph | /ralph | "ralph: fix the bug" |
 | ralplan | /ralplan | "ralplan this feature" |
 | ulw | /ultrawork | "ulw refactor API" |
-| plan | /plan | "plan the endpoints" |
+| omc-plan | /omc-plan | "plan the endpoints" |
 | team | (new!) | "/team 3:executor fix errors" |
 
 TEAMS (NEW!):
@@ -1080,10 +1080,10 @@ HUD STATUSLINE:
 The status bar now shows OMC state. Restart Claude Code to see it.
 
 CLI ANALYTICS (if installed):
-- omc           - Full dashboard (stats + agents + cost)
-- omc stats     - View token usage and costs
-- omc agents    - See agent breakdown by cost
-- omc tui       - Launch interactive TUI dashboard
+- omc           - Default analytics dashboard
+- omc cost      - View cost reports (daily/weekly/monthly)
+- omc sessions  - Inspect session history
+- omc backfill  - Import transcript analytics
 
 Your workflow won't break - it just got easier!
 ```

package/skills/omc-teams/SKILL.md

@@ -6,11 +6,13 @@ aliases: []
 
 # OMC Teams Skill
 
-Spawn N CLI worker processes in tmux panes to execute tasks in parallel. Supports `claude`, `codex`, and `gemini` agent types. Unlike `/team` (which uses Claude Code's native `TeamCreate`/`Task` tools), this skill uses the tmux runtime to launch actual CLI processes in visible tmux panes.
+Spawn N CLI worker processes in tmux panes to execute tasks in parallel. Supports `claude`, `codex`, and `gemini` agent types.
+
+`/omc-teams` is a legacy compatibility skill for the CLI-first runtime: use `omc team ...` commands (not deprecated MCP runtime tools).
 
 ## Usage
 
-```
+```bash
 /oh-my-claudecode:omc-teams N:claude "task description"
 /oh-my-claudecode:omc-teams N:codex "task description"
 /oh-my-claudecode:omc-teams N:gemini "task description"
@@ -28,151 +30,97 @@ Spawn N CLI worker processes in tmux panes to execute tasks in parallel. Support
 /omc-teams 2:claude "implement auth module with tests"
 /omc-teams 2:codex "review the auth module for security issues"
 /omc-teams 3:gemini "redesign UI components for accessibility"
-/omc-teams 1:codex "write comprehensive tests for src/api/"
 ```
 
 ## Requirements
 
 - **tmux** must be running (`$TMUX` set in the current shell)
-- **claude** CLI: `npm install -g @anthropic-ai/claude-code` (for claude workers)
-- **codex** CLI: `npm install -g @openai/codex` (for codex workers)
-- **gemini** CLI: `npm install -g @google/gemini-cli` (for gemini workers)
-
-## How It Works
-
-1. Claude decomposes the task into N independent subtasks (one per worker)
-2. Calls `mcp__team__omc_run_team_start` then `mcp__team__omc_run_team_wait`
-3. The OMC MCP server spawns `runtime-cli.cjs` (co-located in the same install directory)
-4. The runtime creates tmux split-panes and launches the CLI processes
-5. Each worker reads its task from an inbox file and writes `done.json` on completion
-6. The runtime collects results, shuts down workers, returns structured JSON
-7. Claude parses the result and reports to the user
-
----
+- **claude** CLI: `npm install -g @anthropic-ai/claude-code`
+- **codex** CLI: `npm install -g @openai/codex`
+- **gemini** CLI: `npm install -g @google/gemini-cli`
 
 ## Workflow
 
 ### Phase 1: Parse input
 
-Extract from the user command:
-- `N` — number of workers (integer, 1–10)
-- `agent-type` — must be `claude`, `codex`, or `gemini`; reject anything else with an error
-- `task` — the task description
+Extract:
 
-### Phase 2: Decompose task
+- `N` — worker count (1–10)
+- `agent-type` — `claude|codex|gemini`
+- `task` — task description
 
-Break the task into exactly N subtasks. Each subtask must be:
-- **Independent** — no conflicting writes between workers
-- **Scoped** — operates on a distinct subset of files or concerns
-- **Self-contained** — completable without inter-worker coordination
+### Phase 2: Decompose task
 
-Choose a `teamName` slug from the task (e.g., `auth-security-review`).
+Break work into N independent subtasks (file- or concern-scoped) to avoid write conflicts.
 
-### Phase 3: Activate team state & start the team
+### Phase 3: Start CLI team runtime
 
-**CRITICAL: Activate team state BEFORE calling MCP tools.** This prevents the session from
-stopping prematurely after MCP tool calls return. The persistent-mode Stop hook checks
-`team-state.json` to know whether to block the stop or allow it.
+Activate mode state (recommended):
 
-```
+```text
 state_write(mode="team", current_phase="team-exec", active=true)
 ```
 
-Then call `mcp__team__omc_run_team_start` — it spawns workers in the background and returns a
-`jobId` immediately. No Bash, no path resolution; the MCP server finds `runtime-cli.cjs`
-from its own install directory automatically.
+Start workers via CLI:
 
+```bash
+omc team <N>:<claude|codex|gemini> "<task>"
 ```
-mcp__team__omc_run_team_start({
-  "teamName": "{teamName}",
-  "agentTypes": ["{agentType}", "{agentType}", ...],
-  "tasks": [
-    {"subject": "Subtask 1 title", "description": "Full description..."},
-    {"subject": "Subtask 2 title", "description": "Full description..."}
-  ],
-  "cwd": "{cwd}"
-})
-```
-
-Returns: `{ "jobId": "omc-...", "pid": 12345, "message": "Team started in background..." }`
 
-### Phase 4: Wait for completion, then report
+Team name defaults to a slug from the task text (example: `review-auth-flow`).
 
-Call `mcp__team__omc_run_team_wait` — a single blocking call that polls internally
-(500ms → 2000ms exponential backoff) and returns only when the job reaches a terminal
-state. No repeated polling needed; one call instead of N.
+### Phase 4: Monitor + lifecycle API
 
+```bash
+omc team status <team-name>
+omc team api list-tasks --input '{"team_name":"<team-name>"}' --json
 ```
-mcp__team__omc_run_team_wait({
-  "job_id": "{jobId}",
-  "timeout_ms": 60000
-})
-```
 
-> **Timeout guidance:** `timeout_ms` is optional; the default wait timeout is fine.
-> If a wait call times out, **workers are left running** — wait timeout does NOT kill
-> worker processes or panes. You have two options:
-> - Call `omc_run_team_wait` again with the same `job_id` to keep waiting (workers continue)
-> - Call `omc_run_team_cleanup` only when you explicitly want to cancel and stop panes
->
-> Teams can silently stall due to stuck workers or tmux session issues. Use
-> `mcp__team__omc_run_team_status` to inspect live progress before deciding to cancel.
-
-Returns when done:
-```json
-{
-  "jobId": "omc-...",
-  "status": "completed|failed",
-  "elapsedSeconds": "95.3",
-  "result": {
-    "status": "completed",
-    "teamName": "...",
-    "taskResults": [
-      {"taskId": "1", "status": "completed", "summary": "Done: added 12 tests"},
-      {"taskId": "2", "status": "failed", "summary": "Worker exited early"}
-    ],
-    "duration": 95.1,
-    "workerCount": 2
-  }
-}
+Use `omc team api ...` for task claiming, task transitions, mailbox delivery, and worker state updates.
+
+### Phase 5: Shutdown (only when needed)
+
+```bash
+omc team shutdown <team-name>
+omc team shutdown <team-name> --force
 ```
 
-> **Why no deadlock?** `omc_run_team_wait` uses `async/await` with `setTimeout`,
-> which yields the Node.js event loop between polls. The `child.on('close', ...)`
-> callback that updates job status fires during those yields. The background
-> `runtime-cli.cjs` child process is completely independent — it never calls back
-> into this MCP server.
->
-> If you need non-blocking checks (e.g. to do other work while waiting), use
-> `mcp__team__omc_run_team_status` instead.
+Use shutdown for intentional cancellation or stale-state cleanup. Prefer non-force shutdown first.
 
-Report results to the user. For `failed` or wait-timeout errors, explain what happened and suggest next steps (reduce scope, check CLI installation, verify tmux is running).
+### Phase 6: Report + state close
 
-Update OMC state:
-```
-state_write(mode="team", current_phase="completed", active=false)
+Report task results with completion/failure summary and any remaining risks.
+
+```text
+state_write(mode="team", current_phase="complete", active=false)
 ```
 
----
+## Deprecated Runtime Note
 
-## Error Reference
+Legacy MCP runtime tools are deprecated for execution:
 
-| Error | Cause | Fix |
-|-------|-------|-----|
-| `not inside tmux` | Shell not running inside a tmux session | Start tmux and rerun |
-| `codex: command not found` | Codex CLI not installed | `npm install -g @openai/codex` |
-| `gemini: command not found` | Gemini CLI not installed | `npm install -g @google/gemini-cli` |
-| wait timeout error | `omc_run_team_wait` hit `timeout_ms` before completion | Call `omc_run_team_wait` again to keep waiting, or call `omc_run_team_cleanup` to explicitly stop worker panes |
-| `status: failed` | All workers exited with work remaining | Check stderr for crash details |
+- `omc_run_team_start`
+- `omc_run_team_status`
+- `omc_run_team_wait`
+- `omc_run_team_cleanup`
 
----
+If encountered, switch to `omc team ...` CLI commands.
+
+## Error Reference
+
+| Error                        | Cause                               | Fix                                                                                 |
+| ---------------------------- | ----------------------------------- | ----------------------------------------------------------------------------------- |
+| `not inside tmux`            | Shell not running inside tmux       | Start tmux and rerun                                                                |
+| `codex: command not found`   | Codex CLI not installed             | `npm install -g @openai/codex`                                                      |
+| `gemini: command not found`  | Gemini CLI not installed            | `npm install -g @google/gemini-cli`                                                 |
+| `Team <name> is not running` | stale or missing runtime state      | `omc team status <team-name>` then `omc team shutdown <team-name> --force` if stale |
+| `status: failed`             | Workers exited with incomplete work | inspect runtime output, narrow scope, rerun                                         |
 
 ## Relationship to `/team`
 
-| Aspect | `/team` | `/omc-teams` |
-|--------|---------|-------------|
-| Worker type | Claude Code agents (`Task(subagent_type=...)`) | claude / codex / gemini CLI processes |
-| Invocation | `TeamCreate` / `SendMessage` / `TeamDelete` | `mcp__team__omc_run_team_start` + `omc_run_team_wait` |
-| Coordination | Native Claude Code team messaging | tmux panes + inbox files + `done.json` sentinels |
-| Communication | Native Claude Code team messaging | File-based (inbox.md → done.json) |
-| Use when | You want Claude agents with full tool access | You want CLI autonomy (codex/gemini) at scale |
+| Aspect       | `/team`                                   | `/omc-teams`                                         |
+| ------------ | ----------------------------------------- | ---------------------------------------------------- |
+| Worker type  | Claude Code native team agents            | claude / codex / gemini CLI processes in tmux        |
+| Invocation   | `TeamCreate` / `Task` / `SendMessage`     | `omc team [N:agent]` + `status` + `shutdown` + `api` |
+| Coordination | Native team messaging and staged pipeline | tmux worker runtime + CLI API state files            |
+| Use when     | You want Claude-native team orchestration | You want external CLI worker execution               |

package/skills/plan/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: plan
+name: omc-plan
 description: Strategic planning with optional interview workflow
 ---
 
@@ -91,16 +91,16 @@ Jumping into code without understanding requirements leads to rework, scope cree
    c. Update the plan file in `.omc/plans/` with the accepted improvements (add missing details, refine steps, strengthen acceptance criteria, ADR updates, etc.)
    d. Note which improvements were applied in a brief changelog section at the end of the plan
 7. On Critic approval (with improvements applied): *(--interactive only)* If running with `--interactive`, use `AskUserQuestion` to present the plan with these options:
-   - **Approve and execute** — proceed to implementation via ralph+ultrawork
-   - **Approve and implement via team** — proceed to implementation via coordinated parallel team agents
+   - **Approve and implement via team** (Recommended) — proceed to implementation via coordinated parallel team agents (`/team`). Team is the canonical orchestration surface since v4.1.7.
+   - **Approve and execute via ralph** — proceed to implementation via ralph+ultrawork (sequential execution with verification)
    - **Clear context and implement** — compact the context window first (recommended when context is large after planning), then start fresh implementation via ralph with the saved plan file
    - **Request changes** — return to step 1 with user feedback
    - **Reject** — discard the plan entirely
    If NOT running with `--interactive`, output the final approved plan and stop. Do NOT auto-execute.
 8. *(--interactive only)* User chooses via the structured `AskUserQuestion` UI (never ask for approval in plain text)
 9. On user approval (--interactive only):
-   - **Approve and execute**: **MUST** invoke `Skill("oh-my-claudecode:ralph")` with the approved plan path from `.omc/plans/` as context. Do NOT implement directly. Do NOT edit source code files in the planning agent. The ralph skill handles execution via ultrawork parallel agents.
-   - **Approve and implement via team**: **MUST** invoke `Skill("oh-my-claudecode:team")` with the approved plan path from `.omc/plans/` as context. Do NOT implement directly. The team skill coordinates parallel agents across the staged pipeline for faster execution on large tasks.
+   - **Approve and implement via team**: **MUST** invoke `Skill("oh-my-claudecode:team")` with the approved plan path from `.omc/plans/` as context. Do NOT implement directly. The team skill coordinates parallel agents across the staged pipeline for faster execution on large tasks. This is the recommended default execution path.
+   - **Approve and execute via ralph**: **MUST** invoke `Skill("oh-my-claudecode:ralph")` with the approved plan path from `.omc/plans/` as context. Do NOT implement directly. Do NOT edit source code files in the planning agent. The ralph skill handles execution via ultrawork parallel agents.
    - **Clear context and implement**: First invoke `Skill("compact")` to compress the context window (reduces token usage accumulated during planning), then invoke `Skill("oh-my-claudecode:ralph")` with the approved plan path from `.omc/plans/`. This path is recommended when the context window is 50%+ full after the planning session.
 
 ### Review Mode (`--review`)