oh-my-claude-sisyphus 2.6.1 → 3.0.1

package/skills/ralplan/SKILL.md

@@ -0,0 +1,219 @@
+---
+name: ralplan
+description: Iterative planning with Planner, Architect, and Critic until consensus
+user-invocable: true
+---
+
+# Ralplan Skill
+
+## Overview
+
+Ralplan orchestrates three specialized agents—Planner, Architect, and Critic—in an iterative loop until consensus is reached on a comprehensive work plan. This skill ensures plans are strategically sound, architecturally valid, and thoroughly reviewed before execution.
+
+## The Planning Triad
+
+Three agents collaborate in structured phases to validate and refine work plans:
+
+| Agent | Role | Output |
+|-------|------|--------|
+| **Planner** | Strategic Planner | Creates/refines the work plan |
+| **Architect** | Strategic Advisor | Answers questions, validates architecture |
+| **Critic** | Ruthless Reviewer | Critiques and identifies gaps |
+
+## The Iteration Loop
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                       RALPLAN LOOP                              │
+│                                                                 │
+│    ┌──────────────┐                                             │
+│    │   PLANNER    │◄────────────────────────────────┐           │
+│    │   (Plans)    │                                 │           │
+│    └──────┬───────┘                                 │           │
+│           │                                         │           │
+│           ▼                                         │           │
+│    ┌──────────────┐     Questions?    ┌───────────┐ │           │
+│    │   Has open   │─────────────────► │ ARCHITECT │ │           │
+│    │  questions?  │                   │ (Advises) │ │           │
+│    └──────┬───────┘                   └─────┬─────┘ │           │
+│           │                                 │       │           │
+│           │ No questions                    │       │           │
+│           ▼                                 ▼       │           │
+│    ┌──────────────┐                  ┌──────────┐   │           │
+│    │    CRITIC    │◄─────────────────│ Answers  │   │           │
+│    │  (Reviews)   │                  └──────────┘   │           │
+│    └──────┬───────┘                                 │           │
+│           │                                         │           │
+│           ▼                                         │           │
+│    ┌──────────────┐     REJECT      ┌──────────────┐│           │
+│    │   Verdict?   │─────────────────►│  Feedback   ││           │
+│    └──────┬───────┘                  │ to Planner  │┘           │
+│           │                          └─────────────┘            │
+│           │ OKAY                                                │
+│           ▼                                                     │
+│    ┌──────────────────────────────────────────────────────────┐ │
+│    │                  PLAN APPROVED                           │ │
+│    │           Ready for /ralph execution                     │ │
+│    └──────────────────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## State Management
+
+Ralplan maintains persistent state in `.omc/ralplan-state.json` to track progress and enable recovery across interruptions:
+
+```json
+{
+  "active": true,
+  "mode": "ralplan",
+  "iteration": 1,
+  "max_iterations": 5,
+  "plan_path": ".omc/plans/[feature].md",
+  "current_phase": "planner_planning",
+  "started_at": "ISO-timestamp",
+  "task_description": "[original task]"
+}
+```
+
+**Phases**: `planner_planning` → `architect_consultation` → `critic_review` → `handling_verdict` → `complete`
+
+## Execution Protocol
+
+### Initialization
+
+The skill begins by establishing the planning environment:
+
+1. Create `.omc/plans/` directory if it doesn't exist
+2. Read task description from user input
+3. Create `ralplan-state.json` with initial values:
+   - `active: true`
+   - `iteration: 0`
+   - `max_iterations: 5`
+   - `current_phase: "planner_planning"`
+   - `started_at`: Current ISO timestamp
+   - `task_description`: User's task description
+
+### Planner Planning Phase
+
+The Planner creates an initial plan based on task context:
+
+- Invoke Planner in **direct planning mode** (bypassing interview since task context is pre-gathered)
+- Planner receives task context directly without preliminary questioning
+- Planner mandatorily consults with Metis for gap detection
+- Planner generates plan directly to `.omc/plans/[feature-name].md`
+- Plan includes: requirements summary, concrete acceptance criteria, specific implementation steps with file references, risk identification with mitigations, and verification steps
+- Signal completion with `PLAN_READY: .omc/plans/[filename].md`
+- Extract plan path from completion signal and update state
+
+### Architect Consultation (Conditional)
+
+The Architect provides strategic guidance in two scenarios:
+
+1. **After Planner**: If Planner raises architectural questions needing strategic input
+2. **After Critic rejection**: If Critic identifies questions requiring expert guidance
+
+When invoked, the Architect receives file paths to read for analysis, not summaries. This enables thorough examination of the existing codebase context before providing recommendations.
+
+### Critic Review
+
+The Critic examines the plan against quality standards:
+
+- Critic receives the plan file path (per its design)
+- Critic conducts thorough review of plan completeness and feasibility
+- Critic emits verdict: either `OKAY` (approval) or `REJECT` with specific issues
+
+### Verdict Handling and Iteration
+
+Based on Critic's verdict, the skill either approves the plan or continues iteration:
+
+**If verdict is OKAY:**
+- Mark plan as approved
+- Log approval with iteration count
+- Prepare plan for execution with `/ralph` or manual orchestration
+- Set state `active: false, current_phase: "complete"`
+
+**If verdict is REJECT:**
+- Extract Critic feedback with specific issues
+- Increment iteration counter
+- If `iteration >= max_iterations` (5):
+  - Force approval with warning about unresolved concerns
+  - Recommend manual review before execution
+- Otherwise:
+  - Feed Critic feedback back to Planner
+  - Return to Planner Planning phase for refinement
+
+## Iteration Rules
+
+| Rule | Description |
+|------|-------------|
+| **Max 5 iterations** | Safety limit prevents infinite loops |
+| **Planner owns plan** | Only Planner writes to plan file |
+| **Architect provides wisdom** | Architect reads and advises, never modifies |
+| **Critic has final say** | Plan approved only when Critic signals OKAY |
+| **Feedback is specific** | Each rejection includes actionable improvements |
+| **State persists** | Progress survives session interruptions |
+
+## Quality Gates
+
+The orchestrator must verify these gates before invoking Critic for each review:
+
+1. **Plan file exists** at the path specified in state
+2. **File references are valid** - Verify all mentioned files exist in codebase
+3. **Acceptance criteria are concrete** - No vague "improve" or "optimize" without measurable metrics
+4. **No ambiguous language** - Each task clearly specifies what to do
+
+If any gate fails, return to Planner with specific failure feedback for remediation.
+
+## Agent Communication Protocol
+
+### Planner to Architect Questions
+
+```
+ARCHITECT_QUESTION:
+- Topic: [Architecture/Performance/Security/Pattern]
+- Context: [What we're planning]
+- Files to examine: [specific paths]
+- Specific Question: [What we need answered]
+```
+
+### Architect to Planner Answers
+
+```
+ARCHITECT_ANSWER:
+- Topic: [Matching topic]
+- Analysis: [What Architect found after reading files]
+- Recommendation: [Specific guidance]
+- Trade-offs: [What to consider]
+- References: [file:line citations from codebase]
+```
+
+### Critic to Planner Feedback
+
+```
+CRITIC_FEEDBACK:
+- Verdict: REJECT
+- Critical Issues:
+  1. [Issue with specific fix required]
+  2. [Issue with specific fix required]
+- Minor Issues:
+  1. [Nice to fix]
+- Questions for Architect (if any):
+  1. [Architectural question needing expert input]
+```
+
+## Cancellation
+
+To stop an active ralplan session:
+
+- Use `/cancel-ralph` (automatically detects ralplan via state file)
+- Or manually delete `.omc/ralplan-state.json`
+
+## Skill Workflow
+
+1. **Initialize state** and log: `[RALPLAN Iteration 0/5] Initializing...`
+2. **Parse task** from user input
+3. **Spawn Planner** in direct planning mode
+4. **Iterate** through planning loop with observability logging at each phase
+5. **Complete** when Critic approves or max iterations reached with warnings
+
+The iterative loop refines the plan until it meets the rigorous standards of all three agents, ensuring comprehensive, architecturally sound work plans ready for execution.

package/skills/release/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: release
+description: Automated release workflow for oh-my-claudecode
+user-invocable: true
+---
+
+# Release Skill
+
+Automate the release process for oh-my-claudecode.
+
+## Usage
+
+```
+/release <version>
+```
+
+Example: `/release 2.4.0` or `/release patch` or `/release minor`
+
+## Release Checklist
+
+Execute these steps in order:
+
+### 1. Version Bump
+Update version in all locations:
+- `package.json`
+- `src/installer/index.ts` (VERSION constant)
+- `src/__tests__/installer.test.ts` (expected version)
+- `.claude-plugin/plugin.json`
+- `README.md` (version badge and title)
+
+### 2. Run Tests
+```bash
+npm run test:run
+```
+All 231+ tests must pass before proceeding.
+
+### 3. Commit Version Bump
+```bash
+git add -A
+git commit -m "chore: Bump version to <version>"
+```
+
+### 4. Create & Push Tag
+```bash
+git tag v<version>
+git push origin main
+git push origin v<version>
+```
+
+### 5. Publish to npm
+```bash
+npm publish --access public
+```
+
+### 6. Create GitHub Release
+```bash
+gh release create v<version> --title "v<version> - <title>" --notes "<release notes>"
+```
+
+### 7. Verify
+- [ ] npm: https://www.npmjs.com/package/oh-my-claudecode
+- [ ] GitHub: https://github.com/Yeachan-Heo/oh-my-claudecode/releases
+
+## Version Files Reference
+
+| File | Field/Line |
+|------|------------|
+| `package.json` | `"version": "X.Y.Z"` |
+| `src/installer/index.ts` | `export const VERSION = 'X.Y.Z'` |
+| `src/__tests__/installer.test.ts` | `expect(VERSION).toBe('X.Y.Z')` |
+| `.claude-plugin/plugin.json` | `"version": "X.Y.Z"` |
+| `README.md` | Title + version badge |
+
+## Semantic Versioning
+
+- **patch** (X.Y.Z+1): Bug fixes, minor improvements
+- **minor** (X.Y+1.0): New features, backward compatible
+- **major** (X+1.0.0): Breaking changes
+
+## Notes
+
+- Always run tests before publishing
+- Create release notes summarizing changes
+- Plugin marketplace syncs automatically from GitHub releases

package/skills/review/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: review
+description: Review a plan with Critic
+user-invocable: true
+---
+
+# Review Skill
+
+[PLAN REVIEW MODE ACTIVATED]
+
+## Role
+
+Critically evaluate plans using Critic. No plan passes without meeting rigorous standards.
+
+## Review Criteria
+
+| Criterion | Standard |
+|-----------|----------|
+| Clarity | 80%+ claims cite file/line |
+| Testability | 90%+ criteria are concrete |
+| Verification | All file refs exist |
+| Specificity | No vague terms |
+
+## Verdicts
+
+**APPROVED** - Plan meets all criteria, ready for execution
+**REVISE** - Plan has issues needing fixes (with specific feedback)
+**REJECT** - Fundamental problems require replanning
+
+## What Gets Checked
+
+1. Are requirements clear and unambiguous?
+2. Are acceptance criteria concrete and testable?
+3. Do file references actually exist?
+4. Are implementation steps specific?
+5. Are risks identified with mitigations?
+6. Are verification steps defined?

package/skills/ultraqa/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: ultraqa
+description: QA cycling workflow - test, verify, fix, repeat until goal met
+user-invocable: true
+---
+
+# UltraQA Skill
+
+[ULTRAQA ACTIVATED - AUTONOMOUS QA CYCLING]
+
+## Overview
+
+You are now in **ULTRAQA** mode - an autonomous QA cycling workflow that runs until your quality goal is met.
+
+**Cycle**: qa-tester → architect verification → fix → repeat
+
+## Goal Parsing
+
+Parse the goal from arguments. Supported formats:
+
+| Invocation | Goal Type | What to Check |
+|------------|-----------|---------------|
+| `/ultraqa --tests` | tests | All test suites pass |
+| `/ultraqa --build` | build | Build succeeds with exit 0 |
+| `/ultraqa --lint` | lint | No lint errors |
+| `/ultraqa --typecheck` | typecheck | No TypeScript errors |
+| `/ultraqa --custom "pattern"` | custom | Custom success pattern in output |
+
+If no structured goal provided, interpret the argument as a custom goal.
+
+## Cycle Workflow
+
+### Cycle N (Max 5)
+
+1. **RUN QA**: Execute verification based on goal type
+   - `--tests`: Run `npm test` or equivalent
+   - `--build`: Run `npm run build` or equivalent
+   - `--lint`: Run `npm run lint` or equivalent
+   - `--typecheck`: Run `npm run typecheck` or `tsc --noEmit`
+   - `--custom`: Run appropriate command and check for pattern
+   - `--interactive`: Use qa-tester for interactive CLI/service testing:
+     ```
+     Task(subagent_type="oh-my-claudecode:qa-tester", model="sonnet", prompt="TEST:
+     Goal: [describe what to verify]
+     Service: [how to start]
+     Test cases: [specific scenarios to verify]")
+     ```
+
+2. **CHECK RESULT**: Did the goal pass?
+   - **YES** → Exit with success message
+   - **NO** → Continue to step 3
+
+3. **ARCHITECT DIAGNOSIS**: Spawn architect to analyze failure
+   ```
+   Task(subagent_type="oh-my-claudecode:architect", model="opus", prompt="DIAGNOSE FAILURE:
+   Goal: [goal type]
+   Output: [test/build output]
+   Provide root cause and specific fix recommendations.")
+   ```
+
+4. **FIX ISSUES**: Apply architect's recommendations
+   ```
+   Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="FIX:
+   Issue: [architect diagnosis]
+   Files: [affected files]
+   Apply the fix precisely as recommended.")
+   ```
+
+5. **REPEAT**: Go back to step 1
+
+## Exit Conditions
+
+| Condition | Action |
+|-----------|--------|
+| **Goal Met** | Exit with success: "ULTRAQA COMPLETE: Goal met after N cycles" |
+| **Cycle 5 Reached** | Exit with diagnosis: "ULTRAQA STOPPED: Max cycles. Diagnosis: ..." |
+| **Same Failure 3x** | Exit early: "ULTRAQA STOPPED: Same failure detected 3 times. Root cause: ..." |
+| **Environment Error** | Exit: "ULTRAQA ERROR: [tmux/port/dependency issue]" |
+
+## Observability
+
+Output progress each cycle:
+```
+[ULTRAQA Cycle 1/5] Running tests...
+[ULTRAQA Cycle 1/5] FAILED - 3 tests failing
+[ULTRAQA Cycle 1/5] Architect diagnosing...
+[ULTRAQA Cycle 1/5] Fixing: auth.test.ts - missing mock
+[ULTRAQA Cycle 2/5] Running tests...
+[ULTRAQA Cycle 2/5] PASSED - All 47 tests pass
+[ULTRAQA COMPLETE] Goal met after 2 cycles
+```
+
+## State Tracking
+
+Track state in `.omc/ultraqa-state.json`:
+```json
+{
+  "active": true,
+  "goal_type": "tests",
+  "goal_pattern": null,
+  "cycle": 1,
+  "max_cycles": 5,
+  "failures": ["3 tests failing: auth.test.ts"],
+  "started_at": "2024-01-18T12:00:00Z",
+  "session_id": "uuid"
+}
+```
+
+## Cancellation
+
+User can cancel with `/cancel-ultraqa` which clears the state file.
+
+## Important Rules
+
+1. **PARALLEL when possible** - Run diagnosis while preparing potential fixes
+2. **TRACK failures** - Record each failure to detect patterns
+3. **EARLY EXIT on pattern** - 3x same failure = stop and surface
+4. **CLEAR OUTPUT** - User should always know current cycle and status
+5. **CLEAN UP** - Clear state file on completion or cancellation
+
+---
+
+Begin ULTRAQA cycling now. Parse the goal and start cycle 1.

package/skills/ultrawork/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: ultrawork
+description: Activate maximum performance mode with parallel agent orchestration for high-throughput task completion
+user-invocable: true
+---
+
+# Ultrawork Skill
+
+Activates maximum performance mode with parallel agent orchestration.
+
+## When Activated
+
+This skill enhances Claude's capabilities by:
+
+1. **Parallel Execution**: Running multiple agents simultaneously for independent tasks
+2. **Aggressive Delegation**: Routing tasks to specialist agents immediately
+3. **Background Operations**: Using `run_in_background: true` for long operations
+4. **Persistence Enforcement**: Never stopping until all tasks are verified complete
+5. **Smart Model Routing**: Using tiered agents to save tokens
+
+## Smart Model Routing (CRITICAL - SAVE TOKENS)
+
+**Choose tier based on task complexity: LOW (haiku) → MEDIUM (sonnet) → HIGH (opus)**
+
+### Available Agents by Tier
+
+| Domain | LOW (Haiku) | MEDIUM (Sonnet) | HIGH (Opus) |
+|--------|-------------|-----------------|-------------|
+| **Analysis** | `architect-low` | `architect-medium` | `architect` |
+| **Execution** | `executor-low` | `executor` | `executor-high` |
+| **Search** | `explore` | `explore-medium` | - |
+| **Research** | `researcher-low` | `researcher` | - |
+| **Frontend** | `designer-low` | `designer` | `designer-high` |
+| **Docs** | `writer` | - | - |
+| **Visual** | - | `vision` | - |
+| **Planning** | - | - | `planner`, `critic`, `analyst` |
+| **Testing** | - | `qa-tester` | - |
+
+### Tier Selection Guide
+
+| Task Complexity | Tier | Examples |
+|-----------------|------|----------|
+| Simple lookups | LOW | "What does this function return?", "Find where X is defined" |
+| Standard work | MEDIUM | "Add error handling", "Implement this feature" |
+| Complex analysis | HIGH | "Debug this race condition", "Refactor auth module across 5 files" |
+
+### Routing Examples
+
+**CRITICAL: Always pass `model` parameter explicitly - Claude Code does NOT auto-apply models from agent definitions!**
+
+```
+// Simple question → LOW tier (saves tokens!)
+Task(subagent_type="architect-low", model="haiku", prompt="What does this function return?")
+
+// Standard implementation → MEDIUM tier
+Task(subagent_type="executor", model="sonnet", prompt="Add error handling to login")
+
+// Complex refactoring → HIGH tier
+Task(subagent_type="executor-high", model="opus", prompt="Refactor auth module using JWT across 5 files")
+
+// Quick file lookup → LOW tier
+Task(subagent_type="explore", model="haiku", prompt="Find where UserService is defined")
+
+// Thorough search → MEDIUM tier
+Task(subagent_type="explore-medium", model="sonnet", prompt="Find all authentication patterns in the codebase")
+```
+
+## Background Execution Rules
+
+**Run in Background** (set `run_in_background: true`):
+- Package installation: npm install, pip install, cargo build
+- Build processes: npm run build, make, tsc
+- Test suites: npm test, pytest, cargo test
+- Docker operations: docker build, docker pull
+
+**Run Blocking** (foreground):
+- Quick status checks: git status, ls, pwd
+- File reads, edits
+- Simple commands
+
+## Verification Checklist
+
+Before stopping, verify:
+- [ ] TODO LIST: Zero pending/in_progress tasks
+- [ ] FUNCTIONALITY: All requested features work
+- [ ] TESTS: All tests pass (if applicable)
+- [ ] ERRORS: Zero unaddressed errors
+
+**If ANY checkbox is unchecked, CONTINUE WORKING.**