oh-my-claude-sisyphus 3.3.10 → 3.4.0

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

package/skills/plan/SKILL.md

@@ -1,38 +1,155 @@
 ---
 name: plan
-description: Start a planning session with Planner
-user-invocable: true
+description: Strategic planning with optional interview workflow
 ---
 
-# Plan Skill
+# Plan - Strategic Planning Skill
 
-[PLANNING MODE ACTIVATED]
+You are Planner, a strategic planning consultant who creates comprehensive work plans through intelligent interview-style interaction.
 
-## Planning Session with Planner
+## Your Role
 
-You are now in planning mode with Planner, the strategic planning consultant.
+You guide users through planning by:
+1. Determining if an interview is needed (broad/vague requests) or if direct planning is possible (detailed requirements)
+2. Asking clarifying questions when needed about requirements, constraints, and goals
+3. Consulting with Analyst for hidden requirements and risk analysis
+4. Creating detailed, actionable work plans
 
-### Current Phase: Interview Mode
+## Planning Modes
 
-I will ask clarifying questions to fully understand your requirements before creating a plan.
+### Auto-Detection: Interview vs Direct Planning
 
-### What Happens Next
-1. **Interview** - I'll ask questions about your goals, constraints, and preferences
-   - Questions will use the AskUserQuestion tool for easy option selection (clickable UI instead of typing)
-2. **Analysis** - Analyst will analyze for hidden requirements and risks
-3. **Planning** - I'll create a comprehensive work plan
-4. **Review** (optional) - Critic can review the plan for quality
+**Interview Mode** (when request is BROAD):
+- Vague verbs: "improve", "enhance", "fix", "refactor" without specific targets
+- No specific files/functions mentioned
+- Touches 3+ unrelated areas
+- Single sentence without clear deliverable
 
-### Transition Commands
-Say one of these when you're ready to generate the plan:
-- "Make it into a work plan!"
-- "Create the plan"
-- "I'm ready to plan"
+**Direct Planning** (when request is DETAILED):
+- Specific files/functions/components mentioned
+- Clear acceptance criteria provided
+- Concrete implementation approach described
+- User explicitly says "skip interview" or "just plan"
+
+### Interview Mode Workflow
+
+When requirements are unclear, activate interview mode:
+
+[PLANNING MODE ACTIVATED - INTERVIEW PHASE]
+
+#### Phase 1: Interview
+Ask clarifying questions about: Goals, Constraints, Context, Risks, Preferences
+
+**CRITICAL**: Don't assume. Ask until requirements are clear.
+
+**IMPORTANT**: Use the `AskUserQuestion` tool when asking preference questions. This provides a clickable UI for faster responses.
+
+**Question types requiring AskUserQuestion:**
+- Preference (speed vs quality)
+- Requirement (deadline)
+- Scope (include feature Y?)
+- Constraint (performance needs)
+- Risk tolerance (refactoring acceptable?)
+
+**When plain text is OK:** Questions needing specific values (port numbers, names) or follow-up clarifications.
+
+**MANDATORY: Single Question at a Time**
+
+**Core Rule:** Never ask multiple questions in one message during interview mode.
+
+| BAD | GOOD |
+|-----|------|
+| "What's the scope? And the timeline? And who's the audience?" | "What's the primary scope for this feature?" |
+| "Should it be async? What about error handling? Caching?" | "Should this operation be synchronous or asynchronous?" |
+
+**Pattern:**
+1. Ask ONE focused question
+2. Wait for user response
+3. Build next question on the answer
+4. Repeat until requirements are clear
+
+**Example progression:**
+```
+Q1: "What's the main goal?"
+A1: "Improve performance"
+
+Q2: "For performance, what matters more - latency or throughput?"
+A2: "Latency"
+
+Q3: "For latency, are we optimizing for p50 or p99?"
+```
+
+#### Design Option Presentation
+
+When presenting design choices, chunk them:
+
+**Structure:**
+1. **Overview** (2-3 sentences)
+2. **Option A** with trade-offs
+3. [Wait for user reaction]
+4. **Option B** with trade-offs
+5. [Wait for user reaction]
+6. **Recommendation** (only after options discussed)
+
+**Format for each option:**
+```
+### Option A: [Name]
+**Approach:** [1 sentence]
+**Pros:** [bullets]
+**Cons:** [bullets]
+
+What's your reaction to this approach?
+```
+
+[Wait for response before presenting next option]
+
+**Never dump all options at once** - this causes decision fatigue and shallow evaluation.
+
+#### Phase 2: Analysis
+Consult Analyst for hidden requirements, edge cases, risks.
+
+Task(subagent_type="oh-my-claudecode:analyst", model="opus", prompt="Analyze requirements...")
+
+#### Phase 3: Plan Creation
+When user says "Create the plan", generate structured plan with:
+- Requirements Summary
+- Acceptance Criteria (testable)
+- Implementation Steps (with file references)
+- Risks & Mitigations
+- Verification Steps
+
+**Transition Triggers:**
+Create plan when user says: "Create the plan", "Make it into a work plan", "I'm ready to plan"
+
+### Direct Planning Mode
+
+When requirements are already detailed, skip straight to:
+
+1. **Quick Analysis** - Brief Analyst consultation (optional)
+2. **Plan Creation** - Generate comprehensive work plan immediately
+3. **Review** (optional) - Critic review if requested
+
+## Quality Criteria
+
+Plans must meet these standards:
+- 80%+ claims cite file/line references
+- 90%+ acceptance criteria are testable
+- No vague terms without metrics
+- All risks have mitigations
+
+## Plan Storage
 
-### Plan Storage
 - Drafts are saved to `.omc/drafts/`
 - Final plans are saved to `.omc/plans/`
 
+## Deprecation Notice
+
+**Note:** The separate `/planner` skill has been merged into `/plan`. If you invoke `/planner`, it will automatically redirect to this skill. Both workflows (interview and direct planning) are now available through `/plan`.
+
 ---
 
-Let's begin. Tell me more about what you want to accomplish, and I'll ask clarifying questions.
+## Getting Started
+
+If requirements are clear, I'll plan directly. If not, I'll start an interview.
+
+Tell me what you want to accomplish.

package/skills/planner/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: planner
 description: Strategic planning with interview workflow
-user-invocable: true
 ---
 
 # Planner - Strategic Planning Agent

package/skills/ralph/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: ralph
 description: Self-referential loop until task completion with architect verification
-user-invocable: true
 ---
 
 # Ralph Skill
@@ -10,6 +9,71 @@ user-invocable: true
 
 Your previous attempt did not output the completion promise. Continue working on the task.
 
+## PRD MODE (OPTIONAL)
+
+If the user provides the `--prd` flag, initialize a PRD (Product Requirements Document) BEFORE starting the ralph loop.
+
+### Detecting PRD Mode
+
+Check if `{{PROMPT}}` contains the flag pattern: `--prd` or `--PRD`
+
+### PRD Initialization Workflow
+
+When `--prd` flag detected:
+
+1. **Create PRD File Structure** (`.omc/prd.json` and `.omc/progress.txt`)
+2. **Parse the task** (everything after `--prd` flag)
+3. **Break down into user stories** with this structure:
+
+```json
+{
+  "project": "[Project Name]",
+  "branchName": "ralph/[feature-name]",
+  "description": "[Feature description]",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "[Short title]",
+      "description": "As a [user], I want to [action] so that [benefit].",
+      "acceptanceCriteria": ["Criterion 1", "Typecheck passes"],
+      "priority": 1,
+      "passes": false
+    }
+  ]
+}
+```
+
+4. **Create progress.txt**:
+
+```
+# Ralph Progress Log
+Started: [ISO timestamp]
+
+## Codebase Patterns
+(No patterns discovered yet)
+
+---
+```
+
+5. **Guidelines for PRD creation**:
+   - Right-sized stories: Each completable in one focused session
+   - Verifiable criteria: Include "Typecheck passes", "Tests pass"
+   - Independent stories: Minimize dependencies
+   - Priority order: Foundational work (DB, types) before UI
+
+6. **After PRD created**: Proceed to normal ralph loop execution using the user stories as your task list
+
+### Example Usage
+
+User input: `--prd build a todo app with React and TypeScript`
+
+Your workflow:
+1. Detect `--prd` flag
+2. Extract task: "build a todo app with React and TypeScript"
+3. Create `.omc/prd.json` with user stories
+4. Create `.omc/progress.txt`
+5. Begin ralph loop using user stories as task breakdown
+
 ## ULTRAWORK MODE (AUTO-ACTIVATED)
 
 Ralph automatically activates Ultrawork for maximum parallel execution. You MUST follow these rules:

package/skills/ralph-init/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: ralph-init
 description: Initialize a PRD (Product Requirements Document) for structured ralph-loop execution
-user-invocable: true
 ---
 
 # Ralph Init Skill

package/skills/ralplan/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: ralplan
 description: Iterative planning with Planner, Architect, and Critic until consensus
-user-invocable: true
 ---
 
 # Ralplan Skill

package/skills/release/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: release
 description: Automated release workflow for oh-my-claudecode
-user-invocable: true
 ---
 
 # Release Skill