oh-my-claude-sisyphus 3.3.10 → 3.4.1

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

package/commands/ralplan.md

@@ -1,8 +1,15 @@
 ---
 description: Iterative planning with Planner, Architect, and Critic until consensus
+aliases: [rp, planloop]
 ---
 
-# Ralplan Skill
+# Ralplan Command
+
+[RALPLAN ACTIVATED - ITERATIVE PLANNING CONSENSUS MODE]
+
+## User's Task
+
+{{ARGUMENTS}}
 
 ## Overview
 

package/commands/swarm.md

@@ -0,0 +1,280 @@
+---
+description: N coordinated agents with atomic task claiming from shared pool
+aliases: [swarm-agents]
+---
+
+# Swarm Command
+
+[SWARM MODE ACTIVATED]
+
+Spawn N coordinated agents working on a shared task list with atomic claiming. Like a dev team tackling multiple files in parallel.
+
+## User's Request
+
+{{ARGUMENTS}}
+
+## Usage Pattern
+
+```
+/oh-my-claudecode:swarm N:agent-type "task description"
+```
+
+### Parameters
+
+- **N** - Number of agents (1-5, enforced by Claude Code limit)
+- **agent-type** - Agent to spawn (executor, build-fixer, designer, etc.)
+- **task** - High-level task to decompose and distribute
+
+### Examples
+
+```
+/oh-my-claudecode:swarm 5:executor "fix all TypeScript errors"
+/oh-my-claudecode:swarm 3:build-fixer "fix build errors in src/"
+/oh-my-claudecode:swarm 4:designer "implement responsive layouts for all components"
+/oh-my-claudecode:swarm 2:architect "analyze and document all API endpoints"
+```
+
+## How It Works
+
+```
+User: /swarm 5:executor "fix all TypeScript errors"
+              |
+              v
+      [SWARM ORCHESTRATOR]
+              |
+   +--+--+--+--+--+
+   |  |  |  |  |
+   v  v  v  v  v
+  E1 E2 E3 E4 E5
+   |  |  |  |  |
+   +--+--+--+--+
+          |
+          v
+   [SHARED TASK LIST]
+   - Fix a.ts (claimed E1)
+   - Fix b.ts (done E2)
+   - Fix c.ts (claimed E3)
+   - Fix d.ts (pending)
+   ...
+```
+
+## Workflow
+
+### 1. Parse Input
+
+From `{{ARGUMENTS}}`, extract:
+- N (agent count, validate <= 5)
+- agent-type (executor, build-fixer, etc.)
+- task description
+
+### 2. Create Task List
+
+1. Analyze codebase based on task
+2. Break into file-specific subtasks
+3. Initialize `.omc/state/swarm-tasks.json` with all subtasks
+4. Each task gets: id, file, description, status, owner, timestamp
+
+### 3. Spawn Agents
+
+Launch N agents via Task tool:
+- Set `run_in_background: true` for all
+- Each agent receives:
+  - Reference to shared task list
+  - Claiming protocol instructions
+  - Completion criteria
+
+### 4. Task Claiming Protocol
+
+Each agent follows this loop:
+
+```
+LOOP:
+  1. Read swarm-tasks.json
+  2. Find first task with status="pending"
+  3. Atomically claim task (set status="claimed", add owner, timestamp)
+  4. Execute task
+  5. Mark task as "done"
+  6. GOTO LOOP (until no pending tasks)
+```
+
+**Atomic Claiming:**
+- Read current task status
+- If "pending", claim it (set owner, timeout)
+- If already claimed, try next task
+- Timeout: 5 minutes per task
+- Timed-out tasks auto-release to "pending"
+
+### 5. Progress Tracking
+
+Orchestrator monitors via TaskOutput:
+- Shows live stats: claimed/done/pending counts
+- Reports which agent is working on which file
+- Detects idle agents (no pending tasks)
+
+### 6. Completion
+
+Exit when:
+- All tasks marked "done"
+- All agents idle (no pending tasks)
+- User cancels via `/cancel`
+
+## State Files
+
+### `.omc/swarm-state.json`
+Session-level state:
+
+```json
+{
+  "session_id": "swarm-20260124-143022",
+  "agent_count": 5,
+  "agent_type": "executor",
+  "task_description": "fix all TypeScript errors",
+  "status": "active",
+  "started_at": "2026-01-24T14:30:22Z",
+  "agents": [
+    {"id": "agent-1", "background_task_id": "task_abc", "status": "working"},
+    {"id": "agent-2", "background_task_id": "task_def", "status": "working"}
+  ]
+}
+```
+
+### `.omc/state/swarm-tasks.json`
+Shared task list:
+
+```json
+{
+  "tasks": [
+    {
+      "id": "task-001",
+      "file": "src/utils/validation.ts",
+      "description": "Fix type errors in validation helpers",
+      "status": "claimed",
+      "owner": "agent-1",
+      "claimed_at": "2026-01-24T14:30:25Z",
+      "timeout_at": "2026-01-24T14:35:25Z"
+    },
+    {
+      "id": "task-002",
+      "file": "src/components/Header.tsx",
+      "description": "Fix missing prop types",
+      "status": "done",
+      "owner": "agent-2",
+      "claimed_at": "2026-01-24T14:30:26Z",
+      "completed_at": "2026-01-24T14:32:15Z"
+    },
+    {
+      "id": "task-003",
+      "file": "src/api/client.ts",
+      "description": "Add return type annotations",
+      "status": "pending",
+      "owner": null
+    }
+  ],
+  "stats": {
+    "total": 15,
+    "pending": 8,
+    "claimed": 5,
+    "done": 2
+  }
+}
+```
+
+## Agent Instructions Template
+
+Each spawned agent receives:
+
+```markdown
+You are agent {id} in a swarm of {N} {agent-type} agents.
+
+**Your Task:** {task_description}
+
+**Shared Task List:** .omc/state/swarm-tasks.json
+
+**Your Loop:**
+1. Read swarm-tasks.json
+2. Find first task with status="pending"
+3. Claim it atomically (set status="claimed", owner="{id}", timeout)
+4. Execute the task
+5. Mark status="done", set completed_at
+6. Repeat until no pending tasks
+
+**Claiming Protocol:**
+- Read file, check status="pending"
+- Update status="claimed", add your ID
+- Set timeout_at = now + 5 minutes
+- Write file back
+- If file changed between read/write, retry
+
+**Completion:**
+When no pending tasks remain, exit cleanly.
+```
+
+## Constraints
+
+- **Max Agents:** 5 (Claude Code background task limit)
+- **Claim Timeout:** 5 minutes per task
+- **Auto-Release:** Timed-out claims automatically released
+- **Heartbeat:** Recommended every 60 seconds
+
+## Error Handling
+
+- **Agent Crash:** Task auto-releases after timeout
+- **State Corruption:** Orchestrator validates and repairs
+- **No Pending Tasks:** Agent exits cleanly
+- **All Agents Idle:** Orchestrator concludes session
+
+## Cancellation
+
+Use unified cancel command:
+```
+/oh-my-claudecode:cancel
+```
+
+This:
+- Stops orchestrator monitoring
+- Signals all background agents to exit
+- Preserves partial progress in swarm-tasks.json
+- Marks session as "cancelled"
+
+## Use Cases
+
+### Fix All Type Errors
+```
+/swarm 5:executor "fix all TypeScript type errors"
+```
+Spawns 5 executors, each claiming and fixing individual files.
+
+### Implement UI Components
+```
+/swarm 3:designer "implement Material-UI styling for all components"
+```
+Spawns 3 designers, each styling different component files.
+
+### Security Audit
+```
+/swarm 4:security-reviewer "review all API endpoints for vulnerabilities"
+```
+Spawns 4 security reviewers, each auditing different endpoints.
+
+### Documentation Sprint
+```
+/swarm 2:writer "add JSDoc comments to all exported functions"
+```
+Spawns 2 writers, each documenting different modules.
+
+## Benefits
+
+- **Parallel Execution:** N agents work simultaneously
+- **Auto-Balancing:** Fast agents claim more tasks
+- **Fault Tolerance:** Timeouts prevent deadlocks
+- **Progress Visibility:** Live stats on claimed/done/pending
+- **Scalable:** Works for 10s to 100s of subtasks
+
+## Output
+
+Report when complete:
+- Total tasks completed
+- Tasks per agent (performance comparison)
+- Total time elapsed
+- Final verification status
+- Summary of changes made

package/commands/ultrapilot.md

@@ -0,0 +1,158 @@
+---
+description: Parallel autopilot with file ownership partitioning (up to 5x faster)
+aliases: [up, ultraauto, parallelauto]
+---
+
+# Ultrapilot Command
+
+[ULTRAPILOT ACTIVATED - PARALLEL AUTONOMOUS EXECUTION MODE]
+
+You are now in ULTRAPILOT mode. This is a parallel autopilot that spawns multiple workers with file ownership partitioning for maximum speed.
+
+## User's Task
+
+{{ARGUMENTS}}
+
+## Your Mission
+
+Transform this task into working code through parallel execution:
+
+1. **Analysis** - Determine if task is parallelizable
+2. **Decomposition** - Break into parallel-safe subtasks with file partitioning
+3. **Parallel Execution** - Spawn up to 5 workers with exclusive file ownership
+4. **Integration** - Handle shared files sequentially
+5. **Validation** - Full system integrity check
+
+## Phase 0: Task Analysis
+
+Determine if task is suitable for parallel execution:
+
+**Parallelizable if:**
+- Can be split into 2+ independent subtasks
+- File boundaries are clear
+- Dependencies between subtasks are minimal
+
+**If NOT parallelizable:** Fall back to regular `/oh-my-claudecode:autopilot`
+
+## Phase 1: Decomposition
+
+Break task into parallel-safe subtasks:
+
+1. Identify independent components (e.g., frontend, backend, database, tests)
+2. Map each subtask to a non-overlapping file set
+3. Identify shared files (package.json, tsconfig.json) for sequential handling
+4. Create task list with clear ownership
+
+**Output:** Subtask definitions with file ownership assignments
+
+## Phase 2: File Partitioning
+
+Create exclusive ownership map:
+
+```
+Worker 1: src/api/**     (exclusive)
+Worker 2: src/ui/**      (exclusive)
+Worker 3: src/db/**      (exclusive)
+Worker 4: docs/**        (exclusive)
+Worker 5: tests/**       (exclusive)
+SHARED:   package.json, tsconfig.json (sequential)
+```
+
+**Rule:** No two workers can touch the same files
+
+## Phase 3: Parallel Execution
+
+Spawn workers using Task tool with `run_in_background: true`:
+
+```
+Task(
+  subagent_type="oh-my-claudecode:executor",
+  model="sonnet",
+  run_in_background=true,
+  prompt="ULTRAPILOT WORKER [1/5]
+
+OWNED FILES: src/api/**
+TASK: [specific subtask]
+
+You have EXCLUSIVE ownership of these files.
+DO NOT touch files outside your ownership.
+Signal WORKER_COMPLETE when done."
+)
+```
+
+**Critical Rules:**
+- Maximum 5 parallel workers (Claude Code limit)
+- Each worker owns exclusive file set
+- Monitor via TaskOutput
+- Handle failures by reassigning or fixing
+
+## Phase 4: Integration
+
+After all workers complete:
+
+1. Handle shared files (package.json, configs) sequentially
+2. Resolve any integration issues
+3. Ensure all pieces work together
+
+## Phase 5: Validation
+
+Spawn Architect for full system verification:
+
+```
+Task(
+  subagent_type="oh-my-claudecode:architect",
+  model="opus",
+  prompt="ULTRAPILOT VALIDATION
+
+Verify the complete implementation:
+1. All subtasks completed successfully
+2. No integration conflicts
+3. System works as a whole
+4. Tests pass (if applicable)"
+)
+```
+
+## Delegation Rules (MANDATORY)
+
+**YOU ARE A COORDINATOR, NOT AN IMPLEMENTER.**
+
+| Action | YOU Do | DELEGATE |
+|--------|--------|----------|
+| Decompose task | ✓ | |
+| Partition files | ✓ | |
+| Spawn workers | ✓ | |
+| Track progress | ✓ | |
+| **ANY code change** | ✗ NEVER | executor workers |
+
+**Path Exception**: Only write to `.omc/`, `.claude/`, `CLAUDE.md`, `AGENTS.md`
+
+## State Management
+
+Track state in `.omc/ultrapilot-state.json`:
+
+```json
+{
+  "active": true,
+  "mode": "ultrapilot",
+  "workers": [
+    {"id": "w1", "status": "running", "files": ["src/api/**"], "task_id": "..."},
+    {"id": "w2", "status": "complete", "files": ["src/ui/**"], "task_id": "..."}
+  ],
+  "shared_files": ["package.json", "tsconfig.json"],
+  "phase": "parallel_execution"
+}
+```
+
+## Completion
+
+When all phases complete and Architect validates:
+
+```
+<promise>ULTRAPILOT_COMPLETE</promise>
+```
+
+Display summary with:
+- Time savings vs sequential
+- Workers spawned
+- Files modified per worker
+- Final validation status

package/commands/ultrawork.md

@@ -1,5 +1,6 @@
 ---
 description: Activate maximum performance mode with parallel agent orchestration for high-throughput task completion
+aliases: [ulw, uw, turbo]
 ---
 
 # Ultrawork Skill

package/dist/__tests__/delegation-enforcer-integration.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Integration tests for delegation enforcer
+ * Tests the entire flow from hook input to modified output
+ */
+export {};
+//# sourceMappingURL=delegation-enforcer-integration.test.d.ts.map

package/dist/__tests__/delegation-enforcer-integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation-enforcer-integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/delegation-enforcer-integration.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}