oh-my-claude-sisyphus 3.3.10 → 3.4.1

package/skills/omc-setup/SKILL.md

@@ -1,14 +1,28 @@
 ---
 name: omc-setup
-description: One-time setup for oh-my-claudecode (the ONLY command you need to learn)
-user-invocable: true
+description: Setup and configure oh-my-claudecode (the ONLY command you need to learn)
 ---
 
 # OMC Setup
 
 This is the **only command you need to learn**. After running this, everything else is automatic.
 
-## Step 1: Ask User Preference
+## Usage Modes
+
+This skill handles three scenarios:
+
+1. **Initial Setup (no flags)**: First-time installation wizard
+2. **Local Configuration (`--local`)**: Configure project-specific settings (.claude/CLAUDE.md)
+3. **Global Configuration (`--global`)**: Configure global settings (~/.claude/CLAUDE.md)
+
+## Mode Detection
+
+Check for flags in the user's invocation:
+- If `--local` flag present → Skip to Local Configuration (Step 2A)
+- If `--global` flag present → Skip to Global Configuration (Step 2B)
+- If no flags → Run Initial Setup wizard (Step 1)
+
+## Step 1: Initial Setup Wizard (Default Behavior)
 
 Use the AskUserQuestion tool to prompt the user:
 
@@ -18,14 +32,20 @@ Use the AskUserQuestion tool to prompt the user:
 1. **Local (this project)** - Creates `.claude/CLAUDE.md` in current project directory. Best for project-specific configurations.
 2. **Global (all projects)** - Creates `~/.claude/CLAUDE.md` for all Claude Code sessions. Best for consistent behavior everywhere.
 
-## Step 2: Execute Based on Choice
+## Step 2A: Local Configuration (--local flag or user chose LOCAL)
+
+**CRITICAL**: This ALWAYS downloads fresh CLAUDE.md from GitHub to the local project. DO NOT use the Write tool - use bash curl exclusively.
 
-### If User Chooses LOCAL:
+### Create Local .claude Directory
 
 ```bash
 # Create .claude directory in current project
-mkdir -p .claude
+mkdir -p .claude && echo ".claude directory ready"
+```
+
+### Download Fresh CLAUDE.md
 
+```bash
 # Extract old version before download
 OLD_VERSION=$(grep -m1 "^# oh-my-claudecode" .claude/CLAUDE.md 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+' || echo "none")
 
@@ -44,7 +64,40 @@ else
 fi
 ```
 
-### If User Chooses GLOBAL:
+**Note**: The downloaded CLAUDE.md includes Context Persistence instructions with `<remember>` tags for surviving conversation compaction.
+
+**MANDATORY**: Always run this command. Do NOT skip. Do NOT use Write tool.
+
+**FALLBACK** if curl fails:
+Tell user to manually download from:
+https://raw.githubusercontent.com/Yeachan-Heo/oh-my-claudecode/main/docs/CLAUDE.md
+
+### Verify Plugin Installation
+
+```bash
+grep -q "oh-my-claudecode" ~/.claude/settings.json && echo "Plugin verified" || echo "Plugin NOT found - run: claude /install-plugin oh-my-claudecode"
+```
+
+### Confirm Local Configuration Success
+
+After completing local configuration, report:
+
+**OMC Project Configuration Complete**
+- CLAUDE.md: Updated with latest configuration from GitHub at ./.claude/CLAUDE.md
+- Scope: **PROJECT** - applies only to this project
+- Hooks: Provided by plugin (no manual installation needed)
+- Agents: 28+ available (base + tiered variants)
+- Model routing: Haiku/Sonnet/Opus based on task complexity
+
+**Note**: This configuration is project-specific and won't affect other projects or global settings.
+
+If `--local` flag was used, **STOP HERE**. Do not continue to HUD setup or other steps.
+
+## Step 2B: Global Configuration (--global flag or user chose GLOBAL)
+
+**CRITICAL**: This ALWAYS downloads fresh CLAUDE.md from GitHub to global config. DO NOT use the Write tool - use bash curl exclusively.
+
+### Download Fresh CLAUDE.md
 
 ```bash
 # Extract old version before download
@@ -65,6 +118,44 @@ else
 fi
 ```
 
+### Clean Up Legacy Hooks (if present)
+
+Check if old manual hooks exist and remove them to prevent duplicates:
+
+```bash
+# Remove legacy bash hook scripts (now handled by plugin system)
+rm -f ~/.claude/hooks/keyword-detector.sh
+rm -f ~/.claude/hooks/stop-continuation.sh
+rm -f ~/.claude/hooks/persistent-mode.sh
+rm -f ~/.claude/hooks/session-start.sh
+echo "Legacy hooks cleaned"
+```
+
+Check `~/.claude/settings.json` for manual hook entries. If the "hooks" key exists with UserPromptSubmit, Stop, or SessionStart entries pointing to bash scripts, inform the user:
+
+> **Note**: Found legacy hooks in settings.json. These should be removed since the plugin now provides hooks automatically. Remove the "hooks" section from ~/.claude/settings.json to prevent duplicate hook execution.
+
+### Verify Plugin Installation
+
+```bash
+grep -q "oh-my-claudecode" ~/.claude/settings.json && echo "Plugin verified" || echo "Plugin NOT found - run: claude /install-plugin oh-my-claudecode"
+```
+
+### Confirm Global Configuration Success
+
+After completing global configuration, report:
+
+**OMC Global Configuration Complete**
+- CLAUDE.md: Updated with latest configuration from GitHub at ~/.claude/CLAUDE.md
+- Scope: **GLOBAL** - applies to all Claude Code sessions
+- Hooks: Provided by plugin (no manual installation needed)
+- Agents: 28+ available (base + tiered variants)
+- Model routing: Haiku/Sonnet/Opus based on task complexity
+
+**Note**: Hooks are now managed by the plugin system automatically. No manual hook installation required.
+
+If `--global` flag was used, **STOP HERE**. Do not continue to HUD setup or other steps.
+
 ## Step 3: Setup HUD Statusline
 
 The HUD shows real-time status in Claude Code's status bar. **Invoke the hud skill** to set up and configure:
@@ -145,6 +236,36 @@ elif [ -n "$LATEST_VERSION" ]; then
 fi
 ```
 
+## Step 3.7: Set Default Execution Mode
+
+Use the AskUserQuestion tool to prompt the user:
+
+**Question:** "Which parallel execution mode should be your default when you say 'fast' or 'parallel'?"
+
+**Options:**
+1. **ultrawork (maximum capability)** - Uses all agent tiers including Opus for complex tasks. Best for challenging work where quality matters most. (Recommended)
+2. **ecomode (token efficient)** - Prefers Haiku/Sonnet agents, avoids Opus. Best for pro-plan users who want cost efficiency.
+
+Store the preference in `~/.claude/.omc-config.json`:
+
+```bash
+# Read existing config or create empty object
+CONFIG_FILE="$HOME/.claude/.omc-config.json"
+mkdir -p "$(dirname "$CONFIG_FILE")"
+
+if [ -f "$CONFIG_FILE" ]; then
+  EXISTING=$(cat "$CONFIG_FILE")
+else
+  EXISTING='{}'
+fi
+
+# Set defaultExecutionMode (replace USER_CHOICE with "ultrawork" or "ecomode")
+echo "$EXISTING" | jq --arg mode "USER_CHOICE" '. + {defaultExecutionMode: $mode, configuredAt: (now | todate)}' > "$CONFIG_FILE"
+echo "Default execution mode set to: USER_CHOICE"
+```
+
+**Note**: This preference ONLY affects generic keywords ("fast", "parallel"). Explicit keywords ("ulw", "eco") always override this preference.
+
 ## Step 4: Verify Plugin Installation
 
 ```bash
@@ -197,6 +318,7 @@ Just include these words naturally in your request:
 | ralph | Persistence mode | "ralph: fix the auth bug" |
 | ralplan | Iterative planning | "ralplan this feature" |
 | ulw | Max parallelism | "ulw refactor the API" |
+| eco | Token-efficient mode | "eco refactor the API" |
 | plan | Planning interview | "plan the new endpoints" |
 
 Combine them: "ralph ulw: migrate the database"
@@ -231,6 +353,7 @@ MAGIC KEYWORDS (power-user shortcuts):
 | ralph | /ralph | "ralph: fix the bug" |
 | ralplan | /ralplan | "ralplan this feature" |
 | ulw | /ultrawork | "ulw refactor API" |
+| eco | (new!) | "eco fix all errors" |
 | plan | /planner | "plan the endpoints" |
 
 HUD STATUSLINE:
@@ -275,7 +398,50 @@ echo "  https://github.com/Yeachan-Heo/oh-my-claudecode"
 echo ""
 ```
 
-## Fallback
+## Keeping Up to Date
 
-If curl fails, tell user to manually download from:
-https://raw.githubusercontent.com/Yeachan-Heo/oh-my-claudecode/main/docs/CLAUDE.md
+After installing oh-my-claudecode updates (via npm or plugin update), run:
+- `/oh-my-claudecode:omc-setup --local` to update project config
+- `/oh-my-claudecode:omc-setup --global` to update global config
+
+This ensures you have the newest features and agent configurations.
+
+## Help Text
+
+When user runs `/oh-my-claudecode:omc-setup --help` or just `--help`, display:
+
+```
+OMC Setup - Configure oh-my-claudecode
+
+USAGE:
+  /oh-my-claudecode:omc-setup           Run initial setup wizard
+  /oh-my-claudecode:omc-setup --local   Configure local project (.claude/CLAUDE.md)
+  /oh-my-claudecode:omc-setup --global  Configure global settings (~/.claude/CLAUDE.md)
+  /oh-my-claudecode:omc-setup --help    Show this help
+
+MODES:
+  Initial Setup (no flags)
+    - Interactive wizard for first-time setup
+    - Configures CLAUDE.md (local or global)
+    - Sets up HUD statusline
+    - Checks for updates
+    - Offers MCP server configuration
+
+  Local Configuration (--local)
+    - Downloads fresh CLAUDE.md to ./.claude/
+    - Project-specific settings
+    - Use this to update project config after OMC upgrades
+
+  Global Configuration (--global)
+    - Downloads fresh CLAUDE.md to ~/.claude/
+    - Applies to all Claude Code sessions
+    - Cleans up legacy hooks
+    - Use this to update global config after OMC upgrades
+
+EXAMPLES:
+  /oh-my-claudecode:omc-setup           # First time setup
+  /oh-my-claudecode:omc-setup --local   # Update this project
+  /oh-my-claudecode:omc-setup --global  # Update all projects
+
+For more info: https://github.com/Yeachan-Heo/oh-my-claudecode
+```

package/skills/orchestrate/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: orchestrate
 description: Activate multi-agent orchestration mode
-user-invocable: true
 ---
 
 # Orchestrate Skill

package/skills/pipeline/SKILL.md

@@ -0,0 +1,417 @@
+---
+name: pipeline
+description: Chain agents together in sequential or branching workflows with data passing
+---
+
+# Pipeline Skill
+
+## Overview
+
+The pipeline skill enables chaining multiple agents together in defined workflows where the output of one agent becomes the input to the next. This creates powerful agent pipelines similar to Unix pipes but designed for AI agent orchestration.
+
+## Core Concepts
+
+### 1. Sequential Pipelines
+
+The simplest form: Agent A's output flows to Agent B, which flows to Agent C.
+
+```
+explore -> architect -> executor
+```
+
+**Flow:**
+1. Explore agent searches codebase and produces findings
+2. Architect receives findings and produces analysis/recommendations
+3. Executor receives recommendations and implements changes
+
+### 2. Branching Pipelines
+
+Route to different agents based on output conditions.
+
+```
+explore -> {
+  if "complex refactoring" -> architect -> executor-high
+  if "simple change" -> executor-low
+  if "UI work" -> designer -> executor
+}
+```
+
+### 3. Parallel-Then-Merge Pipelines
+
+Run multiple agents in parallel, merge their outputs.
+
+```
+parallel(explore, researcher) -> architect -> executor
+```
+
+## Built-in Pipeline Presets
+
+### Review Pipeline
+**Purpose:** Comprehensive code review and implementation
+
+```
+/pipeline review <task>
+```
+
+**Stages:**
+1. `explore` - Find relevant code and patterns
+2. `architect` - Analyze architecture and design implications
+3. `critic` - Review and critique the analysis
+4. `executor` - Implement with full context
+
+**Use for:** Major features, refactorings, complex changes
+
+---
+
+### Implement Pipeline
+**Purpose:** Planned implementation with testing
+
+```
+/pipeline implement <task>
+```
+
+**Stages:**
+1. `planner` - Create detailed implementation plan
+2. `executor` - Implement the plan
+3. `tdd-guide` - Add/verify tests
+
+**Use for:** New features with clear requirements
+
+---
+
+### Debug Pipeline
+**Purpose:** Systematic debugging workflow
+
+```
+/pipeline debug <issue>
+```
+
+**Stages:**
+1. `explore` - Locate error locations and related code
+2. `architect` - Analyze root cause
+3. `build-fixer` - Apply fixes and verify
+
+**Use for:** Bugs, build errors, test failures
+
+---
+
+### Research Pipeline
+**Purpose:** External research + internal analysis
+
+```
+/pipeline research <topic>
+```
+
+**Stages:**
+1. `parallel(researcher, explore)` - External docs + internal code
+2. `architect` - Synthesize findings
+3. `writer` - Document recommendations
+
+**Use for:** Technology decisions, API integrations
+
+---
+
+### Refactor Pipeline
+**Purpose:** Safe, verified refactoring
+
+```
+/pipeline refactor <target>
+```
+
+**Stages:**
+1. `explore` - Find all usages and dependencies
+2. `architect-medium` - Design refactoring strategy
+3. `executor-high` - Execute refactoring
+4. `qa-tester` - Verify no regressions
+
+**Use for:** Architectural changes, API redesigns
+
+---
+
+### Security Pipeline
+**Purpose:** Security audit and fixes
+
+```
+/pipeline security <scope>
+```
+
+**Stages:**
+1. `explore` - Find potential vulnerabilities
+2. `security-reviewer` - Audit and identify issues
+3. `executor` - Implement fixes
+4. `security-reviewer-low` - Re-verify
+
+**Use for:** Security reviews, vulnerability fixes
+
+---
+
+## Custom Pipeline Syntax
+
+### Basic Sequential
+
+```
+/pipeline agent1 -> agent2 -> agent3 "task description"
+```
+
+**Example:**
+```
+/pipeline explore -> architect -> executor "add authentication"
+```
+
+### With Model Specification
+
+```
+/pipeline explore:haiku -> architect:opus -> executor:sonnet "optimize performance"
+```
+
+### With Branching
+
+```
+/pipeline explore -> (
+  complexity:high -> architect:opus -> executor-high:opus
+  complexity:medium -> executor:sonnet
+  complexity:low -> executor-low:haiku
+) "fix reported issues"
+```
+
+### With Parallel Stages
+
+```
+/pipeline [explore, researcher] -> architect -> executor "implement OAuth"
+```
+
+## Data Passing Protocol
+
+Each agent in the pipeline receives structured context from the previous stage:
+
+```json
+{
+  "pipeline_context": {
+    "original_task": "user's original request",
+    "previous_stages": [
+      {
+        "agent": "explore",
+        "model": "haiku",
+        "findings": "...",
+        "files_identified": ["src/auth.ts", "src/user.ts"]
+      }
+    ],
+    "current_stage": "architect",
+    "next_stage": "executor"
+  },
+  "task": "specific task for this agent"
+}
+```
+
+## Error Handling
+
+### Retry Logic
+
+When an agent fails, the pipeline can:
+
+1. **Retry** - Re-run the same agent (up to 3 times)
+2. **Skip** - Continue to next stage with partial output
+3. **Abort** - Stop entire pipeline
+4. **Fallback** - Route to alternative agent
+
+**Configuration:**
+
+```
+/pipeline explore -> architect -> executor --retry=3 --on-error=abort
+```
+
+### Error Recovery Patterns
+
+**Pattern 1: Fallback to Higher Tier**
+```
+executor-low -> on-error -> executor:sonnet
+```
+
+**Pattern 2: Consult Architect**
+```
+executor -> on-error -> architect -> executor
+```
+
+**Pattern 3: Human-in-the-Loop**
+```
+any-stage -> on-error -> pause-for-user-input
+```
+
+## Pipeline State Management
+
+Pipelines maintain state in `.omc/pipeline-state.json`:
+
+```json
+{
+  "pipeline_id": "uuid",
+  "name": "review",
+  "active": true,
+  "current_stage": 2,
+  "stages": [
+    {
+      "name": "explore",
+      "agent": "explore",
+      "model": "haiku",
+      "status": "completed",
+      "output": "..."
+    },
+    {
+      "name": "architect",
+      "agent": "architect",
+      "model": "opus",
+      "status": "in_progress",
+      "started_at": "2026-01-23T10:30:00Z"
+    },
+    {
+      "name": "executor",
+      "agent": "executor",
+      "model": "sonnet",
+      "status": "pending"
+    }
+  ],
+  "task": "original user task",
+  "created_at": "2026-01-23T10:25:00Z"
+}
+```
+
+## Verification Rules
+
+Before pipeline completion, verify:
+
+- [ ] All stages completed successfully
+- [ ] Output from final stage addresses original task
+- [ ] No unhandled errors in any stage
+- [ ] All files modified pass lsp_diagnostics
+- [ ] Tests pass (if applicable)
+
+## Advanced Features
+
+### Conditional Branching
+
+Based on agent output, route to different paths:
+
+```
+explore -> {
+  if files_found > 5 -> architect:opus -> executor-high:opus
+  if files_found <= 5 -> executor:sonnet
+}
+```
+
+### Loop Constructs
+
+Repeat stages until condition met:
+
+```
+repeat_until(tests_pass) {
+  executor -> qa-tester
+}
+```
+
+### Merge Strategies
+
+When parallel agents complete:
+
+- **concat**: Concatenate all outputs
+- **summarize**: Use architect to summarize findings
+- **vote**: Use critic to choose best output
+
+## Usage Examples
+
+### Example 1: Feature Implementation
+```
+/pipeline review "add rate limiting to API"
+```
+→ Triggers: explore → architect → critic → executor
+
+### Example 2: Bug Fix
+```
+/pipeline debug "login fails with OAuth"
+```
+→ Triggers: explore → architect → build-fixer
+
+### Example 3: Custom Chain
+```
+/pipeline explore:haiku -> architect:opus -> executor:sonnet -> tdd-guide:sonnet "refactor auth module"
+```
+
+### Example 4: Research-Driven Implementation
+```
+/pipeline research "implement GraphQL subscriptions"
+```
+→ Triggers: parallel(researcher, explore) → architect → writer
+
+## Cancellation
+
+Stop active pipeline:
+
+```
+/pipeline cancel
+```
+
+Or use the general cancel command which detects active pipeline.
+
+## Integration with Other Skills
+
+Pipelines can be used within other skills:
+
+- **Ralph**: Loop pipelines until verified complete
+- **Ultrawork**: Run multiple pipelines in parallel
+- **Autopilot**: Use pipelines as building blocks
+
+## Best Practices
+
+1. **Start with presets** - Use built-in pipelines before creating custom ones
+2. **Match model to complexity** - Don't waste opus on simple tasks
+3. **Keep stages focused** - Each agent should have one clear responsibility
+4. **Use parallel stages** - Run independent work simultaneously
+5. **Verify at checkpoints** - Use architect or critic to verify progress
+6. **Document custom pipelines** - Save successful patterns for reuse
+
+## Troubleshooting
+
+### Pipeline Hangs
+
+**Check:** `.omc/pipeline-state.json` for current stage
+**Fix:** Resume with `/pipeline resume` or cancel and restart
+
+### Agent Fails Repeatedly
+
+**Check:** Retry count and error messages
+**Fix:** Route to higher-tier agent or add architect consultation
+
+### Output Not Flowing
+
+**Check:** Data passing structure in agent prompts
+**Fix:** Ensure each agent is prompted with `pipeline_context`
+
+## Technical Implementation
+
+The pipeline orchestrator:
+
+1. **Parses pipeline definition** - Validates syntax and agent names
+2. **Initializes state** - Creates pipeline-state.json
+3. **Executes stages sequentially** - Spawns agents with Task tool
+4. **Passes context between stages** - Structures output for next agent
+5. **Handles branching logic** - Evaluates conditions and routes
+6. **Manages parallel execution** - Spawns concurrent agents and merges
+7. **Persists state** - Updates state file after each stage
+8. **Enforces verification** - Runs checks before completion
+
+## Skill Invocation
+
+This skill activates when:
+
+- User types `/pipeline` command
+- User mentions "agent chain", "workflow", "pipe agents"
+- Pattern detected: "X then Y then Z" with agent names
+
+**Explicit invocation:**
+```
+/oh-my-claudecode:pipeline review "task"
+```
+
+**Auto-detection:**
+```
+"First explore the codebase, then architect should analyze it, then executor implements"
+```
+→ Automatically creates pipeline: explore → architect → executor