oh-my-claude-sisyphus 3.3.10 → 3.4.1

package/agents/templates/tier-instructions.md

@@ -0,0 +1,94 @@
+# Tier-Specific Instructions
+
+This document defines the behavioral differences between agent tiers (LOW/MEDIUM/HIGH).
+
+## LOW Tier (Haiku)
+**Model**: claude-haiku-4-5
+**Focus**: Speed and efficiency for simple, well-defined tasks
+
+```markdown
+**Tier: LOW (Haiku) - Speed-Focused Execution**
+
+- Focus on speed and direct execution
+- Handle simple, well-defined tasks only
+- Limit exploration to 5 files maximum
+- Escalate to MEDIUM tier if:
+  - Task requires analyzing more than 5 files
+  - Complexity is higher than expected
+  - Architectural decisions needed
+- Prefer straightforward solutions over clever ones
+- Skip deep investigation - implement what's asked
+```
+
+## MEDIUM Tier (Sonnet)
+**Model**: claude-sonnet-4-5
+**Focus**: Balance between thoroughness and efficiency
+
+```markdown
+**Tier: MEDIUM (Sonnet) - Balanced Execution**
+
+- Balance thoroughness with efficiency
+- Can explore up to 20 files
+- Handle moderate complexity tasks
+- Consult architect agent for architectural decisions
+- Escalate to HIGH tier if:
+  - Task requires deep architectural changes
+  - System-wide refactoring needed
+  - Complex debugging across many components
+- Consider edge cases but don't over-engineer
+- Document non-obvious decisions
+```
+
+## HIGH Tier (Opus)
+**Model**: claude-opus-4-5
+**Focus**: Correctness and quality for complex tasks
+
+```markdown
+**Tier: HIGH (Opus) - Excellence-Focused Execution**
+
+- Prioritize correctness and code quality above all
+- Full codebase exploration allowed
+- Make architectural decisions confidently
+- Handle complex, ambiguous, or system-wide tasks
+- Consider:
+  - Long-term maintainability
+  - Edge cases and error scenarios
+  - Performance implications
+  - Security considerations
+- Thoroughly document reasoning
+- No escalation needed - you are the top tier
+```
+
+## Selection Guide
+
+| Task Type | Tier | Rationale |
+|-----------|------|-----------|
+| Simple bug fix in known file | LOW | Well-defined, single file |
+| Add validation to existing function | LOW | Straightforward addition |
+| Implement feature across 3-5 files | MEDIUM | Moderate scope |
+| Debug integration issue | MEDIUM | Requires investigation |
+| Refactor module architecture | HIGH | Architectural decision |
+| Design new system component | HIGH | Complex design needed |
+| Fix subtle race condition | HIGH | Deep debugging required |
+| Optimize performance bottleneck | HIGH | Requires deep analysis |
+
+## Template Usage
+
+When creating an agent prompt, replace `{{TIER_INSTRUCTIONS}}` with the appropriate tier block above.
+
+Example for executor-low:
+```markdown
+# executor-low
+
+## Role
+You execute simple, well-defined code changes quickly and efficiently.
+
+## Tier-Specific Instructions
+**Tier: LOW (Haiku) - Speed-Focused Execution**
+
+- Focus on speed and direct execution
+- Handle simple, well-defined tasks only
+- Limit exploration to 5 files maximum
+- Escalate to MEDIUM tier if complexity exceeds expectations
+...
+```

package/commands/cancel-ecomode.md

@@ -0,0 +1,71 @@
+---
+description: Cancel active Ecomode mode (deprecated - use /oh-my-claudecode:cancel instead)
+---
+
+# Cancel Ecomode
+
+[ECOMODE CANCELLED]
+
+**DEPRECATION NOTICE:** This command is deprecated. Use `/oh-my-claudecode:cancel` instead, which intelligently detects and cancels any active mode including ecomode.
+
+The unified cancel command is safer because it:
+- Checks if ecomode is linked to Ralph and handles both
+- Prevents orphaned state files
+- Provides consistent cancellation experience
+
+## Legacy Behavior
+
+If you still use this command, it will:
+
+1. Check if ecomode is linked to Ralph
+2. If linked → Warn and suggest using `/oh-my-claudecode:cancel-ralph`
+3. If standalone → Cancel ecomode only
+
+## Arguments
+
+{{ARGUMENTS}}
+
+## Recommended Action
+
+Use the unified cancel command:
+```
+/oh-my-claudecode:cancel
+```
+
+This will detect ecomode and cancel it properly, along with any linked modes.
+
+## Implementation
+
+If you must cancel ecomode directly:
+
+```bash
+# Check if linked to ralph
+LINKED=$(cat .omc/ecomode-state.json 2>/dev/null | jq -r '.linked_to_ralph // false')
+
+if [[ "$LINKED" == "true" ]]; then
+  echo "Warning: Ecomode is linked to Ralph."
+  echo "Use /oh-my-claudecode:cancel to cancel both modes."
+  exit 1
+fi
+
+# Cancel standalone ecomode
+mkdir -p .omc ~/.claude
+rm -f .omc/ecomode-state.json
+rm -f ~/.claude/ecomode-state.json
+
+echo "Ecomode cancelled. Token-efficient execution mode deactivated."
+```
+
+## Migration
+
+Replace:
+```bash
+/oh-my-claudecode:cancel-ecomode
+```
+
+With:
+```bash
+/oh-my-claudecode:cancel
+```
+
+The new unified cancel is smarter and safer.

package/commands/cancel.md

@@ -0,0 +1,75 @@
+---
+description: Cancel any active OMC mode (autopilot, ralph, ultrawork, ecomode, ultraqa, swarm, ultrapilot, pipeline)
+---
+
+# Cancel Command
+
+[UNIFIED CANCEL - INTELLIGENT MODE DETECTION]
+
+You are cancelling the active OMC mode. The cancel skill will automatically detect which mode is running and clean it up properly.
+
+## Auto-Detection
+
+The skill checks state files to determine what's active and cancels in order of dependency:
+
+1. **Autopilot** - Stops workflow, preserves progress for resume, cleans up ralph/ultraqa
+2. **Ralph** - Stops persistence loop, cleans up linked ultrawork or ecomode
+3. **Ultrawork** - Stops parallel execution (standalone)
+4. **Ecomode** - Stops token-efficient execution (standalone)
+5. **UltraQA** - Stops QA cycling workflow
+6. **Swarm** - Stops coordinated agents, releases claimed tasks
+7. **Ultrapilot** - Stops parallel autopilot workers
+8. **Pipeline** - Stops sequential agent chain
+
+## Usage
+
+Basic cancellation (auto-detects mode):
+```
+/oh-my-claudecode:cancel
+```
+
+Force clear ALL state files:
+```
+/oh-my-claudecode:cancel --force
+/oh-my-claudecode:cancel --all
+```
+
+## User Arguments
+
+{{ARGUMENTS}}
+
+## State Files Checked
+
+- `.omc/autopilot-state.json` → Autopilot
+- `.omc/ralph-state.json` → Ralph
+- `.omc/ultrawork-state.json` → Ultrawork
+- `.omc/ecomode-state.json` → Ecomode
+- `.omc/ultraqa-state.json` → UltraQA
+- `.omc/swarm-state.json` → Swarm
+- `.omc/ultrapilot-state.json` → Ultrapilot
+- `.omc/pipeline-state.json` → Pipeline
+
+## What Gets Preserved
+
+| Mode | Progress Preserved | Resume |
+|------|-------------------|--------|
+| Autopilot | Yes (phase, spec, plan) | `/oh-my-claudecode:autopilot` |
+| All Others | No | N/A |
+
+## Dependency-Aware Cleanup
+
+- **Autopilot cancellation** → Cleans ralph + ultraqa if active
+- **Ralph cancellation** → Cleans linked ultrawork OR ecomode if applicable
+- **Force mode** → Clears ALL state files regardless of what's active
+
+## Exit Messages
+
+The skill will report:
+- Which mode was cancelled
+- What phase/iteration it was in (if applicable)
+- What dependent modes were cleaned up
+- How to resume (if applicable)
+
+## Implementation
+
+Run the cancel skill which contains the full bash implementation for intelligent mode detection and cleanup.

package/commands/ecomode.md

@@ -0,0 +1,60 @@
+---
+description: Token-efficient parallel execution mode using Haiku and Sonnet agents
+aliases: [eco, efficient, save-tokens, budget]
+---
+
+# Ecomode Skill
+
+Activates token-efficient parallel execution for pro-plan users who prioritize cost efficiency over maximum capability.
+
+## When to Use Ecomode
+
+- You're on a pro plan and want to conserve tokens
+- Tasks don't require complex reasoning (no deep debugging, architecture design)
+- You want faster responses (smaller models = lower latency)
+- Standard development work: features, bug fixes, refactoring
+
+## How It Differs from Ultrawork
+
+| Aspect | Ecomode | Ultrawork |
+|--------|---------|-----------|
+| **Default Tier** | Haiku (LOW) | Sonnet (MEDIUM) |
+| **Fallback Tier** | Sonnet (MEDIUM) | Opus (HIGH) |
+| **Opus Usage** | Avoided (planning only if essential) | Used for complex tasks |
+| **Token Cost** | Lower | Higher |
+| **Best For** | Standard dev work | Complex challenges |
+
+## Activation
+
+**Explicit keywords** (always activates ecomode):
+- "ecomode", "eco", "efficient", "save-tokens", "budget"
+
+**Examples:**
+```
+eco fix the login bug
+ecomode: refactor the API
+budget mode: add form validation
+```
+
+## Agent Routing
+
+Ecomode routes tasks to lower-tier agents:
+
+| Domain | Ecomode Uses | Ultrawork Uses |
+|--------|--------------|----------------|
+| Analysis | architect-low (haiku) | architect (opus) |
+| Execution | executor-low (haiku) | executor-high (opus) |
+| Frontend | designer-low (haiku) | designer-high (opus) |
+| Search | explore (haiku) | explore-medium (sonnet) |
+
+## Setting as Default
+
+Run `/oh-my-claudecode:omc-setup` to set ecomode as your default parallel execution mode.
+
+When set as default, saying "fast" or "parallel" will activate ecomode instead of ultrawork.
+
+## Cancellation
+
+- `/oh-my-claudecode:cancel-ecomode` - Cancel ecomode only
+- `/oh-my-claudecode:cancel` - Cancel any active mode (auto-detects)
+- Say "stop" or "cancel" - Unified cancellation

package/commands/help.md

@@ -61,4 +61,4 @@ But now you don't NEED them - everything is automatic.
 
 ---
 
-*Version: 3.0.11*
+*Version: 3.4.0*

package/commands/mcp-setup.md

@@ -64,7 +64,7 @@ Read the current `~/.claude/settings.json` and add/update the `mcpServers` secti
   "mcpServers": {
     "context7": {
       "command": "npx",
-      "args": ["-y", "@context7/mcp"]
+      "args": ["-y", "@upstash/context7-mcp"]
     }
   }
 }
@@ -76,7 +76,7 @@ Read the current `~/.claude/settings.json` and add/update the `mcpServers` secti
   "mcpServers": {
     "exa": {
       "command": "npx",
-      "args": ["-y", "@anthropic/exa-mcp-server"],
+      "args": ["-y", "exa-mcp-server"],
       "env": {
         "EXA_API_KEY": "<user-provided-key>"
       }
@@ -91,7 +91,7 @@ Read the current `~/.claude/settings.json` and add/update the `mcpServers` secti
   "mcpServers": {
     "filesystem": {
       "command": "npx",
-      "args": ["-y", "@anthropic/mcp-server-filesystem", "<allowed-directories>"]
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "<allowed-directories>"]
     }
   }
 }
@@ -102,15 +102,16 @@ Read the current `~/.claude/settings.json` and add/update the `mcpServers` secti
 {
   "mcpServers": {
     "github": {
-      "command": "npx",
-      "args": ["-y", "@anthropic/github-mcp-server"],
+      "command": "docker",
+      "args": ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"],
       "env": {
-        "GITHUB_TOKEN": "<user-provided-token>"
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "<user-provided-token>"
       }
     }
   }
 }
 ```
+> Note: GitHub MCP requires Docker. Alternatively, configure as a remote URL: https://api.githubcopilot.com/mcp/
 
 ## Step 4: Merge Configuration
 

package/commands/pipeline.md

@@ -0,0 +1,231 @@
+---
+description: Sequential agent chaining with data passing between stages
+aliases: [pipe, chain]
+---
+
+# Pipeline Command
+
+[PIPELINE MODE ACTIVATED]
+
+Chain multiple agents together in sequential workflows where output from one agent flows to the next. Like Unix pipes for AI agents.
+
+## User's Request
+
+{{ARGUMENTS}}
+
+## Mission
+
+Execute a pipeline of agents where each stage receives context from previous stages and passes refined output to the next.
+
+## Usage Patterns
+
+### Built-in Presets
+
+Use predefined pipelines for common workflows:
+
+```
+/oh-my-claudecode:pipeline review <task>
+/oh-my-claudecode:pipeline implement <task>
+/oh-my-claudecode:pipeline debug <issue>
+/oh-my-claudecode:pipeline research <topic>
+/oh-my-claudecode:pipeline refactor <target>
+/oh-my-claudecode:pipeline security <scope>
+```
+
+### Custom Pipelines
+
+Define your own agent sequence:
+
+```
+/oh-my-claudecode:pipeline explore -> architect -> executor "add authentication"
+/oh-my-claudecode:pipeline explore:haiku -> architect:opus -> executor:sonnet "optimize performance"
+```
+
+### With Parallel Stages
+
+Run agents in parallel then merge:
+
+```
+/oh-my-claudecode:pipeline [explore, researcher] -> architect -> executor "implement OAuth"
+```
+
+## Built-in Pipeline Definitions
+
+### Review Pipeline
+**Stages:** explore → architect → critic → executor
+**Use for:** Comprehensive code review and implementation
+
+### Implement Pipeline
+**Stages:** planner → executor → tdd-guide
+**Use for:** New features with clear requirements
+
+### Debug Pipeline
+**Stages:** explore → architect → build-fixer
+**Use for:** Bugs, build errors, test failures
+
+### Research Pipeline
+**Stages:** parallel(researcher, explore) → architect → writer
+**Use for:** Technology decisions, API integrations
+
+### Refactor Pipeline
+**Stages:** explore → architect-medium → executor-high → qa-tester
+**Use for:** Architectural changes, API redesigns
+
+### Security Pipeline
+**Stages:** explore → security-reviewer → executor → security-reviewer-low
+**Use for:** Security audits and vulnerability fixes
+
+## Pipeline State
+
+Pipelines maintain state in `.omc/pipeline-state.json`:
+
+```json
+{
+  "pipeline_id": "uuid",
+  "name": "review",
+  "active": true,
+  "current_stage": 2,
+  "stages": [
+    {
+      "name": "explore",
+      "status": "completed",
+      "output": "..."
+    },
+    {
+      "name": "architect",
+      "status": "in_progress"
+    },
+    {
+      "name": "executor",
+      "status": "pending"
+    }
+  ]
+}
+```
+
+## Data Passing Protocol
+
+Each agent receives structured context:
+
+```json
+{
+  "pipeline_context": {
+    "original_task": "user's request",
+    "previous_stages": [
+      {
+        "agent": "explore",
+        "findings": "...",
+        "files_identified": ["src/auth.ts"]
+      }
+    ],
+    "current_stage": "architect",
+    "next_stage": "executor"
+  }
+}
+```
+
+## Workflow
+
+### 1. Parse Pipeline Definition
+
+Extract:
+- Pipeline name (preset) or custom agent sequence
+- Model specifications for each stage
+- Task description
+
+### 2. Initialize State
+
+Create `.omc/pipeline-state.json` with:
+- Unique pipeline ID
+- Stage definitions
+- Status tracking
+
+### 3. Execute Stages Sequentially
+
+For each stage:
+1. Spawn agent via Task tool
+2. Pass context from previous stages
+3. Collect output
+4. Update pipeline state
+5. Move to next stage
+
+### 4. Handle Parallel Stages
+
+When parallel stages detected (e.g., `[explore, researcher]`):
+1. Spawn multiple agents with `run_in_background: true`
+2. Wait for all to complete
+3. Merge outputs (concat or summarize)
+4. Pass merged output to next stage
+
+### 5. Verify and Complete
+
+Before completion:
+- All stages marked "completed"
+- Output from final stage addresses original task
+- No unhandled errors
+- Modified files pass lsp_diagnostics
+- Tests pass (if applicable)
+
+## Error Handling
+
+When a stage fails:
+- **Retry** - Re-run same agent (up to 3 times)
+- **Fallback** - Route to higher-tier agent
+- **Abort** - Stop entire pipeline
+
+Configuration:
+```
+/pipeline explore -> architect -> executor --retry=3 --on-error=abort
+```
+
+## Cancellation
+
+Stop active pipeline:
+```
+/oh-my-claudecode:cancel
+```
+
+The unified cancel command auto-detects active pipeline and cleans up state.
+
+## Examples
+
+### Example 1: Feature Implementation
+```
+/oh-my-claudecode:pipeline review "add rate limiting to API"
+```
+Triggers: explore → architect → critic → executor
+
+### Example 2: Bug Fix
+```
+/oh-my-claudecode:pipeline debug "login fails with OAuth"
+```
+Triggers: explore → architect → build-fixer
+
+### Example 3: Custom Chain
+```
+/oh-my-claudecode:pipeline explore:haiku -> architect:opus -> executor:sonnet -> tdd-guide:sonnet "refactor auth module"
+```
+
+### Example 4: Research-Driven Implementation
+```
+/oh-my-claudecode:pipeline research "implement GraphQL subscriptions"
+```
+Triggers: parallel(researcher, explore) → architect → writer
+
+## Best Practices
+
+1. **Start with presets** - Use built-in pipelines before custom ones
+2. **Match model to complexity** - haiku for simple, opus for complex
+3. **Keep stages focused** - One clear responsibility per agent
+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
+
+## Output
+
+Report when complete:
+- Pipeline name and stages executed
+- Output from each stage
+- Final result
+- Verification status
+- Total time elapsed