claudecode-omc 4.8.2 → 4.8.4

package/skills/omc-teams/SKILL.md

@@ -34,14 +34,31 @@ Spawn N CLI worker processes in tmux panes to execute tasks in parallel. Support
 
 ## Requirements
 
-- **tmux** must be running (`$TMUX` set in the current shell)
+- **tmux binary** must be installed and discoverable (`command -v tmux`)
+- **Active tmux session** required to launch worker panes (`$TMUX` set, or start/attach tmux first)
 - **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
+### Phase 0: Verify prerequisites
+
+Check tmux explicitly before claiming it is missing:
+
+```bash
+command -v tmux >/dev/null 2>&1
+```
+
+- If this fails, report that **tmux is not installed** and stop.
+- If `tmux` exists but `$TMUX` is empty, report that the user is **not currently inside an active tmux session**. Do **not** say tmux is missing; tell them to start or attach tmux, then rerun.
+- If you need to confirm the active session, use:
+
+```bash
+tmux display-message -p '#S'
+```
+
+### Phase 1: Parse + validate input
 
 Extract:
 
@@ -49,6 +66,12 @@ Extract:
 - `agent-type` — `claude|codex|gemini`
 - `task` — task description
 
+Validate before decomposing or running anything:
+
+- Reject unsupported agent types up front. `/omc-teams` only supports **`claude`**, **`codex`**, and **`gemini`**.
+- If the user asks for an unsupported type such as `expert`, explain that `/omc-teams` launches external CLI workers only.
+- For native Claude Code team agents/roles, direct them to **`/oh-my-claudecode:team`** instead.
+
 ### Phase 2: Decompose task
 
 Break work into N independent subtasks (file- or concern-scoped) to avoid write conflicts.
@@ -69,6 +92,15 @@ omc team <N>:<claude|codex|gemini> "<task>"
 
 Team name defaults to a slug from the task text (example: `review-auth-flow`).
 
+After launch, verify the command actually executed instead of assuming Enter fired. Check pane output and confirm the command or worker bootstrap text appears in pane history:
+
+```bash
+tmux list-panes -a -F '#{session_name}:#{window_index}.#{pane_index} #{pane_id} #{pane_current_command}'
+tmux capture-pane -pt <pane-id> -S -20
+```
+
+Do not claim the team started successfully unless pane output shows the command was submitted.
+
 ### Phase 4: Monitor + lifecycle API
 
 ```bash
@@ -111,6 +143,7 @@ If encountered, switch to `omc team ...` CLI commands.
 | Error                        | Cause                               | Fix                                                                                 |
 | ---------------------------- | ----------------------------------- | ----------------------------------------------------------------------------------- |
 | `not inside tmux`            | Shell not running inside tmux       | Start tmux and rerun                                                                |
+| `Unsupported agent type`     | Requested agent is not claude/codex/gemini | Use `claude`, `codex`, or `gemini`; for native Claude Code agents use `/oh-my-claudecode:team` |
 | `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 |

package/skills/plan/SKILL.md

@@ -1,6 +1,9 @@
 ---
 name: omc-plan
 description: Strategic planning with optional interview workflow
+pipeline: [deep-interview, omc-plan, autopilot]
+next-skill: autopilot
+handoff: .omc/plans/ralplan-*.md
 ---
 
 <Purpose>

package/skills/planning-with-files/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: planning-with-files
+description: File-based planning workflow for complex tasks. Create and maintain task_plan.md, findings.md, and progress.md as persistent working memory.
+---
+
+# Planning With Files
+
+Use this skill when the task is complex, long-running, or likely to exceed context continuity.
+
+## Use When
+
+- Multi-step tasks (typically 3+ phases)
+- Investigations requiring many reads/searches
+- Work that spans planning, implementation, and verification
+
+## Core Pattern
+
+Context window is volatile; files are durable.
+Write key decisions and discoveries to disk early.
+
+## Standard Files
+
+- `task_plan.md`: goals, phases, decisions, errors
+- `findings.md`: research notes, references, technical findings
+- `progress.md`: chronological execution and test log
+
+## Workflow
+
+1. Initialize files in project root:
+   - `bash skills/planning-with-files/scripts/init-session.sh`
+2. Before major decisions, re-read `task_plan.md`.
+3. After every 2 search/view operations, update `findings.md`.
+4. After each phase, update status and `progress.md`.
+5. Before handoff, validate completeness:
+   - `bash skills/planning-with-files/scripts/check-complete.sh`
+
+## Rules
+
+- Do not start complex implementation without `task_plan.md`.
+- Record all meaningful errors and attempted fixes.
+- Do not repeat identical failed actions.
+- Keep plans minimal and reversible.
+
+## Templates
+
+- `skills/planning-with-files/templates/task_plan.md`
+- `skills/planning-with-files/templates/findings.md`
+- `skills/planning-with-files/templates/progress.md`
+

package/skills/planning-with-files/examples.md

@@ -0,0 +1,17 @@
+# Planning With Files Examples
+
+## Example: feature delivery
+
+1. Run `bash skills/planning-with-files/scripts/init-session.sh`
+2. Set goal and phases in `task_plan.md`
+3. Log findings during discovery in `findings.md`
+4. Implement phase by phase and append test results to `progress.md`
+5. Run `bash skills/planning-with-files/scripts/check-complete.sh`
+
+## Example: bug investigation
+
+1. Capture repro steps and hypotheses in `task_plan.md`
+2. Store command outputs and traces in `findings.md`
+3. Log each failed attempt and changed hypothesis in `progress.md`
+4. Only implement once root cause is validated
+

package/skills/planning-with-files/reference.md

@@ -0,0 +1,21 @@
+# Planning With Files Reference
+
+## Why this exists
+
+Long tasks lose context. Persisting decisions and findings in project files
+keeps implementation aligned with goals and reduces repeated failures.
+
+## Core principles
+
+1. Plan before implementing.
+2. Re-read the plan before major decisions.
+3. Externalize discoveries to `findings.md`.
+4. Track execution and verification in `progress.md`.
+5. Keep failed attempts visible to avoid repeating them.
+
+## Recommended cadence
+
+- Every phase transition: update `task_plan.md`
+- Every 2 search/view actions: update `findings.md`
+- Every test run or fix cycle: update `progress.md`
+

package/skills/planning-with-files/scripts/check-complete.ps1

@@ -0,0 +1,28 @@
+param(
+    [string]$PlanFile = "task_plan.md"
+)
+
+if (-not (Test-Path $PlanFile)) {
+    Write-Host "ERROR: $PlanFile not found"
+    exit 1
+}
+
+$content = Get-Content $PlanFile -Raw
+$total = ([regex]::Matches($content, "### Phase")).Count
+$complete = ([regex]::Matches($content, "\*\*Status:\*\* complete")).Count
+$inProgress = ([regex]::Matches($content, "\*\*Status:\*\* in_progress")).Count
+$pending = ([regex]::Matches($content, "\*\*Status:\*\* pending")).Count
+
+Write-Host "Total phases: $total"
+Write-Host "Complete: $complete"
+Write-Host "In progress: $inProgress"
+Write-Host "Pending: $pending"
+
+if ($total -gt 0 -and $complete -eq $total) {
+    Write-Host "ALL PHASES COMPLETE"
+    exit 0
+}
+
+Write-Host "TASK NOT COMPLETE"
+exit 1
+

package/skills/planning-with-files/scripts/check-complete.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Verify all phases in task_plan.md are complete.
+# Usage: bash skills/planning-with-files/scripts/check-complete.sh [task_plan_path]
+
+set -euo pipefail
+
+PLAN_FILE="${1:-task_plan.md}"
+
+if [[ ! -f "${PLAN_FILE}" ]]; then
+  echo "ERROR: ${PLAN_FILE} not found"
+  exit 1
+fi
+
+TOTAL="$(grep -c "### Phase" "${PLAN_FILE}" || true)"
+COMPLETE="$(grep -cF "**Status:** complete" "${PLAN_FILE}" || true)"
+IN_PROGRESS="$(grep -cF "**Status:** in_progress" "${PLAN_FILE}" || true)"
+PENDING="$(grep -cF "**Status:** pending" "${PLAN_FILE}" || true)"
+
+echo "Total phases: ${TOTAL}"
+echo "Complete: ${COMPLETE}"
+echo "In progress: ${IN_PROGRESS}"
+echo "Pending: ${PENDING}"
+
+if [[ "${TOTAL}" -gt 0 && "${COMPLETE}" -eq "${TOTAL}" ]]; then
+  echo "ALL PHASES COMPLETE"
+  exit 0
+fi
+
+echo "TASK NOT COMPLETE"
+exit 1
+

package/skills/planning-with-files/scripts/init-session.ps1

@@ -0,0 +1,31 @@
+param(
+    [string]$ProjectName = "project"
+)
+
+$date = Get-Date -Format "yyyy-MM-dd"
+Write-Host "Initializing planning files for: $ProjectName"
+
+if (-not (Test-Path "task_plan.md")) {
+    Copy-Item "skills/planning-with-files/templates/task_plan.md" "task_plan.md"
+    Write-Host "Created task_plan.md"
+} else {
+    Write-Host "task_plan.md already exists, skipping"
+}
+
+if (-not (Test-Path "findings.md")) {
+    Copy-Item "skills/planning-with-files/templates/findings.md" "findings.md"
+    Write-Host "Created findings.md"
+} else {
+    Write-Host "findings.md already exists, skipping"
+}
+
+if (-not (Test-Path "progress.md")) {
+    Copy-Item "skills/planning-with-files/templates/progress.md" "progress.md"
+    (Get-Content "progress.md") -replace "\[DATE\]", $date | Set-Content "progress.md"
+    Write-Host "Created progress.md"
+} else {
+    Write-Host "progress.md already exists, skipping"
+}
+
+Write-Host "Planning files initialized."
+

package/skills/planning-with-files/scripts/init-session.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Initialize planning files in the current project root.
+# Usage: bash skills/planning-with-files/scripts/init-session.sh [project-name]
+
+set -euo pipefail
+
+PROJECT_NAME="${1:-project}"
+DATE="$(date +%Y-%m-%d)"
+
+echo "Initializing planning files for: ${PROJECT_NAME}"
+
+if [[ ! -f task_plan.md ]]; then
+  cp skills/planning-with-files/templates/task_plan.md task_plan.md
+  echo "Created task_plan.md"
+else
+  echo "task_plan.md already exists, skipping"
+fi
+
+if [[ ! -f findings.md ]]; then
+  cp skills/planning-with-files/templates/findings.md findings.md
+  echo "Created findings.md"
+else
+  echo "findings.md already exists, skipping"
+fi
+
+if [[ ! -f progress.md ]]; then
+  cp skills/planning-with-files/templates/progress.md progress.md
+  # Replace session token with current date for convenience.
+  sed -i.bak "s/\\[DATE\\]/${DATE}/g" progress.md && rm -f progress.md.bak
+  echo "Created progress.md"
+else
+  echo "progress.md already exists, skipping"
+fi
+
+echo "Planning files initialized."
+

package/skills/planning-with-files/scripts/session-catchup.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+Session catchup helper for planning-with-files.
+
+Checks if planning files were updated long ago while the working tree changed,
+and prints a lightweight catchup reminder.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+PLANNING_FILES = ("task_plan.md", "findings.md", "progress.md")
+
+
+def run(cmd: list[str], cwd: Path) -> str:
+    try:
+        out = subprocess.check_output(cmd, cwd=str(cwd), stderr=subprocess.STDOUT, text=True)
+        return out.strip()
+    except Exception:
+        return ""
+
+
+def newest_planning_mtime(root: Path) -> float:
+    mtimes = []
+    for name in PLANNING_FILES:
+        p = root / name
+        if p.exists():
+            mtimes.append(p.stat().st_mtime)
+    return max(mtimes) if mtimes else 0.0
+
+
+def main() -> int:
+    root = Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else Path.cwd().resolve()
+    if not (root / ".git").exists():
+        return 0
+
+    planning_mtime = newest_planning_mtime(root)
+    if planning_mtime == 0:
+        return 0
+
+    diff_stat = run(["git", "diff", "--stat"], root)
+    if not diff_stat:
+        return 0
+
+    now = datetime.now().timestamp()
+    age_hours = (now - planning_mtime) / 3600
+    if age_hours < 1:
+        return 0
+
+    print("[planning-with-files] Catchup reminder")
+    print("Detected git changes after last planning file update.")
+    print("Recommended next steps:")
+    print("1. Read task_plan.md, findings.md, progress.md")
+    print("2. Run: git diff --stat")
+    print("3. Sync planning files with current code changes")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

package/skills/planning-with-files/templates/findings.md

@@ -0,0 +1,24 @@
+# Findings and Decisions
+
+## Requirements
+-
+
+## Research Findings
+-
+
+## Technical Decisions
+| Decision | Rationale |
+|----------|-----------|
+|          |           |
+
+## Issues Encountered
+| Issue | Resolution |
+|-------|------------|
+|       |            |
+
+## Resources
+-
+
+## Visual or Browser Findings
+-
+

package/skills/planning-with-files/templates/progress.md

@@ -0,0 +1,38 @@
+# Progress Log
+
+## Session: [DATE]
+
+### Phase 1: [Title]
+- **Status:** in_progress
+- **Started:** [timestamp]
+- Actions taken:
+  -
+- Files created or modified:
+  -
+
+### Phase 2: [Title]
+- **Status:** pending
+- Actions taken:
+  -
+- Files created or modified:
+  -
+
+## Test Results
+| Test | Input | Expected | Actual | Status |
+|------|-------|----------|--------|--------|
+|      |       |          |        |        |
+
+## Error Log
+| Timestamp | Error | Attempt | Resolution |
+|-----------|-------|---------|------------|
+|           |       | 1       |            |
+
+## Reboot Check
+| Question | Answer |
+|----------|--------|
+| Where am I? | Phase X |
+| Where am I going? | Remaining phases |
+| What is the goal? | See task_plan.md |
+| What have I learned? | See findings.md |
+| What have I done? | See this file |
+

package/skills/planning-with-files/templates/task_plan.md

@@ -0,0 +1,53 @@
+# Task Plan: [Brief Description]
+
+## Goal
+[One sentence describing the end state]
+
+## Current Phase
+Phase 1
+
+## Phases
+
+### Phase 1: Requirements and Discovery
+- [ ] Understand user intent
+- [ ] Identify constraints and requirements
+- [ ] Document findings in findings.md
+- **Status:** in_progress
+
+### Phase 2: Planning and Structure
+- [ ] Define technical approach
+- [ ] Create project structure if needed
+- [ ] Document major decisions
+- **Status:** pending
+
+### Phase 3: Implementation
+- [ ] Execute plan in small steps
+- [ ] Keep changes reversible
+- [ ] Verify incrementally
+- **Status:** pending
+
+### Phase 4: Testing and Verification
+- [ ] Verify requirements are met
+- [ ] Log test results in progress.md
+- [ ] Fix issues found
+- **Status:** pending
+
+### Phase 5: Delivery
+- [ ] Review output quality
+- [ ] Summarize results and residual risks
+- **Status:** pending
+
+## Key Questions
+1. [Question to answer]
+2. [Question to answer]
+
+## Decisions Made
+| Decision | Rationale |
+|----------|-----------|
+|          |           |
+
+## Errors Encountered
+| Error | Attempt | Resolution |
+|-------|---------|------------|
+|       | 1       |            |
+

package/skills/ralph/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ralph
-description: Self-referential loop until task completion with architect verification
+description: Self-referential loop until task completion with configurable verification reviewer
 ---
 
 [RALPH + ULTRAWORK - ITERATION {{ITERATION}}/{{MAX}}]
@@ -8,14 +8,14 @@ description: Self-referential loop until task completion with architect verifica
 Your previous attempt did not output the completion promise. Continue working on the task.
 
 <Purpose>
-Ralph is a PRD-driven persistence loop that keeps working on a task until ALL user stories in prd.json have passes: true and are architect-verified. It wraps ultrawork's parallel execution with session persistence, automatic retry on failure, structured story tracking, and mandatory verification before completion.
+Ralph is a PRD-driven persistence loop that keeps working on a task until ALL user stories in prd.json have passes: true and are reviewer-verified. It wraps ultrawork's parallel execution with session persistence, automatic retry on failure, structured story tracking, and mandatory verification before completion.
 </Purpose>
 
 <Use_When>
 - Task requires guaranteed completion with verification (not just "do your best")
 - User says "ralph", "don't stop", "must complete", "finish this", or "keep going until done"
 - Work may span multiple iterations and needs persistence across retries
-- Task benefits from structured PRD-driven execution with architect sign-off
+- Task benefits from structured PRD-driven execution with reviewer sign-off
 </Use_When>
 
 <Do_Not_Use_When>
@@ -30,13 +30,15 @@ Complex tasks often fail silently: partial implementations get declared "done",
 1. Structuring work into discrete user stories with testable acceptance criteria (prd.json)
 2. Iterating story-by-story until each one passes
 3. Tracking progress and learnings across iterations (progress.txt)
-4. Requiring fresh architect verification against specific acceptance criteria before completion
+4. Requiring fresh reviewer verification against specific acceptance criteria before completion
 </Why_This_Exists>
 
 <PRD_Mode>
 By default, ralph operates in PRD mode. A scaffold `prd.json` is auto-generated when ralph starts if none exists.
 
 **Opt-out:** If `{{PROMPT}}` contains `--no-prd`, skip PRD generation and work in legacy mode (no story tracking, generic verification). Use this for trivial quick fixes.
+
+**Reviewer selection:** Pass `--critic=architect`, `--critic=critic`, or `--critic=codex` in the Ralph prompt to choose the completion reviewer for that run. `architect` remains the default.
 </PRD_Mode>
 
 <Execution_Policy>
@@ -84,20 +86,24 @@ By default, ralph operates in PRD mode. A scaffold `prd.json` is auto-generated
    b. If NOT all complete, loop back to Step 2 (pick next story)
    c. If ALL complete, proceed to Step 7 (architect verification)
 
-7. **Architect verification** (tiered, against acceptance criteria):
+7. **Reviewer verification** (tiered, against acceptance criteria):
    - <5 files, <100 lines with full tests: STANDARD tier minimum (architect-medium / Sonnet)
    - Standard changes: STANDARD tier (architect-medium / Sonnet)
    - >20 files or security/architectural changes: THOROUGH tier (architect / Opus)
+   - If `--critic=critic`, use the Claude `critic` agent for the approval pass
+   - If `--critic=codex`, run `omc ask codex --agent-prompt critic "..."` for the approval pass
    - Ralph floor: always at least STANDARD, even for small changes
-   - The architect verifies against the SPECIFIC acceptance criteria from prd.json, not vague "is it done?"
+   - The selected reviewer verifies against the SPECIFIC acceptance criteria from prd.json, not vague "is it done?"
 
 8. **On approval**: Run `/oh-my-claudecode:cancel` to cleanly exit and clean up all state files
 
-9. **On rejection**: Fix the issues raised, re-verify at the same tier, then loop back to check if the story needs to be marked incomplete
+9. **On rejection**: Fix the issues raised, re-verify with the same reviewer, then loop back to check if the story needs to be marked incomplete
 </Steps>
 
 <Tool_Usage>
-- Use `Task(subagent_type="oh-my-claudecode:architect", ...)` for verification cross-checks when changes are security-sensitive, architectural, or involve complex multi-system integration
+- Use `Task(subagent_type="oh-my-claudecode:architect", ...)` for architect verification cross-checks when changes are security-sensitive, architectural, or involve complex multi-system integration
+- Use `Task(subagent_type="oh-my-claudecode:critic", ...)` when `--critic=critic`
+- Use `omc ask codex --agent-prompt critic "..."` when `--critic=codex`
 - Skip architect consultation for simple feature additions, well-tested changes, or time-critical verification
 - Proceed with architect agent verification alone -- never block on unavailable tools
 - Use `state_write` / `state_read` for ralph mode state persistence between iterations
@@ -171,7 +177,7 @@ Why bad: Did not refine scaffold criteria into task-specific ones. This is PRD t
 - Stop and report when a fundamental blocker requires user input (missing credentials, unclear requirements, external service down)
 - Stop when the user says "stop", "cancel", or "abort" -- run `/oh-my-claudecode:cancel`
 - Continue working when the hook system sends "The boulder never stops" -- this means the iteration continues
-- If architect rejects verification, fix the issues and re-verify (do not stop)
+- If the selected reviewer rejects verification, fix the issues and re-verify (do not stop)
 - If the same issue recurs across 3+ iterations, report it as a potential fundamental problem
 </Escalation_And_Stop_Conditions>
 
@@ -184,7 +190,7 @@ Why bad: Did not refine scaffold criteria into task-specific ones. This is PRD t
 - [ ] Fresh build output shows success
 - [ ] lsp_diagnostics shows 0 errors on affected files
 - [ ] progress.txt records implementation details and learnings
-- [ ] Architect verification passed (STANDARD tier minimum) against specific acceptance criteria
+- [ ] Selected reviewer verification passed against specific acceptance criteria
 - [ ] `/oh-my-claudecode:cancel` run for clean state cleanup
 </Final_Checklist>
 

package/skills/release/SKILL.md

@@ -25,6 +25,8 @@ Update version in all locations:
 - `src/installer/index.ts` (VERSION constant)
 - `src/__tests__/installer.test.ts` (expected version)
 - `.claude-plugin/plugin.json`
+- `.claude-plugin/marketplace.json` (both `plugins[0].version` and root `version`)
+- `docs/CLAUDE.md` (`<!-- OMC:VERSION:X.Y.Z -->` marker)
 - `README.md` (version badge and title)
 
 ### 2. Run Tests
@@ -68,6 +70,8 @@ gh release create v<version> --title "v<version> - <title>" --notes "<release no
 | `src/installer/index.ts` | `export const VERSION = 'X.Y.Z'` |
 | `src/__tests__/installer.test.ts` | `expect(VERSION).toBe('X.Y.Z')` |
 | `.claude-plugin/plugin.json` | `"version": "X.Y.Z"` |
+| `.claude-plugin/marketplace.json` | `plugins[0].version` + root `version` |
+| `docs/CLAUDE.md` | `<!-- OMC:VERSION:X.Y.Z -->` |
 | `README.md` | Title + version badge |
 
 ## Semantic Versioning

package/skills/setup/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: setup
+description: Unified setup entrypoint for install, diagnostics, and MCP configuration
+---
+
+# Setup
+
+Use `/oh-my-claudecode:setup` as the unified setup/configuration entrypoint.
+
+## Usage
+
+```bash
+/oh-my-claudecode:setup                # full setup wizard
+/oh-my-claudecode:setup doctor         # installation diagnostics
+/oh-my-claudecode:setup mcp            # MCP server configuration
+/oh-my-claudecode:setup wizard --local # explicit wizard path
+```
+
+## Routing
+
+Route by the first argument:
+
+- No argument, `wizard`, `local`, `global`, or `--force` -> run `/oh-my-claudecode:omc-setup {{ARGUMENTS}}`
+- `doctor` -> run `/oh-my-claudecode:omc-doctor {{ARGUMENTS_AFTER_DOCTOR}}`
+- `mcp` -> run `/oh-my-claudecode:mcp-setup {{ARGUMENTS_AFTER_MCP}}`
+
+Examples:
+
+```bash
+/oh-my-claudecode:omc-setup {{ARGUMENTS}}
+/oh-my-claudecode:omc-doctor {{ARGUMENTS_AFTER_DOCTOR}}
+/oh-my-claudecode:mcp-setup {{ARGUMENTS_AFTER_MCP}}
+```
+
+## Notes
+
+- `/oh-my-claudecode:omc-setup`, `/oh-my-claudecode:omc-doctor`, and `/oh-my-claudecode:mcp-setup` remain valid compatibility entrypoints.
+- Prefer `/oh-my-claudecode:setup` in new documentation and user guidance.
+
+Task: {{ARGUMENTS}}

package/skills/start-dev/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: start-dev
+description: Adaptive development workflow that runs discover -> research -> plan -> implement -> verify with explicit quality gates.
+---
+
+# start-dev
+
+Use this skill as a practical default for non-trivial feature delivery.
+
+## Goal
+
+Move from request to verified implementation with minimal rework.
+
+## Workflow
+
+1. Discover:
+   - Map affected modules
+   - Identify constraints and existing patterns
+2. Research:
+   - Validate version-sensitive APIs and framework behavior from official docs
+3. Plan:
+   - Define smallest reversible change
+   - List files and risks
+4. Implement:
+   - Execute in small increments
+   - Keep tests and build green
+5. Verify:
+   - Run targeted tests, then broader checks
+   - Summarize residual risk honestly
+
+## Delegation Pattern
+
+- `explore` for codebase mapping
+- `architect` for design tradeoffs
+- `executor` for implementation
+- `test-engineer` for test strategy
+- `code-reviewer` or `verifier` for final quality pass
+
+## Quality Gates
+
+- Requirements are explicit before coding.
+- Plan includes rollback strategy.
+- Verification commands and results are captured.
+- No completion claim without evidence.
+