oh-my-claude-sisyphus 3.4.0 → 3.4.2

package/README.md

@@ -62,11 +62,76 @@ Include these words anywhere in your message:
 |---------|--------|
 | `ralph` | Persistence mode - won't stop until done |
 | `ralplan` | Iterative planning with consensus |
-| `ulw` | Maximum parallel execution |
+| `ulw` / `ultrawork` | Maximum parallel execution |
+| `ultrapilot` | Parallel autopilot (3-5x faster) |
+| `swarm` | N coordinated agents |
+| `pipeline` | Sequential agent chaining |
+| `eco` / `ecomode` | Token-efficient parallel execution |
 | `plan` | Start a planning interview |
 | `autopilot` / `ap` | Full autonomous execution |
 
-**Combine them:** `ralph ulw: migrate the database`
+**Combine them:** `ralph ulw: migrate the database` or `eco: refactor auth system`
+
+---
+
+## Execution Modes (v3.4.0)
+
+### Ultrapilot: Parallel Autopilot
+
+3-5x faster execution with up to 5 parallel workers. Perfect for multi-component systems and large refactoring:
+
+```
+/oh-my-claudecode:ultrapilot "build a fullstack todo app"
+```
+
+**How it works:**
+- Automatic task decomposition into parallelizable subtasks
+- Non-overlapping file ownership prevents conflicts
+- Parallel execution with intelligent coordination
+- Automatic conflict detection and resolution
+
+---
+
+### Swarm: Coordinated Agents
+
+N independent agents claiming tasks from a shared pool:
+
+```
+/oh-my-claudecode:swarm 5:executor "fix all TypeScript errors"
+```
+
+**Features:**
+- Atomic task claiming prevents duplicate work
+- 5-minute timeout per task with auto-release
+- Scales from 2 to 10 workers
+
+---
+
+### Pipeline: Sequential Chaining
+
+Chain agents together with data passing between stages:
+
+```
+/oh-my-claudecode:pipeline explore:haiku -> architect:opus -> executor:sonnet
+```
+
+**Built-in Presets:**
+- `review` - explore → architect → critic → executor
+- `implement` - planner → executor → tdd-guide
+- `debug` - explore → architect → build-fixer
+- `security` - explore → security-reviewer → executor
+
+---
+
+### Ecomode: Token-Efficient
+
+Maximum parallelism with Haiku where possible, falling back to Sonnet/Opus for complex reasoning:
+
+```
+/oh-my-claudecode:ecomode "refactor the authentication system"
+```
+
+**30-50% token savings** compared to standard ultrawork while maintaining quality.
 
 ---
 
@@ -187,11 +252,12 @@ After configuration, restart Claude Code for changes to take effect.
 
 ## What's Under the Hood
 
-- **28 Specialized Agents** - architect, researcher, explore, designer, writer, vision, critic, analyst, executor, planner, qa-tester, scientist (with tier variants)
-- **31 Skills** - orchestrate, ultrawork, ralph, planner, deepsearch, deepinit, git-master, frontend-ui-ux, learner, research, mcp-setup, and more
+- **32 Specialized Agents** - architect, researcher, explore, designer, writer, vision, critic, analyst, executor, planner, qa-tester, scientist (with tier variants including explore-high)
+- **40 Skills** - orchestrate, autopilot, ultrawork, ultrapilot, swarm, pipeline, ecomode, ralph, planner, ralplan, deepsearch, analyze, research, tdd, build-fix, code-review, security-review, git-master, frontend-ui-ux, learner, mcp-setup, cancel (unified), and more
+- **5 Execution Modes** - Autopilot (autonomous), Ultrapilot (3-5x parallel), Swarm (coordinated), Pipeline (sequential), Ecomode (token-efficient)
 - **MCP Server Support** - Easy configuration of Context7, Exa, GitHub, and custom MCP servers
 - **Persistent Python REPL** - True variable persistence for data analysis
-- **Research Workflow** - Parallel scientist orchestration with `/oh-my-claudecode:research` command (new in 3.3.x)
+- **Research Workflow** - Parallel scientist orchestration with `/oh-my-claudecode:research` command
 - **HUD Statusline** - Real-time visualization of orchestration state
 - **Learned Skills** - Extract reusable insights from sessions with `/oh-my-claudecode:learner`
 - **Memory System** - Persistent context that survives compaction

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/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

package/commands/planner.md

@@ -0,0 +1,174 @@
+---
+description: Strategic planning consultant with interview workflow
+aliases: [planning, plan-interview]
+---
+
+# Planner Command
+
+[PLANNER MODE ACTIVATED - INTERVIEW WORKFLOW]
+
+You are activating the Planner agent, a strategic planning consultant who creates comprehensive work plans through interview-style interaction.
+
+## User's Request
+
+{{ARGUMENTS}}
+
+## What Planner Does
+
+The Planner guides users through planning by:
+
+1. **Interview Phase** - Asks clarifying questions about requirements, constraints, goals
+2. **Analysis Phase** - Consults Analyst for hidden requirements and risk analysis
+3. **Plan Creation** - Creates detailed, actionable work plans
+
+## How It's Different from `/plan`
+
+| Command | Workflow | Use When |
+|---------|----------|----------|
+| `/planner` | Full interview workflow | Requirements unclear, complex project |
+| `/plan` | Quick planning, no interview | Requirements clear, simple task |
+
+## Interview Protocol
+
+The Planner follows strict interview discipline:
+
+### Single Question at a Time
+
+**NEVER** ask multiple questions in one message.
+
+**Good:**
+```
+What's the primary scope for this feature?
+```
+
+**Bad:**
+```
+What's the scope? And the timeline? And who's the audience?
+```
+
+### Question Categories
+
+The Planner asks about:
+- **Goals** - What success looks like
+- **Constraints** - Time, budget, technical limits
+- **Context** - Existing systems, dependencies
+- **Risks** - What could go wrong
+- **Preferences** - Trade-offs (speed vs quality)
+
+### Using AskUserQuestion Tool
+
+For preference questions, the Planner uses `AskUserQuestion` tool to provide clickable UI:
+
+**Question types requiring AskUserQuestion:**
+- Preference (speed vs quality)
+- Requirement (deadline)
+- Scope (include feature Y?)
+- Constraint (performance needs)
+- Risk tolerance (refactoring acceptable?)
+
+**Example:**
+```
+AskUserQuestion(
+  question="For performance, what matters more - latency or throughput?",
+  type="preference",
+  options=["Latency", "Throughput", "Both equally"]
+)
+```
+
+## Plan Quality Criteria
+
+Planner ensures:
+- 80%+ claims cite file/line references
+- 90%+ acceptance criteria are testable
+- No vague terms without metrics
+- All risks have mitigations
+
+## Transition to Plan Creation
+
+Planner creates the plan when user says:
+- "Create the plan"
+- "Make it into a work plan"
+- "I'm ready to plan"
+- "Let's create the plan"
+
+## Plan Structure
+
+The final plan includes:
+
+1. **Requirements Summary** - What was gathered from interview
+2. **Acceptance Criteria** - Testable conditions for completion
+3. **Implementation Steps** - With file references
+4. **Risks & Mitigations** - What could go wrong and how to handle
+5. **Verification Steps** - How to verify completion
+
+## Delegation to Planner Agent
+
+This command delegates to the `planner` agent (Opus model) which follows the full interview workflow.
+
+```
+Task(
+  subagent_type="oh-my-claudecode:planner",
+  model="opus",
+  prompt="PLANNING REQUEST: {{ARGUMENTS}}
+
+Follow the interview workflow:
+1. Ask clarifying questions (one at a time)
+2. Use AskUserQuestion for preference questions
+3. Consult Analyst when ready
+4. Create plan when user confirms
+
+Quality requirements:
+- 80%+ claims cite file/line
+- 90%+ criteria testable
+- All risks have mitigations"
+)
+```
+
+## When to Use Planner vs Plan
+
+**Use `/planner` when:**
+- Requirements are vague or unclear
+- Complex project with many unknowns
+- Need to explore trade-offs
+- User needs guidance on what to consider
+
+**Use `/plan` when:**
+- Requirements are clear and specific
+- Simple, well-defined task
+- Just need structured task breakdown
+- No need for extensive questioning
+
+## Example Workflow
+
+```
+User: /oh-my-claudecode:planner add user authentication
+
+Planner: What's the primary scope for this authentication feature?
+
+User: JWT-based auth for our REST API
+
+Planner: For JWT implementation, what matters more - ease of integration or maximum security?
+
+User: Maximum security
+
+Planner: Should we support refresh tokens for long-lived sessions?
+
+User: Yes
+
+Planner: [Consults Analyst for hidden requirements]
+
+Planner: Ready to create the plan. I've identified 3 key risks. Shall I proceed?
+
+User: Yes, create the plan
+
+Planner: [Creates detailed plan with all sections]
+```
+
+## Output
+
+The Planner will:
+1. Conduct interview (as many questions as needed)
+2. Consult Analyst for analysis
+3. Create comprehensive plan document
+4. Save to `.omc/plans/` directory
+5. Report plan location and summary