diff --git a/README.md b/README.md
index c9248db6..a3c98db5 100644
--- a/README.md
+++ b/README.md
@@ -1,913 +1,316 @@
-# SuperCharged Claude Code - Ultimate Upgrade Package
-
-> 🚀 Transform your Claude Code into an autonomous AI development powerhouse with **280 custom skills**, autonomous agents, multi-framework integration, and Z.AI GLM model support. **v2.0.0 - Framework Integration Edition**.
-
-[](https://claude.com/claude-code)
-[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
-[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
-[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
-[](LICENSE)
-[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
-
-## ⚡ Quick Installation
-
-### Linux / macOS (Bash)
-```bash
-# Clone the repository
-git clone https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade.git
-cd SuperCharged-Claude-Code-Upgrade
-
-# 🎯 Run the installer
-./supercharge.sh
-```
-
-### Windows Installation Options
-
-> **⚠️ Windows Users:** The PowerShell installer is **experimental** and may have bugs. We strongly recommend using **WSL** (Option 2) for a reliable installation experience.
-
-#### Option 1: PowerShell Installer ⚠️ **Experimental - Use WSL Instead**
-```powershell
-# Download and run the native PowerShell installer
-irm https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/branch/main/install-windows.ps1 | pwsh -ExecutionPolicy Bypass -
-
-# OR download and run manually
-Invoke-WebRequest -Uri "https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/branch/main/install-windows.ps1" -OutFile "install-windows.ps1"
-pwsh -ExecutionPolicy Bypass -File install-windows.ps1
-
-# OR right-click install-windows.ps1 and select "Run with PowerShell"
-```
-
-#### Option 2: WSL (Windows Subsystem for Linux) ⭐ **Recommended**
-```bash
-# Clone and run in WSL
-wsl bash -c "git clone https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade.git && cd SuperCharged-Claude-Code-Upgrade && ./supercharge.sh"
-```
-
-#### Option 3: Git Bash
-```bash
-# Clone the repository
-git clone https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade.git
-cd SuperCharged-Claude-Code-Upgrade
-
-# Run the installer
-./supercharge.sh
-```
-
-#### Option 4: Manual Download
-```powershell
-# 1. Download and extract the ZIP from:
-# https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/archive/refs/heads/main.zip
-
-# 2. Open PowerShell and navigate to extracted folder
-cd path\to\SuperCharged-Claude-Code-Upgrade
-
-# 3. Run the installer
-pwsh -ExecutionPolicy Bypass -File install-windows.ps1
-```
-
-> **📝 Note:** The PowerShell installer (Option 1) downloads everything automatically. For bash/WSL options, you must clone the repository first since the script needs access to local files.
-
----
-
-## ⚡ Why SuperCharge Claude Code?
-
-**Claude Code is powerful. SuperCharge makes it unstoppable.**
-
-This comprehensive customization package transforms your Claude Code installation with:
-
-- ✨ **280 Custom Skills** - Cognitive enhancement, development workflows, UI/UX intelligence, desktop development
-- 🤖 **43 Autonomous Agents** - RalphLoop "Tackle Until Solved" + 39 specialized agents
-- 🔥 **5 Framework Integration** - Chippery, OpenAgentsControl, AGIAgent, Agno, OS-Copilot
-- 🌐 **Z.AI API Integration** - GLM-4.5-air and GLM-4.7 model support with 10% OFF discount
-- 🔌 **MCP Servers** - Image analysis, web search, GitHub integration built-in
-- 🎯 **Agent Management** - Complete library with sync capabilities
-- 🪝 **Smart Hooks** - Session automation and multi-AI consultation
-- 🚀 **Auto-Trigger System** - Intelligent component routing with pattern matching
-- 💻 **Tauri Framework** - Build tiny, fast, secure desktop & mobile apps with Rust
-
-**Perfect for:** Developers, AI enthusiasts, teams building with AI assistants, and anyone wanting to maximize their Claude Code productivity.
-
-## 🆕 What's New in v2.0.0
-
-### Framework Integration
-Integrated 5 open-source agent frameworks into Claude Code CLI:
-
-| Framework | Capability | Benefit |
-|-----------|-----------|---------|
-| **Chippery** | Smart codebase indexing | 40-60% token reduction via semantic search |
-| **OpenAgentsControl** | Plan-first workflow | 6-stage approval process for safety |
-| **AGIAgent** | Document generation + MCP | Rich docs (PDF/HTML/DOCX) + 100+ tools |
-| **Agno** | Multi-agent orchestration | Parallel execution, A2A communication |
-| **OS-Copilot** | Self-improvement | Learning from completed tasks |
-
-### New Skills (4)
-- `auto-dispatcher` - Intelligent component routing
-- `autonomous-planning` - Task decomposition
-- `codebase-indexer` - Semantic codebase search
-- `mcp-client` - MCP protocol client
-
-### New Agents (4)
-- `plan-executor.md` - Plan-first approval workflow
-- `orchestrator.md` - Multi-agent orchestration
-- `self-learner.md` - Self-improvement agent
-- `document-generator.md` - Document generation agent
-
----
-
-## 🎯 What Gets Installed
-
-### 🧠 Cognitive Skills
-| Skill | Purpose |
-|-------|---------|
-| `always-use-superpowers` | Auto-applies relevant skills before any action (Priority: 9999) |
-| `cognitive-core` | Core cognitive processing framework |
-| `cognitive-planner` | Strategic planning and architecture design |
-| `cognitive-safety` | Security validation and best practices |
-
-### 🤖 Autonomous Agents
-| Agent | Capability |
-|-------|------------|
-| **RalphLoop** | Iterates autonomously until task completion |
-| **Brainstorming** | Multi-AI collaborative ideation |
-| **Test-Driven Development** | Automated TDD workflow |
-| **Systematic Debugging** | Step-by-step bug resolution |
-| **Verification** | Pre-completion validation checks |
-
-### 🎨 Development Tools
-| Tool | Features |
-|------|----------|
-| `ui-ux-pro-max` | 50 styles, 21 palettes, 50 font pairings |
-| `agent-pipeline-builder` | Multi-agent workflow construction |
-| `dispatching-parallel-agents` | Concurrent agent execution |
-| `finishing-a-development-branch` | PR and merge automation |
-| `tauri` | Cross-platform desktop & mobile apps with Rust backend |
-
-### 🌐 Integrations
-- **Z.AI GLM Models** - glm-4.5-air (fast), glm-4.7 (powerful)
-- **Qwen Consultation** - Get second opinions from Qwen models
-- **Dev-Browser** - Persistent browser automation
-- **MCP Servers** - Vision, search, web reader, GitHub
-
-### 📁 Installation Structure
-```
-~/.claude/
-├── skills/ # 270+ custom skills
-├── agents/ # 100+ agent library
-├── hooks/ # Session automation
-├── commands/ # Custom commands
-├── plugins/ # MCP servers & integrations
-└── settings.json # Z.AI API configuration
-
-~/.local/bin/
-└── ralphloop # Ralph Orchestrator wrapper
-```
-
----
-
-## 📖 Detailed Installation Guide
-
-### 🎯 SuperCharge Installer (Main Script)
-
-#### One-Line Installation
-
-**Linux / macOS:**
-```bash
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash
-```
-
-**Windows (WSL/Git Bash):**
-```bash
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash
-```
-
-#### One-Line with Options
-
-**Linux / macOS:**
-```bash
-# Skip dependency installation
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash -s -- --skip-deps
-
-# Development mode (verbose output)
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash -s -- --dev-mode
-```
-
-**Windows (WSL/Git Bash):**
-```bash
-# Skip dependency installation
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash -s -- --skip-deps
-
-# Development mode (verbose output)
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash -s -- --dev-mode
-```
-
-#### Manual Installation
-
-**All Platforms (requires bash):**
-```bash
-# Clone the repository
-git clone https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade.git
-cd SuperCharged-Claude-Code-Upgrade
-
-# Run the supercharge installer
-bash supercharge.sh
-
-# With options
-bash supercharge.sh --skip-deps
-bash supercharge.sh --dev-mode
-```
-
-> **🪟 Windows Users:** Use WSL, Git Bash, or run `wsl bash script.sh` after downloading.
-
-### 🔧 Claude Code + Z.AI Installer (Optional)
-
-#### One-Line Installation
-
-**Linux / macOS:**
-```bash
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/install-claude-code.sh | bash
-```
-
-**Windows (WSL/Git Bash):**
-```bash
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/install-claude-code.sh | bash
-```
-
-#### One-Line with Options
-
-**Linux / macOS / Windows (WSL/Git Bash):**
-```bash
-# Automatic installation (prompts for API key)
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/install-claude-code.sh | bash -s -- --auto
-
-# Manual instructions only (no installation)
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/install-claude-code.sh | bash -s -- --manual
-
-# Configure API only (skip Claude Code installation)
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/install-claude-code.sh | bash -s -- --skip-install
-```
-
-#### Manual Installation
-
-**All Platforms (requires bash):**
-```bash
-# Clone the repository
-git clone https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade.git
-cd SuperCharged-Claude-Code-Upgrade
-
-# Run the Claude Code installer
-bash install-claude-code.sh --auto
-
-# Other options
-bash install-claude-code.sh --manual # Show instructions only
-bash install-claude-code.sh --skip-install # Configure API only
-```
-
----
-
-## 📋 Available Scripts & Options
-
-### supercharge.sh - Main SuperCharge Installer
-Transforms existing Claude Code with all customizations.
-
-| Option | Description |
-|--------|-------------|
-| (default) | Interactive installation with all prompts |
-| `--skip-deps` | Skip dependency installation checks |
-| `--dev-mode` | Enable verbose output for debugging |
-
-**One-liners (Linux / macOS / Windows WSL):**
-```bash
-# Full installation
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash
-
-# Skip dependencies
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash -s -- --skip-deps
-
-# Verbose mode
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/supercharge.sh | bash -s -- --dev-mode
-```
-
-### install-claude-code.sh - Claude Code + Z.AI Installer
-Installs Claude Code and configures Z.AI GLM models or Anthropic API.
-
-**New Features:**
-- 🔀 **Provider Switching** - Switch between Anthropic and Z.AI APIs
-- 🔑 **API Key Update** - Update existing API keys easily
-- 🧩 **Coding-Helper Addons** - Optional Z.AI coding-helper installation
-
-| Option | Description |
-|--------|-------------|
-| `--auto` (default) | Automated installation with provider selection |
-| `--manual` | Show manual installation steps only |
-| `--skip-install` | Skip Claude Code install, configure API only |
-
-**One-liners:**
-```bash
-# Auto install with provider selection
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/install-claude-code.sh | bash
-
-# Show manual instructions
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/install-claude-code.sh | bash -s -- --manual
-
-# Configure API only (skip Claude Code install)
-curl -fsSL https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/raw/main/install-claude-code.sh | bash -s -- --skip-install
-```
-
-**Provider Switching:**
-If Claude Code is already installed, the script will:
-1. Detect your current API provider (Anthropic or Z.AI)
-2. Offer to switch between providers
-3. Allow you to update your API key
-4. Optionally install Z.AI coding-helper addons
-
-**Z.AI Coding-Helper Features:**
-- Interactive wizard for easy setup
-- Multi-tool management (Claude Code, OpenCode, etc.)
-- MCP service configuration
-- API key management for Global and China plans
-- Bilingual interface (English/Chinese)
-
----
-
-## 🔧 Claude Code Installation Details
-
-If you don't have Claude Code installed yet, we've got you covered with **Z.AI API support**.
-
-### What is Z.AI API?
-
-[Z.AI](https://docs.z.ai/devpack/tool/claude) provides GLM (General Language Model) models optimized for Claude Code:
-
-- **glm-4.5-air** - Fast, efficient model (Haiku class) - ideal for quick iterations
-- **glm-4.7** - Powerful model (Sonnet/Opus class) - for complex tasks
-
-> [!TIP]
-> **🎁 Grab 10% OFF Token for z.ai coding plan**: [https://z.ai/subscribe?ic=R0K78RJKNW](https://z.ai/subscribe?ic=R0K78RJKNW)
-
-### Manual Claude Code Installation
-
-```bash
-# 1. Install Claude Code via npm
-npm install -g @anthropic-ai/claude-code
-
-# 2. Configure Z.AI API in ~/.claude/settings.json:
-{
- "env": {
- "ANTHROPIC_API_KEY": "your-zai-api-key-here",
- "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
- "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.7",
- "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.7"
- }
-}
-
-# 3. Start Claude Code
-claude
-
-# 4. Check model status
-/status
-```
-
-### Documentation
-- **Z.AI Official Docs**: https://docs.z.ai/devpack/tool/claude
-- **Claude Code Docs**: https://docs.anthropic.com/en/docs/claude-code/overview
-
----
-
-## 💡 Usage Examples
-
-### RalphLoop - Autonomous Agent
-
-```bash
-# Let Ralph tackle complex problems autonomously
-claude
-> /ralph "Design a microservices architecture for an e-commerce platform"
-
-# Ralph iterates until completion:
-# - Creates .ralph/PROMPT.md with success criteria
-# - Iterates continuously until all criteria met
-# - Updates .ralph/state.json with progress
-# - Outputs final result to .ralph/iterations/final.md
-```
-
-**Configuration:**
-```bash
-export RALPH_AGENT=claude # Agent selection
-export RALPH_MAX_ITERATIONS=100 # Max iterations
-export RALPH_MAX_RUNTIME=14400 # 4 hours
-export RALPH_VERBOSE=true # Debug output
-```
-
-### Multi-AI Brainstorming
-
-```bash
-> /brainstorming "Create a viral TikTok marketing strategy"
-
-# Collaborates with multiple AI perspectives:
-# - Content strategist (copy & messaging)
-# - SEO expert (keywords & optimization)
-# - Social media manager (platforms & tactics)
-# - Product manager (goals & metrics)
-# - Developer (implementation)
-```
-
-### Test-Driven Development
-
-```bash
-> /test-driven-development "Implement user authentication"
-
-# Automated TDD workflow:
-# 1. Write failing tests
-# 2. Implement minimal code
-# 3. Refactor while tests green
-```
-
-### Systematic Debugging
-
-```bash
-> /systematic-debugging "Database connection timing out"
-
-# Step-by-step resolution:
-# 1. Gather error information
-# 2. Form hypotheses
-# 3. Test each hypothesis
-# 4. Verify fix doesn't break functionality
-```
-
----
-
-## 🎨 UI/UX Intelligence
-
-The `ui-ux-pro-max` skill provides comprehensive design capabilities:
-
-### 50 Design Styles
-Glassmorphism, Claymorphism, Neumorphism, Brutalism, Minimalism, Bento Grid, Dark Mode, Skeuomorphism, Flat Design, and more...
-
-### 21 Color Palettes
-Pre-configured themes for instant visual consistency
-
-### 50 Font Pairings
-Typographic combinations proven to work well together
-
-### 9 Tech Stacks
-React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui
-
----
-
-## ⚙️ Configuration
-
-### Environment Variables
-
-```bash
-# Ralph Configuration
-export RALPH_AGENT=claude # claude|gemini|kiro|q|auto
-export RALPH_MAX_ITERATIONS=100 # Maximum iterations
-export RALPH_MAX_RUNTIME=14400 # Max runtime (4 hours)
-
-# Qwen Consultation
-export QWEN_CONSULT_MODE=always # always|delegate|off
-export QWEN_MODEL=qwen-coder-plus # Model selection
-export QWEN_MAX_ITERATIONS=3 # Max consultation iterations
-
-# Auto Superpowers
-export AUTO_SUPERPOWERS=true # Auto-inject context
-```
-
-### Settings Files
-
-**~/.claude/settings.json**
-```json
-{
- "customInstructions": "enabled",
- "permissions": {
- "allowedTools": ["*"],
- "allowedPrompts": ["*"]
- }
-}
-```
-
-**~/.claude/hooks.json**
-```json
-{
- "sessionStart": ["session-start-superpowers.sh"],
- "userPromptSubmit": ["qwen-consult.sh", "ralph-auto-trigger.sh"]
-}
-```
-
----
-
-## 📦 Package Contents
-
-| Component | Count | Description |
-|-----------|-------|-------------|
-| **Skills** | 270+ | Cognitive, development, UI/UX, autonomous agents, desktop development |
-| **Agents** | 100+ | Engineering, marketing, product, testing, design |
-| **Hooks** | 5+ | Session automation, multi-AI consultation |
-| **Commands** | 3 | /brainstorm, /write-plan, /execute-plan |
-| **MCP Servers** | 6 | Vision, search, web reader, GitHub, feedback, usage |
-| **Binaries** | 1 | ralphloop wrapper |
-| **Size** | 126MB | Complete package |
-
-### Full Inventory
-See [INVENTORY.md](INVENTORY.md) for complete component listing.
-
----
-
-## 🔍 Troubleshooting
-
-### Ralph Loop Not Working
-
-```bash
-# Check Ralph installation
-ralph --version
-
-# Reinstall Ralph Orchestrator
-pip3 install --upgrade ralph-orchestrator
-
-# Check RalphLoop wrapper
-which ralphloop
-ls -la ~/.local/bin/ralphloop
-```
-
-### Skills Not Loading
-
-```bash
-# Check skills directory
-ls -la ~/.claude/skills/
-
-# Verify skill syntax
-cat ~/.claude/skills/your-skill/SKILL.md
-
-# Check for errors
-claude --debug
-```
-
-### Claude Code Not Found
-
-The supercharge script will offer to install Claude Code automatically if not detected.
-
-```bash
-# Or install manually
-npm install -g @anthropic-ai/claude-code
-
-# Then run supercharge again
-./supercharge.sh
-```
-
-### Z.AI API Configuration
-
-```bash
-# Check settings
-cat ~/.claude/settings.json | grep ANTHROPIC
-
-# Verify API key works
-curl -X POST https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
- -H "Authorization: Bearer YOUR_API_KEY" \
- -H "Content-Type: application/json" \
- -d '{"model":"glm-4.7","messages":[{"role":"user","content":"test"}]}'
-```
-
----
-
-## 🔄 Updates & Maintenance
-
-### Update SuperCharge Package
-
-```bash
-cd SuperCharged-Claude-Code-Upgrade
-git pull origin main
-./supercharge.sh
-```
-
-### Update Agents
-
-```bash
-~/.claude/scripts/sync-agents.sh
-```
-
-### Backup Current Setup
-
-```bash
-~/.claude/agents/export-claude-customizations.sh
-```
-
----
-
-## 🗑️ Uninstallation
-
-```bash
-# Remove customizations
-rm -rf ~/.claude/skills/*
-rm -rf ~/.claude/agents/*
-rm -rf ~/.claude/hooks/*
-rm -rf ~/.claude/commands/*
-rm -rf ~/.claude/plugins/*
-rm ~/.claude/hooks.json
-rm ~/.local/bin/ralphloop
-
-# Restore from backup if needed
-cp -r ~/.claude-backup-YYYYMMDD_HHMMSS/* ~/.claude/
-```
-
----
-
-## 🤝 Contributing
-
-Contributions welcome! Please:
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
-
-### Adding Custom Skills
-
-Create `~/.claude/skills/your-skill/SKILL.md`:
-
-```markdown
-# Your Custom Skill
-
-## When to Use
-Use this skill when...
-
-## What It Does
-This skill provides...
-```
-
----
-
-## 🔧 Ralph Orchestrator - Autonomous "Tackle Until Solved" Agent
-
-### What is Ralph Orchestrator?
-
-**Ralph Orchestrator** is a Python package that enables autonomous agent looping - the "Tackle Until Solved" capability that powers the `/ralph` command in this package.
-
-### How Ralph Works
-
-```
-┌─────────────────────────────────────────────────────────┐
-│ Ralph Orchestrator │
-│ "Tackle Until Solved" │
-├─────────────────────────────────────────────────────────┤
-│ │
-│ 1. Analyze Task ──────> 2. Generate Approach │
-│ │ │ │
-│ ▼ ▼ │
-│ 3. Execute Step ──────> 4. Validate Result │
-│ │ │ │
-│ │ Complete? ────────No──┤ │
-│ │ │ │
-│ │ Yes ▼ │
-│ └────────────────> 5. Output Solution │
-│ │
-└─────────────────────────────────────────────────────────┘
-```
-
-### Ralph Dependency
-
-| Component | Status | Notes |
-|-----------|--------|-------|
-| **Python Package** | Required | `ralph-orchestrator` |
-| **System Command** | Optional | `ralph` CLI (if installed) |
-| **Fallback Mode** | Available | Creates project files without running loop |
-
-### Installation Methods
-
-**Option 1: Automatic (via supercharge.sh)**
-```bash
-./supercharge.sh
-# Automatically installs ralph-orchestrator via pip3
-```
-
-**Option 2: Manual Installation**
-```bash
-# Install Python package
-pip3 install ralph-orchestrator
-
-# OR install from requirements.txt in this repo
-pip3 install -r requirements.txt
-```
-
-**Option 3: System-Wide Installation**
-```bash
-# Install for all users
-sudo pip3 install ralph-orchestrator
-
-# This creates the 'ralph' command system-wide
-```
-
-### How We Built the Ralph Integration
-
-Our Ralph integration consists of several components working together:
-
-#### 1. **bin/ralphloop** - Python Wrapper Script
-- **Size**: 6,290 bytes (223 lines)
-- **Purpose**: Standalone wrapper for Ralph Orchestrator
-- **Features**:
- - Creates `.ralph/` project structure
- - Generates `PROMPT.md` with task description
- - Creates `ralph.yml` configuration
- - Streams Ralph output in real-time
- - Handles interrupts gracefully (Ctrl+C)
-
-```python
-# Key components:
-- check_dependencies() # Verifies ralph installation
-- create_ralph_project() # Creates .ralph/ directory
-- run_ralph_loop() # Executes autonomous iteration
-```
-
-#### 2. **skills/ralph/** - Claude Code Skill
-- **Purpose**: Integrates Ralph with Claude Code's `/ralph` command
-- **Trigger**: User types `/ralph "task description"`
-- **Flow**:
- 1. Receives task from user
- 2. Sets `RALPH_AUTO=true` environment variable
- 3. Delegates to `brainstorming` skill with Ralph mode
- 4. Ralph runs autonomous iterations until complete
-
-#### 3. **skills/brainstorming/** - Multi-AI Brainstorming
-- **Purpose**: Creative thinking with Ralph integration
-- **Modes**:
- - **Direct Mode**: Quick ideation (simple tasks)
- - **Ralph Mode**: Autonomous iteration (complex tasks)
-- **Auto-Trigger**: Task complexity automatically determines mode
-
-#### 4. **hooks/ralph-auto-trigger.sh** - Automatic Triggering
-- **Purpose**: Auto-starts Ralph for complex tasks
-- **Triggers**: Agent requests, development keywords
-- **Modes**:
- - `RALPH_AUTO_MODE=always` - Every request
- - `RALPH_AUTO_MODE=agents` - Agent/dev tasks only (default)
- - `RALPH_AUTO_MODE=off` - Disabled
-
-#### 5. **hooks/qwen-consult.sh** - Qwen AI Integration
-- **Purpose**: Multi-AI consultation with Qwen
-- **Modes**:
- - `QWEN_CONSULT_MODE=always` - Every request
- - `QWEN_CONSULT_MODE=delegate` - Keyword-triggered (default)
- - `QWEN_CONSULT_MODE=off` - Disabled
-
-### File Structure Created by Ralph
-
-```
-.ralph/
-├── PROMPT.md # Task description with success criteria
-├── ralph.yml # Configuration (agent, max_iterations, etc.)
-├── state.json # Progress tracking
-└── iterations/
- ├── 001.md # First iteration output
- ├── 002.md # Second iteration output
- ├── ...
- └── final.md # Validated final result
-```
-
-### Environment Variables
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `RALPH_AGENT` | `claude` | AI agent to use (claude, gemini, kiro, q, auto) |
-| `RALPH_MAX_ITERATIONS` | `100` | Maximum iterations before giving up |
-| `RALPH_MAX_RUNTIME` | `14400` | Maximum runtime in seconds (4 hours) |
-| `RALPH_AUTO_MODE` | `agents` | Auto-trigger mode (always, agents, off) |
-| `QWEN_CONSULT_MODE` | `delegate` | Qwen consultation mode |
-| `AUTO_SUPERPOWERS` | `true` | Auto-inject superpowers context |
-
-### Troubleshooting Ralph
-
-**Ralph command not found:**
-```bash
-# Check if Python package is installed
-python3 -c "import ralph_orchestrator; print('OK')"
-
-# If not, install it
-pip3 install ralph-orchestrator
-```
-
-**Ralph won't start:**
-```bash
-# Check ralphloop is executable
-ls -la ~/.claude/skills/bin/ralphloop
-chmod +x ~/.claude/skills/bin/ralphloop
-
-# Check Python 3 is available
-python3 --version
-```
-
-**Loop not running (fallback mode):**
-```bash
-# This is expected if ralph-orchestrator isn't installed
-# The script still creates project files for manual use
-cat .ralph/PROMPT.md
-cat .ralph/ralph.yml
-```
-
-### Ralph Orchestrator Source
-
-- **GitHub**: https://github.com/mikeyobrien/ralph-orchestrator
-- **PyPI**: https://pypi.org/project/ralph-orchestrator/
-- **Author**: Mike O'Brien
-- **License**: MIT
-
----
-
-## 📄 License
-
-MIT License - See [LICENSE](LICENSE) file for details
-
----
-
-## 🙏 Credits & Inspiration
-
-This project is built on the shoulders of giants. We gratefully acknowledge:
-
-### Core Inspirations
-
-🎭 **[contains-studio/agents](https://github.com/contains-studio/agents)**
-> 40+ specialized agents with PROACTIVELY auto-triggering
-
-*Inspired our agent architecture and auto-triggering patterns*
-
-[View on GitHub →](https://github.com/contains-studio/agents)
-
----
-
-🤖 **[@iannuttall/ralph](https://github.com/iannuttall/ralph)**
-> Autonomous agent looping with background execution
-
-*Ralph Orchestrator: "Fire and forget" complex tasks with autonomous iteration*
-
-[View on GitHub →](https://github.com/iannuttall/ralph)
-
----
-
-🖼️ **[@z_ai/mcp-server](https://github.com/ZAI-China/mcp-server)**
-> 8 vision tools for images, videos, diagrams, and data visualization
-
-*Comprehensive MCP server for AI vision capabilities*
-
-[View on GitHub →](https://github.com/ZAI-China/mcp-server)
-
----
-
-### Additional Inspiration
-
-📊 **llm-tldr**
-> 95% token reduction via 5-layer analysis
-
-*Inspired our cognitive optimization approach*
-
----
-
-🎨 **[ui-ux-pro-max-skill](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill)**
-> Professional UI/UX design guidance
-
-*50+ styles, 97 color palettes, 57 font pairings across 9 tech stacks*
-
-[View on GitHub →](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill)
-
----
-
-🧠 **[Cognitive User Simulation](https://github.com/HighMark-31/Cognitive-User-Simulation)**
-> Multi-agent analysis and coordination optimization
-
-*Inspired our multi-AI brainstorming and consultation patterns*
-
-[View on GitHub →](https://github.com/HighMark-31/Cognitive-User-Simulation)
-
----
-
-### Core Technologies
-
-- **[Ralph Orchestrator](https://github.com/mikeyobrien/ralph-orchestrator)** - Autonomous agent iteration engine
-- **[Claude Code](https://claude.com/claude-code)** - Anthropic's AI coding assistant
-- **[Z.AI](https://docs.z.ai/devpack/tool/claude)** - GLM model integration with 90% cost savings
-
----
-
-### Community Contributors
-
-This package incorporates skills, agents, and plugins from the Claude Code community. Thank you to all contributors who make this ecosystem better!
-
----
-
-## 📞 Support
-
-- **Issues**: [Gitea Issues](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/issues)
-- **Discussions**: [Gitea Discussions](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade/discussions)
-- **Documentation**: [Full Docs](INVENTORY.md)
-
----
-
-## 🌟 Star History
-
-[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
-
----
-
-**Made with ❤️ for the Claude Code community**
-
-*SuperCharge your AI development workflow today!*
-
----
-
-**Keywords:** Claude Code customization, Claude Code skills, Claude Code agents, AI coding assistant, Z.AI API, GLM models, RalphLoop, autonomous AI development, CLI tools, developer tools, Claude Code plugins, MCP servers, Qwen integration, AI workflow automation
+# SuperCharged Claude Code - Ultimate Upgrade Package
+
+> 🚀 Transform your Claude Code into an autonomous AI development powerhouse with **291 custom skills**, 4 integrated agent frameworks, intelligent auto-routing, and multi-platform orchestration.
+
+[](https://claude.com/claude-code)
+[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
+[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
+[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
+[](https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade)
+[](LICENSE)
+
+## ⚡ Quick Installation
+
+### Linux / macOS (Bash)
+```bash
+git clone https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade.git
+cd SuperCharged-Claude-Code-Upgrade
+./supercharge.sh
+```
+
+### Windows (WSL Recommended)
+```bash
+wsl bash -c "git clone https://github.rommark.dev/admin/SuperCharged-Claude-Code-Upgrade.git && cd SuperCharged-Claude-Code-Upgrade && ./supercharge.sh"
+```
+
+---
+
+## ⚡ Why SuperCharge Claude Code?
+
+**Claude Code is powerful. SuperCharge makes it unstoppable.**
+
+This comprehensive customization package transforms your Claude Code installation with:
+
+- ✨ **291 Custom Skills** - Cognitive enhancement, development workflows, UI/UX intelligence
+- 🤖 **4 Agent Frameworks** - Clawd, Ralph, Prometheus, Dexto - fully integrated
+- 🔥 **21 Slash Commands** - Instant access to all agents and tools
+- 🌐 **MCP Servers** - 10 servers for file operations, Git, GitHub, databases, search
+- 🎯 **Intelligent Auto-Routing** - Pattern-based agent selection with 70% confidence threshold
+- 💻 **Web Interface** - ClaudeCLI-Web dashboard with real-time session management
+- 🪝 **Smart Hooks** - Session automation and multi-AI consultation
+- 🚀 **Autonomous Execution** - Clawd gateway for hands-off task completion
+
+**Perfect for:** Developers, AI enthusiasts, teams building with AI assistants, and anyone wanting to maximize their Claude Code productivity.
+
+---
+
+## 🆕 What's New in v3.0.0
+
+### Major Framework Integrations
+
+#### 🔧 **Prometheus** (EuniAI)
+Multi-agent code analysis system with knowledge graph reasoning:
+
+- **6 Commands:** , , , , ,
+- **4 Tools:** AST-based code parsing, graph traversal, container execution, web search
+- **Capabilities:** Bug fixing, feature planning, code context, regression testing
+
+#### 🎭 **Dexto** (Truffle AI)
+Agent harness with orchestration and session management:
+
+- **12 Commands:** , , , , , , , , , , ,
+- **5 Tools:** Filesystem, Playwright, Process, TODO, Plan
+- **Capabilities:** Development, media creation, databases, GitHub, research
+
+#### 🤖 **Clawd**
+Autonomous task execution gateway:
+
+- **1 Command:**
+- **Capability:** Multi-agent task delegation with persistent sessions
+- **Gateway:** Running on port 8766 with health monitoring
+
+#### 🔄 **Ralph**
+"Tackle Until Solved" autonomous iteration:
+
+- **1 Command:**
+- **Capability:** Architecture design, multi-step implementations
+- **Integration:** Access to all 21 commands via intelligent routing
+
+### 🎯 Intelligent Auto-Routing System
+
+**NEW:** Automatic agent selection based on task patterns:
+
+| Task Pattern | Routes To | Example |
+|-------------|-----------|---------|
+| "autonomous", "automatically" | | "Handle this autonomously" |
+| "architecture", "design system" | | "Design microservices architecture" |
+| "bug", "fix", "reproduce" | | "Fix authentication bug" |
+| "feature", "implement" | | "Add two-factor auth" |
+| "github", "pr", "issue" | | "Analyze pull request" |
+| "pdf", "document" | | "Summarize document" |
+| "generate image" | | "Generate image" |
+| "database", "sql" | | "Optimize query" |
+
+---
+
+## 📊 Complete Feature List
+
+### 🔧 Agent Frameworks (4)
+
+| Framework | Type | Status |
+|-----------|------|--------|
+| **Clawd** | Autonomous Execution | ✅ Integrated |
+| **Ralph** | Iterative Architecture | ✅ Integrated |
+| **Prometheus** | Code Analysis | ✅ Integrated |
+| **Dexto** | Multi-Agent Harness | ✅ Integrated |
+
+### 🎯 Slash Commands (21)
+
+#### Clawd (1)
+```
+/clawd "Autonomous task execution"
+```
+
+#### Ralph (1)
+```
+/ralph "Complex architecture or multi-step task"
+```
+
+#### Prometheus (6)
+```
+/prometheus-bug "Bug analysis and fix"
+/prometheus-feature "Feature planning"
+/prometheus-context "Code context retrieval"
+/prometheus-edit "Code editing"
+/prometheus-test "Test execution"
+/prometheus-classify "Issue classification"
+/prometheus "Auto-select appropriate tool"
+```
+
+#### Dexto (12)
+```
+/dexto-code "Development tasks"
+/dexto-database "Database operations"
+/dexto-github "GitHub operations"
+/dexto-pdf "PDF analysis"
+/dexto-image-edit "Image editing"
+/dexto-nano-banana "AI image generation"
+/dexto-sora "Video generation"
+/dexto-music "Music creation"
+/dexto-podcast "Podcast generation"
+/dexto-research "Product research"
+/dexto-triage "Support ticket triage"
+/dexto-explore "Codebase exploration"
+/dexto "Auto-select appropriate agent"
+```
+
+### 🔌 MCP Servers (10)
+
+- **arc** - Subagent file operations
+- **claude-mem** - Persistent memory
+- **filesystem** - Local filesystem operations
+- **git** - Git operations
+- **fetch** - HTTP requests
+- **sqlite** - Database operations
+- **github** - GitHub API (requires auth)
+- **brave-search** - Web search (requires auth)
+- **postgres** - PostgreSQL (requires connection)
+- **puppeteer** - Browser automation
+
+### 🪝 Hooks (7)
+
+- - Pattern-based agent routing
+- - Clawd automation
+- - Session initialization
+- - Task completion handling
+- - Clawd command wrapper
+- - Prometheus integration
+- - Unified agent system
+
+### 📚 Skills (291)
+
+- Cognitive enhancement
+- Development workflows
+- UI/UX design intelligence
+- Desktop development
+- Code review
+- Testing strategies
+- Documentation
+- Git workflows
+- Architecture patterns
+
+---
+
+## 🚀 Usage Examples
+
+### Autonomous Task Execution
+```bash
+/clawd "Deploy the application and run all tests"
+```
+
+### Architecture Design
+```bash
+/ralph "Design a scalable e-commerce backend with microservices"
+```
+
+### Bug Analysis
+```bash
+/prometheus-bug "Login fails after password reset"
+```
+
+### Feature Implementation
+```bash
+/prometheus-feature "Add two-factor authentication"
+```
+
+### GitHub Operations
+```bash
+/dexto-github "Analyze issues in repository"
+```
+
+### PDF Analysis
+```bash
+/dexto-pdf "Summarize research paper"
+```
+
+### Image Generation
+```bash
+/dexto-nano-banana "Generate image of cyberpunk city"
+```
+
+---
+
+## 🛠️ Configuration
+
+### Auto-Routing Confidence Threshold
+
+Edit `~/.claude/hooks/intelligent-router.sh`:
+```bash
+if [ "$SCORE" -ge 70 ]; then # Adjust threshold (0-100)
+```
+
+### Enable/Disable MCP Servers
+
+Edit `~/.claude/mcp-servers/registry.json`:
+```json
+{
+ "servers": {
+ "github": { "enabled": true },
+ "brave-search": { "enabled": false }
+ }
+}
+```
+
+---
+
+## 📁 Project Structure
+
+```
+SuperCharged-Claude-Code-Upgrade/
+├── commands/ # 21 slash commands
+├── hooks/ # Event hooks
+├── skills/ # 291 custom skills
+├── mcp-servers/ # MCP server registry
+├── prometheus/ # Prometheus integration
+├── dexto/ # Dexto integration
+├── clawd/ # Clawd gateway
+├── ralph-integration/ # Ralph integration
+├── plugins/ # Plugin marketplace
+├── ClaudeCLI-Web/ # Web interface
+├── health-check.sh # System validation
+└── supercharge.sh # Installer
+```
+
+---
+
+## 🩺 Health Check
+
+Run health check to verify all systems:
+```bash
+~/.claude/health-check.sh
+```
+
+Expected output:
+```
+✓ All 291 skills loaded
+✓ All 21 commands available
+✓ All 10 MCP servers registered
+✓ Clawd gateway running (PID: xxxx)
+✓ Intelligent router active
+```
+
+---
+
+## 📚 Documentation
+
+- [Auto-Trigger System](AUTO-TRIGGER-SUMMARY.md)
+- [Complete Integration Summary](FINAL-INTEGRATION-SUMMARY.md)
+- [Prometheus Documentation](prometheus/README.md)
+- [Dexto Documentation](dexto/README.md)
+- [ClaudeCLI-Web](ClaudeCLI-Web/README.md)
+
+---
+
+## 🤝 Contributing
+
+Contributions welcome! Please read CONTRIBUTING.md for details.
+
+---
+
+## 📄 License
+
+MIT License - see LICENSE file for details.
+
+---
+
+**🎉 Your Claude Code CLI is now a comprehensive multi-agent AI platform!**
+
+Total capabilities:
+- ✅ Autonomous execution (Clawd)
+- ✅ Architecture design (Ralph)
+- ✅ Code analysis (Prometheus)
+- ✅ Multi-agent framework (Dexto)
+- ✅ 291 specialized skills
+- ✅ 10 MCP servers
+- ✅ Intelligent auto-routing
+- ✅ Production-grade monitoring
diff --git a/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-22-opencode-support-design.md b/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-22-opencode-support-design.md
new file mode 100644
index 00000000..144f1cea
--- /dev/null
+++ b/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-22-opencode-support-design.md
@@ -0,0 +1,294 @@
+# OpenCode Support Design
+
+**Date:** 2025-11-22
+**Author:** Bot & Jesse
+**Status:** Design Complete, Awaiting Implementation
+
+## Overview
+
+Add full superpowers support for OpenCode.ai using a native OpenCode plugin architecture that shares core functionality with the existing Codex implementation.
+
+## Background
+
+OpenCode.ai is a coding agent similar to Claude Code and Codex. Previous attempts to port superpowers to OpenCode (PR #93, PR #116) used file-copying approaches. This design takes a different approach: building a native OpenCode plugin using their JavaScript/TypeScript plugin system while sharing code with the Codex implementation.
+
+### Key Differences Between Platforms
+
+- **Claude Code**: Native Anthropic plugin system + file-based skills
+- **Codex**: No plugin system → bootstrap markdown + CLI script
+- **OpenCode**: JavaScript/TypeScript plugins with event hooks and custom tools API
+
+### OpenCode's Agent System
+
+- **Primary agents**: Build (default, full access) and Plan (restricted, read-only)
+- **Subagents**: General (research, searching, multi-step tasks)
+- **Invocation**: Automatic dispatch by primary agents OR manual `@mention` syntax
+- **Configuration**: Custom agents in `opencode.json` or `~/.config/opencode/agent/`
+
+## Architecture
+
+### High-Level Structure
+
+1. **Shared Core Module** (`lib/skills-core.js`)
+ - Common skill discovery and parsing logic
+ - Used by both Codex and OpenCode implementations
+
+2. **Platform-Specific Wrappers**
+ - Codex: CLI script (`.codex/superpowers-codex`)
+ - OpenCode: Plugin module (`.opencode/plugin/superpowers.js`)
+
+3. **Skill Directories**
+ - Core: `~/.config/opencode/superpowers/skills/` (or installed location)
+ - Personal: `~/.config/opencode/skills/` (shadows core skills)
+
+### Code Reuse Strategy
+
+Extract common functionality from `.codex/superpowers-codex` into shared module:
+
+```javascript
+// lib/skills-core.js
+module.exports = {
+ extractFrontmatter(filePath), // Parse name + description from YAML
+ findSkillsInDir(dir, maxDepth), // Recursive SKILL.md discovery
+ findAllSkills(dirs), // Scan multiple directories
+ resolveSkillPath(skillName, dirs), // Handle shadowing (personal > core)
+ checkForUpdates(repoDir) // Git fetch/status check
+};
+```
+
+### Skill Frontmatter Format
+
+Current format (no `when_to_use` field):
+
+```yaml
+---
+name: skill-name
+description: Use when [condition] - [what it does]; [additional context]
+---
+```
+
+## OpenCode Plugin Implementation
+
+### Custom Tools
+
+**Tool 1: `use_skill`**
+
+Loads a specific skill's content into the conversation (equivalent to Claude's Skill tool).
+
+```javascript
+{
+ name: 'use_skill',
+ description: 'Load and read a specific skill to guide your work',
+ schema: z.object({
+ skill_name: z.string().describe('Name of skill (e.g., "superpowers:brainstorming")')
+ }),
+ execute: async ({ skill_name }) => {
+ const { skillPath, content, frontmatter } = resolveAndReadSkill(skill_name);
+ const skillDir = path.dirname(skillPath);
+
+ return `# ${frontmatter.name}
+# ${frontmatter.description}
+# Supporting tools and docs are in ${skillDir}
+# ============================================
+
+${content}`;
+ }
+}
+```
+
+**Tool 2: `find_skills`**
+
+Lists all available skills with metadata.
+
+```javascript
+{
+ name: 'find_skills',
+ description: 'List all available skills',
+ schema: z.object({}),
+ execute: async () => {
+ const skills = discoverAllSkills();
+ return skills.map(s =>
+ `${s.namespace}:${s.name}
+ ${s.description}
+ Directory: ${s.directory}
+`).join('\n');
+ }
+}
+```
+
+### Session Startup Hook
+
+When a new session starts (`session.started` event):
+
+1. **Inject using-superpowers content**
+ - Full content of the using-superpowers skill
+ - Establishes mandatory workflows
+
+2. **Run find_skills automatically**
+ - Display full list of available skills upfront
+ - Include skill directories for each
+
+3. **Inject tool mapping instructions**
+ ```markdown
+ **Tool Mapping for OpenCode:**
+ When skills reference tools you don't have, substitute:
+ - `TodoWrite` → `update_plan`
+ - `Task` with subagents → Use OpenCode subagent system (@mention)
+ - `Skill` tool → `use_skill` custom tool
+ - Read, Write, Edit, Bash → Your native equivalents
+
+ **Skill directories contain:**
+ - Supporting scripts (run with bash)
+ - Additional documentation (read with read tool)
+ - Utilities specific to that skill
+ ```
+
+4. **Check for updates** (non-blocking)
+ - Quick git fetch with timeout
+ - Notify if updates available
+
+### Plugin Structure
+
+```javascript
+// .opencode/plugin/superpowers.js
+const skillsCore = require('../../lib/skills-core');
+const path = require('path');
+const fs = require('fs');
+const { z } = require('zod');
+
+export const SuperpowersPlugin = async ({ client, directory, $ }) => {
+ const superpowersDir = path.join(process.env.HOME, '.config/opencode/superpowers');
+ const personalDir = path.join(process.env.HOME, '.config/opencode/skills');
+
+ return {
+ 'session.started': async () => {
+ const usingSuperpowers = await readSkill('using-superpowers');
+ const skillsList = await findAllSkills();
+ const toolMapping = getToolMappingInstructions();
+
+ return {
+ context: `${usingSuperpowers}\n\n${skillsList}\n\n${toolMapping}`
+ };
+ },
+
+ tools: [
+ {
+ name: 'use_skill',
+ description: 'Load and read a specific skill',
+ schema: z.object({
+ skill_name: z.string()
+ }),
+ execute: async ({ skill_name }) => {
+ // Implementation using skillsCore
+ }
+ },
+ {
+ name: 'find_skills',
+ description: 'List all available skills',
+ schema: z.object({}),
+ execute: async () => {
+ // Implementation using skillsCore
+ }
+ }
+ ]
+ };
+};
+```
+
+## File Structure
+
+```
+superpowers/
+├── lib/
+│ └── skills-core.js # NEW: Shared skill logic
+├── .codex/
+│ ├── superpowers-codex # UPDATED: Use skills-core
+│ ├── superpowers-bootstrap.md
+│ └── INSTALL.md
+├── .opencode/
+│ ├── plugin/
+│ │ └── superpowers.js # NEW: OpenCode plugin
+│ └── INSTALL.md # NEW: Installation guide
+└── skills/ # Unchanged
+```
+
+## Implementation Plan
+
+### Phase 1: Refactor Shared Core
+
+1. Create `lib/skills-core.js`
+ - Extract frontmatter parsing from `.codex/superpowers-codex`
+ - Extract skill discovery logic
+ - Extract path resolution (with shadowing)
+ - Update to use only `name` and `description` (no `when_to_use`)
+
+2. Update `.codex/superpowers-codex` to use shared core
+ - Import from `../lib/skills-core.js`
+ - Remove duplicated code
+ - Keep CLI wrapper logic
+
+3. Test Codex implementation still works
+ - Verify bootstrap command
+ - Verify use-skill command
+ - Verify find-skills command
+
+### Phase 2: Build OpenCode Plugin
+
+1. Create `.opencode/plugin/superpowers.js`
+ - Import shared core from `../../lib/skills-core.js`
+ - Implement plugin function
+ - Define custom tools (use_skill, find_skills)
+ - Implement session.started hook
+
+2. Create `.opencode/INSTALL.md`
+ - Installation instructions
+ - Directory setup
+ - Configuration guidance
+
+3. Test OpenCode implementation
+ - Verify session startup bootstrap
+ - Verify use_skill tool works
+ - Verify find_skills tool works
+ - Verify skill directories are accessible
+
+### Phase 3: Documentation & Polish
+
+1. Update README with OpenCode support
+2. Add OpenCode installation to main docs
+3. Update RELEASE-NOTES
+4. Test both Codex and OpenCode work correctly
+
+## Next Steps
+
+1. **Create isolated workspace** (using git worktrees)
+ - Branch: `feature/opencode-support`
+
+2. **Follow TDD where applicable**
+ - Test shared core functions
+ - Test skill discovery and parsing
+ - Integration tests for both platforms
+
+3. **Incremental implementation**
+ - Phase 1: Refactor shared core + update Codex
+ - Verify Codex still works before moving on
+ - Phase 2: Build OpenCode plugin
+ - Phase 3: Documentation and polish
+
+4. **Testing strategy**
+ - Manual testing with real OpenCode installation
+ - Verify skill loading, directories, scripts work
+ - Test both Codex and OpenCode side-by-side
+ - Verify tool mappings work correctly
+
+5. **PR and merge**
+ - Create PR with complete implementation
+ - Test in clean environment
+ - Merge to main
+
+## Benefits
+
+- **Code reuse**: Single source of truth for skill discovery/parsing
+- **Maintainability**: Bug fixes apply to both platforms
+- **Extensibility**: Easy to add future platforms (Cursor, Windsurf, etc.)
+- **Native integration**: Uses OpenCode's plugin system properly
+- **Consistency**: Same skill experience across all platforms
diff --git a/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-22-opencode-support-implementation.md b/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-22-opencode-support-implementation.md
new file mode 100644
index 00000000..1a7c1fb9
--- /dev/null
+++ b/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-22-opencode-support-implementation.md
@@ -0,0 +1,1095 @@
+# OpenCode Support Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Add full superpowers support for OpenCode.ai with a native JavaScript plugin that shares core functionality with the existing Codex implementation.
+
+**Architecture:** Extract common skill discovery/parsing logic into `lib/skills-core.js`, refactor Codex to use it, then build OpenCode plugin using their native plugin API with custom tools and session hooks.
+
+**Tech Stack:** Node.js, JavaScript, OpenCode Plugin API, Git worktrees
+
+---
+
+## Phase 1: Create Shared Core Module
+
+### Task 1: Extract Frontmatter Parsing
+
+**Files:**
+- Create: `lib/skills-core.js`
+- Reference: `.codex/superpowers-codex` (lines 40-74)
+
+**Step 1: Create lib/skills-core.js with extractFrontmatter function**
+
+```javascript
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extract YAML frontmatter from a skill file.
+ * Current format:
+ * ---
+ * name: skill-name
+ * description: Use when [condition] - [what it does]
+ * ---
+ *
+ * @param {string} filePath - Path to SKILL.md file
+ * @returns {{name: string, description: string}}
+ */
+function extractFrontmatter(filePath) {
+ try {
+ const content = fs.readFileSync(filePath, 'utf8');
+ const lines = content.split('\n');
+
+ let inFrontmatter = false;
+ let name = '';
+ let description = '';
+
+ for (const line of lines) {
+ if (line.trim() === '---') {
+ if (inFrontmatter) break;
+ inFrontmatter = true;
+ continue;
+ }
+
+ if (inFrontmatter) {
+ const match = line.match(/^(\w+):\s*(.*)$/);
+ if (match) {
+ const [, key, value] = match;
+ switch (key) {
+ case 'name':
+ name = value.trim();
+ break;
+ case 'description':
+ description = value.trim();
+ break;
+ }
+ }
+ }
+ }
+
+ return { name, description };
+ } catch (error) {
+ return { name: '', description: '' };
+ }
+}
+
+module.exports = {
+ extractFrontmatter
+};
+```
+
+**Step 2: Verify file was created**
+
+Run: `ls -l lib/skills-core.js`
+Expected: File exists
+
+**Step 3: Commit**
+
+```bash
+git add lib/skills-core.js
+git commit -m "feat: create shared skills core module with frontmatter parser"
+```
+
+---
+
+### Task 2: Extract Skill Discovery Logic
+
+**Files:**
+- Modify: `lib/skills-core.js`
+- Reference: `.codex/superpowers-codex` (lines 97-136)
+
+**Step 1: Add findSkillsInDir function to skills-core.js**
+
+Add before `module.exports`:
+
+```javascript
+/**
+ * Find all SKILL.md files in a directory recursively.
+ *
+ * @param {string} dir - Directory to search
+ * @param {string} sourceType - 'personal' or 'superpowers' for namespacing
+ * @param {number} maxDepth - Maximum recursion depth (default: 3)
+ * @returns {Array<{path: string, name: string, description: string, sourceType: string}>}
+ */
+function findSkillsInDir(dir, sourceType, maxDepth = 3) {
+ const skills = [];
+
+ if (!fs.existsSync(dir)) return skills;
+
+ function recurse(currentDir, depth) {
+ if (depth > maxDepth) return;
+
+ const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+ for (const entry of entries) {
+ const fullPath = path.join(currentDir, entry.name);
+
+ if (entry.isDirectory()) {
+ // Check for SKILL.md in this directory
+ const skillFile = path.join(fullPath, 'SKILL.md');
+ if (fs.existsSync(skillFile)) {
+ const { name, description } = extractFrontmatter(skillFile);
+ skills.push({
+ path: fullPath,
+ skillFile: skillFile,
+ name: name || entry.name,
+ description: description || '',
+ sourceType: sourceType
+ });
+ }
+
+ // Recurse into subdirectories
+ recurse(fullPath, depth + 1);
+ }
+ }
+ }
+
+ recurse(dir, 0);
+ return skills;
+}
+```
+
+**Step 2: Update module.exports**
+
+Replace the exports line with:
+
+```javascript
+module.exports = {
+ extractFrontmatter,
+ findSkillsInDir
+};
+```
+
+**Step 3: Verify syntax**
+
+Run: `node -c lib/skills-core.js`
+Expected: No output (success)
+
+**Step 4: Commit**
+
+```bash
+git add lib/skills-core.js
+git commit -m "feat: add skill discovery function to core module"
+```
+
+---
+
+### Task 3: Extract Skill Resolution Logic
+
+**Files:**
+- Modify: `lib/skills-core.js`
+- Reference: `.codex/superpowers-codex` (lines 212-280)
+
+**Step 1: Add resolveSkillPath function**
+
+Add before `module.exports`:
+
+```javascript
+/**
+ * Resolve a skill name to its file path, handling shadowing
+ * (personal skills override superpowers skills).
+ *
+ * @param {string} skillName - Name like "superpowers:brainstorming" or "my-skill"
+ * @param {string} superpowersDir - Path to superpowers skills directory
+ * @param {string} personalDir - Path to personal skills directory
+ * @returns {{skillFile: string, sourceType: string, skillPath: string} | null}
+ */
+function resolveSkillPath(skillName, superpowersDir, personalDir) {
+ // Strip superpowers: prefix if present
+ const forceSuperpowers = skillName.startsWith('superpowers:');
+ const actualSkillName = forceSuperpowers ? skillName.replace(/^superpowers:/, '') : skillName;
+
+ // Try personal skills first (unless explicitly superpowers:)
+ if (!forceSuperpowers && personalDir) {
+ const personalPath = path.join(personalDir, actualSkillName);
+ const personalSkillFile = path.join(personalPath, 'SKILL.md');
+ if (fs.existsSync(personalSkillFile)) {
+ return {
+ skillFile: personalSkillFile,
+ sourceType: 'personal',
+ skillPath: actualSkillName
+ };
+ }
+ }
+
+ // Try superpowers skills
+ if (superpowersDir) {
+ const superpowersPath = path.join(superpowersDir, actualSkillName);
+ const superpowersSkillFile = path.join(superpowersPath, 'SKILL.md');
+ if (fs.existsSync(superpowersSkillFile)) {
+ return {
+ skillFile: superpowersSkillFile,
+ sourceType: 'superpowers',
+ skillPath: actualSkillName
+ };
+ }
+ }
+
+ return null;
+}
+```
+
+**Step 2: Update module.exports**
+
+```javascript
+module.exports = {
+ extractFrontmatter,
+ findSkillsInDir,
+ resolveSkillPath
+};
+```
+
+**Step 3: Verify syntax**
+
+Run: `node -c lib/skills-core.js`
+Expected: No output
+
+**Step 4: Commit**
+
+```bash
+git add lib/skills-core.js
+git commit -m "feat: add skill path resolution with shadowing support"
+```
+
+---
+
+### Task 4: Extract Update Check Logic
+
+**Files:**
+- Modify: `lib/skills-core.js`
+- Reference: `.codex/superpowers-codex` (lines 16-38)
+
+**Step 1: Add checkForUpdates function**
+
+Add at top after requires:
+
+```javascript
+const { execSync } = require('child_process');
+```
+
+Add before `module.exports`:
+
+```javascript
+/**
+ * Check if a git repository has updates available.
+ *
+ * @param {string} repoDir - Path to git repository
+ * @returns {boolean} - True if updates are available
+ */
+function checkForUpdates(repoDir) {
+ try {
+ // Quick check with 3 second timeout to avoid delays if network is down
+ const output = execSync('git fetch origin && git status --porcelain=v1 --branch', {
+ cwd: repoDir,
+ timeout: 3000,
+ encoding: 'utf8',
+ stdio: 'pipe'
+ });
+
+ // Parse git status output to see if we're behind
+ const statusLines = output.split('\n');
+ for (const line of statusLines) {
+ if (line.startsWith('## ') && line.includes('[behind ')) {
+ return true; // We're behind remote
+ }
+ }
+ return false; // Up to date
+ } catch (error) {
+ // Network down, git error, timeout, etc. - don't block bootstrap
+ return false;
+ }
+}
+```
+
+**Step 2: Update module.exports**
+
+```javascript
+module.exports = {
+ extractFrontmatter,
+ findSkillsInDir,
+ resolveSkillPath,
+ checkForUpdates
+};
+```
+
+**Step 3: Verify syntax**
+
+Run: `node -c lib/skills-core.js`
+Expected: No output
+
+**Step 4: Commit**
+
+```bash
+git add lib/skills-core.js
+git commit -m "feat: add git update checking to core module"
+```
+
+---
+
+## Phase 2: Refactor Codex to Use Shared Core
+
+### Task 5: Update Codex to Import Shared Core
+
+**Files:**
+- Modify: `.codex/superpowers-codex` (add import at top)
+
+**Step 1: Add import statement**
+
+After the existing requires at top of file (around line 6), add:
+
+```javascript
+const skillsCore = require('../lib/skills-core');
+```
+
+**Step 2: Verify syntax**
+
+Run: `node -c .codex/superpowers-codex`
+Expected: No output
+
+**Step 3: Commit**
+
+```bash
+git add .codex/superpowers-codex
+git commit -m "refactor: import shared skills core in codex"
+```
+
+---
+
+### Task 6: Replace extractFrontmatter with Core Version
+
+**Files:**
+- Modify: `.codex/superpowers-codex` (lines 40-74)
+
+**Step 1: Remove local extractFrontmatter function**
+
+Delete lines 40-74 (the entire extractFrontmatter function definition).
+
+**Step 2: Update all extractFrontmatter calls**
+
+Find and replace all calls from `extractFrontmatter(` to `skillsCore.extractFrontmatter(`
+
+Affected lines approximately: 90, 310
+
+**Step 3: Verify script still works**
+
+Run: `.codex/superpowers-codex find-skills | head -20`
+Expected: Shows list of skills
+
+**Step 4: Commit**
+
+```bash
+git add .codex/superpowers-codex
+git commit -m "refactor: use shared extractFrontmatter in codex"
+```
+
+---
+
+### Task 7: Replace findSkillsInDir with Core Version
+
+**Files:**
+- Modify: `.codex/superpowers-codex` (lines 97-136, approximately)
+
+**Step 1: Remove local findSkillsInDir function**
+
+Delete the entire `findSkillsInDir` function definition (approximately lines 97-136).
+
+**Step 2: Update all findSkillsInDir calls**
+
+Replace calls from `findSkillsInDir(` to `skillsCore.findSkillsInDir(`
+
+**Step 3: Verify script still works**
+
+Run: `.codex/superpowers-codex find-skills | head -20`
+Expected: Shows list of skills
+
+**Step 4: Commit**
+
+```bash
+git add .codex/superpowers-codex
+git commit -m "refactor: use shared findSkillsInDir in codex"
+```
+
+---
+
+### Task 8: Replace checkForUpdates with Core Version
+
+**Files:**
+- Modify: `.codex/superpowers-codex` (lines 16-38, approximately)
+
+**Step 1: Remove local checkForUpdates function**
+
+Delete the entire `checkForUpdates` function definition.
+
+**Step 2: Update all checkForUpdates calls**
+
+Replace calls from `checkForUpdates(` to `skillsCore.checkForUpdates(`
+
+**Step 3: Verify script still works**
+
+Run: `.codex/superpowers-codex bootstrap | head -50`
+Expected: Shows bootstrap content
+
+**Step 4: Commit**
+
+```bash
+git add .codex/superpowers-codex
+git commit -m "refactor: use shared checkForUpdates in codex"
+```
+
+---
+
+## Phase 3: Build OpenCode Plugin
+
+### Task 9: Create OpenCode Plugin Directory Structure
+
+**Files:**
+- Create: `.opencode/plugin/superpowers.js`
+
+**Step 1: Create directory**
+
+Run: `mkdir -p .opencode/plugin`
+
+**Step 2: Create basic plugin file**
+
+```javascript
+#!/usr/bin/env node
+
+/**
+ * Superpowers plugin for OpenCode.ai
+ *
+ * Provides custom tools for loading and discovering skills,
+ * with automatic bootstrap on session start.
+ */
+
+const skillsCore = require('../../lib/skills-core');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const homeDir = os.homedir();
+const superpowersSkillsDir = path.join(homeDir, '.config/opencode/superpowers/skills');
+const personalSkillsDir = path.join(homeDir, '.config/opencode/skills');
+
+/**
+ * OpenCode plugin entry point
+ */
+export const SuperpowersPlugin = async ({ project, client, $, directory, worktree }) => {
+ return {
+ // Custom tools and hooks will go here
+ };
+};
+```
+
+**Step 3: Verify file was created**
+
+Run: `ls -l .opencode/plugin/superpowers.js`
+Expected: File exists
+
+**Step 4: Commit**
+
+```bash
+git add .opencode/plugin/superpowers.js
+git commit -m "feat: create opencode plugin scaffold"
+```
+
+---
+
+### Task 10: Implement use_skill Tool
+
+**Files:**
+- Modify: `.opencode/plugin/superpowers.js`
+
+**Step 1: Add use_skill tool implementation**
+
+Replace the plugin return statement with:
+
+```javascript
+export const SuperpowersPlugin = async ({ project, client, $, directory, worktree }) => {
+ // Import zod for schema validation
+ const { z } = await import('zod');
+
+ return {
+ tools: [
+ {
+ name: 'use_skill',
+ description: 'Load and read a specific skill to guide your work. Skills contain proven workflows, mandatory processes, and expert techniques.',
+ schema: z.object({
+ skill_name: z.string().describe('Name of the skill to load (e.g., "superpowers:brainstorming" or "my-custom-skill")')
+ }),
+ execute: async ({ skill_name }) => {
+ // Resolve skill path (handles shadowing: personal > superpowers)
+ const resolved = skillsCore.resolveSkillPath(
+ skill_name,
+ superpowersSkillsDir,
+ personalSkillsDir
+ );
+
+ if (!resolved) {
+ return `Error: Skill "${skill_name}" not found.\n\nRun find_skills to see available skills.`;
+ }
+
+ // Read skill content
+ const fullContent = fs.readFileSync(resolved.skillFile, 'utf8');
+ const { name, description } = skillsCore.extractFrontmatter(resolved.skillFile);
+
+ // Extract content after frontmatter
+ const lines = fullContent.split('\n');
+ let inFrontmatter = false;
+ let frontmatterEnded = false;
+ const contentLines = [];
+
+ for (const line of lines) {
+ if (line.trim() === '---') {
+ if (inFrontmatter) {
+ frontmatterEnded = true;
+ continue;
+ }
+ inFrontmatter = true;
+ continue;
+ }
+
+ if (frontmatterEnded || !inFrontmatter) {
+ contentLines.push(line);
+ }
+ }
+
+ const content = contentLines.join('\n').trim();
+ const skillDirectory = path.dirname(resolved.skillFile);
+
+ // Format output similar to Claude Code's Skill tool
+ return `# ${name || skill_name}
+# ${description || ''}
+# Supporting tools and docs are in ${skillDirectory}
+# ============================================
+
+${content}`;
+ }
+ }
+ ]
+ };
+};
+```
+
+**Step 2: Verify syntax**
+
+Run: `node -c .opencode/plugin/superpowers.js`
+Expected: No output
+
+**Step 3: Commit**
+
+```bash
+git add .opencode/plugin/superpowers.js
+git commit -m "feat: implement use_skill tool for opencode"
+```
+
+---
+
+### Task 11: Implement find_skills Tool
+
+**Files:**
+- Modify: `.opencode/plugin/superpowers.js`
+
+**Step 1: Add find_skills tool to tools array**
+
+Add after the use_skill tool definition, before closing the tools array:
+
+```javascript
+ {
+ name: 'find_skills',
+ description: 'List all available skills in the superpowers and personal skill libraries.',
+ schema: z.object({}),
+ execute: async () => {
+ // Find skills in both directories
+ const superpowersSkills = skillsCore.findSkillsInDir(
+ superpowersSkillsDir,
+ 'superpowers',
+ 3
+ );
+ const personalSkills = skillsCore.findSkillsInDir(
+ personalSkillsDir,
+ 'personal',
+ 3
+ );
+
+ // Combine and format skills list
+ const allSkills = [...personalSkills, ...superpowersSkills];
+
+ if (allSkills.length === 0) {
+ return 'No skills found. Install superpowers skills to ~/.config/opencode/superpowers/skills/';
+ }
+
+ let output = 'Available skills:\n\n';
+
+ for (const skill of allSkills) {
+ const namespace = skill.sourceType === 'personal' ? '' : 'superpowers:';
+ const skillName = skill.name || path.basename(skill.path);
+
+ output += `${namespace}${skillName}\n`;
+ if (skill.description) {
+ output += ` ${skill.description}\n`;
+ }
+ output += ` Directory: ${skill.path}\n\n`;
+ }
+
+ return output;
+ }
+ }
+```
+
+**Step 2: Verify syntax**
+
+Run: `node -c .opencode/plugin/superpowers.js`
+Expected: No output
+
+**Step 3: Commit**
+
+```bash
+git add .opencode/plugin/superpowers.js
+git commit -m "feat: implement find_skills tool for opencode"
+```
+
+---
+
+### Task 12: Implement Session Start Hook
+
+**Files:**
+- Modify: `.opencode/plugin/superpowers.js`
+
+**Step 1: Add session.started hook**
+
+After the tools array, add:
+
+```javascript
+ 'session.started': async () => {
+ // Read using-superpowers skill content
+ const usingSuperpowersPath = skillsCore.resolveSkillPath(
+ 'using-superpowers',
+ superpowersSkillsDir,
+ personalSkillsDir
+ );
+
+ let usingSuperpowersContent = '';
+ if (usingSuperpowersPath) {
+ const fullContent = fs.readFileSync(usingSuperpowersPath.skillFile, 'utf8');
+ // Strip frontmatter
+ const lines = fullContent.split('\n');
+ let inFrontmatter = false;
+ let frontmatterEnded = false;
+ const contentLines = [];
+
+ for (const line of lines) {
+ if (line.trim() === '---') {
+ if (inFrontmatter) {
+ frontmatterEnded = true;
+ continue;
+ }
+ inFrontmatter = true;
+ continue;
+ }
+
+ if (frontmatterEnded || !inFrontmatter) {
+ contentLines.push(line);
+ }
+ }
+
+ usingSuperpowersContent = contentLines.join('\n').trim();
+ }
+
+ // Tool mapping instructions
+ const toolMapping = `
+**Tool Mapping for OpenCode:**
+When skills reference tools you don't have, substitute OpenCode equivalents:
+- \`TodoWrite\` → \`update_plan\` (your planning/task tracking tool)
+- \`Task\` tool with subagents → Use OpenCode's subagent system (@mention syntax or automatic dispatch)
+- \`Skill\` tool → \`use_skill\` custom tool (already available)
+- \`Read\`, \`Write\`, \`Edit\`, \`Bash\` → Use your native tools
+
+**Skill directories contain supporting files:**
+- Scripts you can run with bash tool
+- Additional documentation you can read
+- Utilities and helpers specific to that skill
+
+**Skills naming:**
+- Superpowers skills: \`superpowers:skill-name\` (from ~/.config/opencode/superpowers/skills/)
+- Personal skills: \`skill-name\` (from ~/.config/opencode/skills/)
+- Personal skills override superpowers skills when names match
+`;
+
+ // Check for updates (non-blocking)
+ const hasUpdates = skillsCore.checkForUpdates(
+ path.join(homeDir, '.config/opencode/superpowers')
+ );
+
+ const updateNotice = hasUpdates ?
+ '\n\n⚠️ **Updates available!** Run `cd ~/.config/opencode/superpowers && git pull` to update superpowers.' :
+ '';
+
+ // Return context to inject into session
+ return {
+ context: `
+You have superpowers.
+
+**Below is the full content of your 'superpowers:using-superpowers' skill - your introduction to using skills. For all other skills, use the 'use_skill' tool:**
+
+${usingSuperpowersContent}
+
+${toolMapping}${updateNotice}
+`
+ };
+ }
+```
+
+**Step 2: Verify syntax**
+
+Run: `node -c .opencode/plugin/superpowers.js`
+Expected: No output
+
+**Step 3: Commit**
+
+```bash
+git add .opencode/plugin/superpowers.js
+git commit -m "feat: implement session.started hook for opencode"
+```
+
+---
+
+## Phase 4: Documentation
+
+### Task 13: Create OpenCode Installation Guide
+
+**Files:**
+- Create: `.opencode/INSTALL.md`
+
+**Step 1: Create installation guide**
+
+```markdown
+# Installing Superpowers for OpenCode
+
+## Prerequisites
+
+- [OpenCode.ai](https://opencode.ai) installed
+- Node.js installed
+- Git installed
+
+## Installation Steps
+
+### 1. Install Superpowers Skills
+
+```bash
+# Clone superpowers skills to OpenCode config directory
+mkdir -p ~/.config/opencode/superpowers
+git clone https://github.com/obra/superpowers.git ~/.config/opencode/superpowers
+```
+
+### 2. Install the Plugin
+
+The plugin is included in the superpowers repository you just cloned.
+
+OpenCode will automatically discover it from:
+- `~/.config/opencode/superpowers/.opencode/plugin/superpowers.js`
+
+Or you can link it to the project-local plugin directory:
+
+```bash
+# In your OpenCode project
+mkdir -p .opencode/plugin
+ln -s ~/.config/opencode/superpowers/.opencode/plugin/superpowers.js .opencode/plugin/superpowers.js
+```
+
+### 3. Restart OpenCode
+
+Restart OpenCode to load the plugin. On the next session, you should see:
+
+```
+You have superpowers.
+```
+
+## Usage
+
+### Finding Skills
+
+Use the `find_skills` tool to list all available skills:
+
+```
+use find_skills tool
+```
+
+### Loading a Skill
+
+Use the `use_skill` tool to load a specific skill:
+
+```
+use use_skill tool with skill_name: "superpowers:brainstorming"
+```
+
+### Personal Skills
+
+Create your own skills in `~/.config/opencode/skills/`:
+
+```bash
+mkdir -p ~/.config/opencode/skills/my-skill
+```
+
+Create `~/.config/opencode/skills/my-skill/SKILL.md`:
+
+```markdown
+---
+name: my-skill
+description: Use when [condition] - [what it does]
+---
+
+# My Skill
+
+[Your skill content here]
+```
+
+Personal skills override superpowers skills with the same name.
+
+## Updating
+
+```bash
+cd ~/.config/opencode/superpowers
+git pull
+```
+
+## Troubleshooting
+
+### Plugin not loading
+
+1. Check plugin file exists: `ls ~/.config/opencode/superpowers/.opencode/plugin/superpowers.js`
+2. Check OpenCode logs for errors
+3. Verify Node.js is installed: `node --version`
+
+### Skills not found
+
+1. Verify skills directory exists: `ls ~/.config/opencode/superpowers/skills`
+2. Use `find_skills` tool to see what's discovered
+3. Check file structure: each skill should have a `SKILL.md` file
+
+### Tool mapping issues
+
+When a skill references a Claude Code tool you don't have:
+- `TodoWrite` → use `update_plan`
+- `Task` with subagents → use `@mention` syntax to invoke OpenCode subagents
+- `Skill` → use `use_skill` tool
+- File operations → use your native tools
+
+## Getting Help
+
+- Report issues: https://github.com/obra/superpowers/issues
+- Documentation: https://github.com/obra/superpowers
+```
+
+**Step 2: Verify file created**
+
+Run: `ls -l .opencode/INSTALL.md`
+Expected: File exists
+
+**Step 3: Commit**
+
+```bash
+git add .opencode/INSTALL.md
+git commit -m "docs: add opencode installation guide"
+```
+
+---
+
+### Task 14: Update Main README
+
+**Files:**
+- Modify: `README.md`
+
+**Step 1: Add OpenCode section**
+
+Find the section about supported platforms (search for "Codex" in the file), and add after it:
+
+```markdown
+### OpenCode
+
+Superpowers works with [OpenCode.ai](https://opencode.ai) through a native JavaScript plugin.
+
+**Installation:** See [.opencode/INSTALL.md](.opencode/INSTALL.md)
+
+**Features:**
+- Custom tools: `use_skill` and `find_skills`
+- Automatic session bootstrap
+- Personal skills with shadowing
+- Supporting files and scripts access
+```
+
+**Step 2: Verify formatting**
+
+Run: `grep -A 10 "### OpenCode" README.md`
+Expected: Shows the section you added
+
+**Step 3: Commit**
+
+```bash
+git add README.md
+git commit -m "docs: add opencode support to readme"
+```
+
+---
+
+### Task 15: Update Release Notes
+
+**Files:**
+- Modify: `RELEASE-NOTES.md`
+
+**Step 1: Add entry for OpenCode support**
+
+At the top of the file (after the header), add:
+
+```markdown
+## [Unreleased]
+
+### Added
+
+- **OpenCode Support**: Native JavaScript plugin for OpenCode.ai
+ - Custom tools: `use_skill` and `find_skills`
+ - Automatic session bootstrap with tool mapping instructions
+ - Shared core module (`lib/skills-core.js`) for code reuse
+ - Installation guide in `.opencode/INSTALL.md`
+
+### Changed
+
+- **Refactored Codex Implementation**: Now uses shared `lib/skills-core.js` module
+ - Eliminates code duplication between Codex and OpenCode
+ - Single source of truth for skill discovery and parsing
+
+---
+
+```
+
+**Step 2: Verify formatting**
+
+Run: `head -30 RELEASE-NOTES.md`
+Expected: Shows your new section
+
+**Step 3: Commit**
+
+```bash
+git add RELEASE-NOTES.md
+git commit -m "docs: add opencode support to release notes"
+```
+
+---
+
+## Phase 5: Final Verification
+
+### Task 16: Test Codex Still Works
+
+**Files:**
+- Test: `.codex/superpowers-codex`
+
+**Step 1: Test find-skills command**
+
+Run: `.codex/superpowers-codex find-skills | head -20`
+Expected: Shows list of skills with names and descriptions
+
+**Step 2: Test use-skill command**
+
+Run: `.codex/superpowers-codex use-skill superpowers:brainstorming | head -20`
+Expected: Shows brainstorming skill content
+
+**Step 3: Test bootstrap command**
+
+Run: `.codex/superpowers-codex bootstrap | head -30`
+Expected: Shows bootstrap content with instructions
+
+**Step 4: If all tests pass, record success**
+
+No commit needed - this is verification only.
+
+---
+
+### Task 17: Verify File Structure
+
+**Files:**
+- Check: All new files exist
+
+**Step 1: Verify all files created**
+
+Run:
+```bash
+ls -l lib/skills-core.js
+ls -l .opencode/plugin/superpowers.js
+ls -l .opencode/INSTALL.md
+```
+
+Expected: All files exist
+
+**Step 2: Verify directory structure**
+
+Run: `tree -L 2 .opencode/` (or `find .opencode -type f` if tree not available)
+Expected:
+```
+.opencode/
+├── INSTALL.md
+└── plugin/
+ └── superpowers.js
+```
+
+**Step 3: If structure correct, proceed**
+
+No commit needed - this is verification only.
+
+---
+
+### Task 18: Final Commit and Summary
+
+**Files:**
+- Check: `git status`
+
+**Step 1: Check git status**
+
+Run: `git status`
+Expected: Working tree clean, all changes committed
+
+**Step 2: Review commit log**
+
+Run: `git log --oneline -20`
+Expected: Shows all commits from this implementation
+
+**Step 3: Create summary document**
+
+Create a completion summary showing:
+- Total commits made
+- Files created: `lib/skills-core.js`, `.opencode/plugin/superpowers.js`, `.opencode/INSTALL.md`
+- Files modified: `.codex/superpowers-codex`, `README.md`, `RELEASE-NOTES.md`
+- Testing performed: Codex commands verified
+- Ready for: Testing with actual OpenCode installation
+
+**Step 4: Report completion**
+
+Present summary to user and offer to:
+1. Push to remote
+2. Create pull request
+3. Test with real OpenCode installation (requires OpenCode installed)
+
+---
+
+## Testing Guide (Manual - Requires OpenCode)
+
+These steps require OpenCode to be installed and are not part of the automated implementation:
+
+1. **Install skills**: Follow `.opencode/INSTALL.md`
+2. **Start OpenCode session**: Verify bootstrap appears
+3. **Test find_skills**: Should list all available skills
+4. **Test use_skill**: Load a skill and verify content appears
+5. **Test supporting files**: Verify skill directory paths are accessible
+6. **Test personal skills**: Create a personal skill and verify it shadows core
+7. **Test tool mapping**: Verify TodoWrite → update_plan mapping works
+
+## Success Criteria
+
+- [ ] `lib/skills-core.js` created with all core functions
+- [ ] `.codex/superpowers-codex` refactored to use shared core
+- [ ] Codex commands still work (find-skills, use-skill, bootstrap)
+- [ ] `.opencode/plugin/superpowers.js` created with tools and hooks
+- [ ] Installation guide created
+- [ ] README and RELEASE-NOTES updated
+- [ ] All changes committed
+- [ ] Working tree clean
diff --git a/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-28-skills-improvements-from-user-feedback.md b/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-28-skills-improvements-from-user-feedback.md
new file mode 100644
index 00000000..52a8b0ea
--- /dev/null
+++ b/plugins/cache/superpowers/superpowers/4.0.3/docs/plans/2025-11-28-skills-improvements-from-user-feedback.md
@@ -0,0 +1,711 @@
+# Skills Improvements from User Feedback
+
+**Date:** 2025-11-28
+**Status:** Draft
+**Source:** Two Claude instances using superpowers in real development scenarios
+
+---
+
+## Executive Summary
+
+Two Claude instances provided detailed feedback from actual development sessions. Their feedback reveals **systematic gaps** in current skills that allowed preventable bugs to ship despite following the skills.
+
+**Critical insight:** These are problem reports, not just solution proposals. The problems are real; the solutions need careful evaluation.
+
+**Key themes:**
+1. **Verification gaps** - We verify operations succeed but not that they achieve intended outcomes
+2. **Process hygiene** - Background processes accumulate and interfere across subagents
+3. **Context optimization** - Subagents get too much irrelevant information
+4. **Self-reflection missing** - No prompt to critique own work before handoff
+5. **Mock safety** - Mocks can drift from interfaces without detection
+6. **Skill activation** - Skills exist but aren't being read/used
+
+---
+
+## Problems Identified
+
+### Problem 1: Configuration Change Verification Gap
+
+**What happened:**
+- Subagent tested "OpenAI integration"
+- Set `OPENAI_API_KEY` env var
+- Got status 200 responses
+- Reported "OpenAI integration working"
+- **BUT** response contained `"model": "claude-sonnet-4-20250514"` - was actually using Anthropic
+
+**Root cause:**
+`verification-before-completion` checks operations succeed but not that outcomes reflect intended configuration changes.
+
+**Impact:** High - False confidence in integration tests, bugs ship to production
+
+**Example failure pattern:**
+- Switch LLM provider → verify status 200 but don't check model name
+- Enable feature flag → verify no errors but don't check feature is active
+- Change environment → verify deployment succeeds but don't check environment vars
+
+---
+
+### Problem 2: Background Process Accumulation
+
+**What happened:**
+- Multiple subagents dispatched during session
+- Each started background server processes
+- Processes accumulated (4+ servers running)
+- Stale processes still bound to ports
+- Later E2E test hit stale server with wrong config
+- Confusing/incorrect test results
+
+**Root cause:**
+Subagents are stateless - don't know about previous subagents' processes. No cleanup protocol.
+
+**Impact:** Medium-High - Tests hit wrong server, false passes/failures, debugging confusion
+
+---
+
+### Problem 3: Context Bloat in Subagent Prompts
+
+**What happened:**
+- Standard approach: give subagent full plan file to read
+- Experiment: give only task + pattern + file + verify command
+- Result: Faster, more focused, single-attempt completion more common
+
+**Root cause:**
+Subagents waste tokens and attention on irrelevant plan sections.
+
+**Impact:** Medium - Slower execution, more failed attempts
+
+**What worked:**
+```
+You are adding a single E2E test to packnplay's test suite.
+
+**Your task:** Add `TestE2E_FeaturePrivilegedMode` to `pkg/runner/e2e_test.go`
+
+**What to test:** A local devcontainer feature that requests `"privileged": true`
+in its metadata should result in the container running with `--privileged` flag.
+
+**Follow the exact pattern of TestE2E_FeatureOptionValidation** (at the end of the file)
+
+**After writing, run:** `go test -v ./pkg/runner -run TestE2E_FeaturePrivilegedMode -timeout 5m`
+```
+
+---
+
+### Problem 4: No Self-Reflection Before Handoff
+
+**What happened:**
+- Added self-reflection prompt: "Look at your work with fresh eyes - what could be better?"
+- Implementer for Task 5 identified failing test was due to implementation bug, not test bug
+- Traced to line 99: `strings.Join(metadata.Entrypoint, " ")` creating invalid Docker syntax
+- Without self-reflection, would have just reported "test fails" without root cause
+
+**Root cause:**
+Implementers don't naturally step back and critique their own work before reporting completion.
+
+**Impact:** Medium - Bugs handed off to reviewer that implementer could have caught
+
+---
+
+### Problem 5: Mock-Interface Drift
+
+**What happened:**
+```typescript
+// Interface defines close()
+interface PlatformAdapter {
+ close(): Promise;
+}
+
+// Code (BUGGY) calls cleanup()
+await adapter.cleanup();
+
+// Mock (MATCHES BUG) defines cleanup()
+vi.mock('web-adapter', () => ({
+ WebAdapter: vi.fn().mockImplementation(() => ({
+ cleanup: vi.fn().mockResolvedValue(undefined), // Wrong!
+ })),
+}));
+```
+- Tests passed
+- Runtime crashed: "adapter.cleanup is not a function"
+
+**Root cause:**
+Mock derived from what buggy code calls, not from interface definition. TypeScript can't catch inline mocks with wrong method names.
+
+**Impact:** High - Tests give false confidence, runtime crashes
+
+**Why testing-anti-patterns didn't prevent this:**
+The skill covers testing mock behavior and mocking without understanding, but not the specific pattern of "derive mock from interface, not implementation."
+
+---
+
+### Problem 6: Code Reviewer File Access
+
+**What happened:**
+- Code reviewer subagent dispatched
+- Couldn't find test file: "The file doesn't appear to exist in the repository"
+- File actually exists
+- Reviewer didn't know to explicitly read it first
+
+**Root cause:**
+Reviewer prompts don't include explicit file reading instructions.
+
+**Impact:** Low-Medium - Reviews fail or incomplete
+
+---
+
+### Problem 7: Fix Workflow Latency
+
+**What happened:**
+- Implementer identifies bug during self-reflection
+- Implementer knows the fix
+- Current workflow: report → I dispatch fixer → fixer fixes → I verify
+- Extra round-trip adds latency without adding value
+
+**Root cause:**
+Rigid separation between implementer and fixer roles when implementer has already diagnosed.
+
+**Impact:** Low - Latency, but no correctness issue
+
+---
+
+### Problem 8: Skills Not Being Read
+
+**What happened:**
+- `testing-anti-patterns` skill exists
+- Neither human nor subagents read it before writing tests
+- Would have prevented some issues (though not all - see Problem 5)
+
+**Root cause:**
+No enforcement that subagents read relevant skills. No prompt includes skill reading.
+
+**Impact:** Medium - Skill investment wasted if not used
+
+---
+
+## Proposed Improvements
+
+### 1. verification-before-completion: Add Configuration Change Verification
+
+**Add new section:**
+
+```markdown
+## Verifying Configuration Changes
+
+When testing changes to configuration, providers, feature flags, or environment:
+
+**Don't just verify the operation succeeded. Verify the output reflects the intended change.**
+
+### Common Failure Pattern
+
+Operation succeeds because *some* valid config exists, but it's not the config you intended to test.
+
+### Examples
+
+| Change | Insufficient | Required |
+|--------|-------------|----------|
+| Switch LLM provider | Status 200 | Response contains expected model name |
+| Enable feature flag | No errors | Feature behavior actually active |
+| Change environment | Deploy succeeds | Logs/vars reference new environment |
+| Set credentials | Auth succeeds | Authenticated user/context is correct |
+
+### Gate Function
+
+```
+BEFORE claiming configuration change works:
+
+1. IDENTIFY: What should be DIFFERENT after this change?
+2. LOCATE: Where is that difference observable?
+ - Response field (model name, user ID)
+ - Log line (environment, provider)
+ - Behavior (feature active/inactive)
+3. RUN: Command that shows the observable difference
+4. VERIFY: Output contains expected difference
+5. ONLY THEN: Claim configuration change works
+
+Red flags:
+ - "Request succeeded" without checking content
+ - Checking status code but not response body
+ - Verifying no errors but not positive confirmation
+```
+
+**Why this works:**
+Forces verification of INTENT, not just operation success.
+
+---
+
+### 2. subagent-driven-development: Add Process Hygiene for E2E Tests
+
+**Add new section:**
+
+```markdown
+## Process Hygiene for E2E Tests
+
+When dispatching subagents that start services (servers, databases, message queues):
+
+### Problem
+
+Subagents are stateless - they don't know about processes started by previous subagents. Background processes persist and can interfere with later tests.
+
+### Solution
+
+**Before dispatching E2E test subagent, include cleanup in prompt:**
+
+```
+BEFORE starting any services:
+1. Kill existing processes: pkill -f "" 2>/dev/null || true
+2. Wait for cleanup: sleep 1
+3. Verify port free: lsof -i : && echo "ERROR: Port still in use" || echo "Port free"
+
+AFTER tests complete:
+1. Kill the process you started
+2. Verify cleanup: pgrep -f "" || echo "Cleanup successful"
+```
+
+### Example
+
+```
+Task: Run E2E test of API server
+
+Prompt includes:
+"Before starting the server:
+- Kill any existing servers: pkill -f 'node.*server.js' 2>/dev/null || true
+- Verify port 3001 is free: lsof -i :3001 && exit 1 || echo 'Port available'
+
+After tests:
+- Kill the server you started
+- Verify: pgrep -f 'node.*server.js' || echo 'Cleanup verified'"
+```
+
+### Why This Matters
+
+- Stale processes serve requests with wrong config
+- Port conflicts cause silent failures
+- Process accumulation slows system
+- Confusing test results (hitting wrong server)
+```
+
+**Trade-off analysis:**
+- Adds boilerplate to prompts
+- But prevents very confusing debugging
+- Worth it for E2E test subagents
+
+---
+
+### 3. subagent-driven-development: Add Lean Context Option
+
+**Modify Step 2: Execute Task with Subagent**
+
+**Before:**
+```
+Read that task carefully from [plan-file].
+```
+
+**After:**
+```
+## Context Approaches
+
+**Full Plan (default):**
+Use when tasks are complex or have dependencies:
+```
+Read Task N from [plan-file] carefully.
+```
+
+**Lean Context (for independent tasks):**
+Use when task is standalone and pattern-based:
+```
+You are implementing: [1-2 sentence task description]
+
+File to modify: [exact path]
+Pattern to follow: [reference to existing function/test]
+What to implement: [specific requirement]
+Verification: [exact command to run]
+
+[Do NOT include full plan file]
+```
+
+**Use lean context when:**
+- Task follows existing pattern (add similar test, implement similar feature)
+- Task is self-contained (doesn't need context from other tasks)
+- Pattern reference is sufficient (e.g., "follow TestE2E_FeatureOptionValidation")
+
+**Use full plan when:**
+- Task has dependencies on other tasks
+- Requires understanding of overall architecture
+- Complex logic that needs context
+```
+
+**Example:**
+```
+Lean context prompt:
+
+"You are adding a test for privileged mode in devcontainer features.
+
+File: pkg/runner/e2e_test.go
+Pattern: Follow TestE2E_FeatureOptionValidation (at end of file)
+Test: Feature with `"privileged": true` in metadata results in `--privileged` flag
+Verify: go test -v ./pkg/runner -run TestE2E_FeaturePrivilegedMode -timeout 5m
+
+Report: Implementation, test results, any issues."
+```
+
+**Why this works:**
+Reduces token usage, increases focus, faster completion when appropriate.
+
+---
+
+### 4. subagent-driven-development: Add Self-Reflection Step
+
+**Modify Step 2: Execute Task with Subagent**
+
+**Add to prompt template:**
+
+```
+When done, BEFORE reporting back:
+
+Take a step back and review your work with fresh eyes.
+
+Ask yourself:
+- Does this actually solve the task as specified?
+- Are there edge cases I didn't consider?
+- Did I follow the pattern correctly?
+- If tests are failing, what's the ROOT CAUSE (implementation bug vs test bug)?
+- What could be better about this implementation?
+
+If you identify issues during this reflection, fix them now.
+
+Then report:
+- What you implemented
+- Self-reflection findings (if any)
+- Test results
+- Files changed
+```
+
+**Why this works:**
+Catches bugs implementer can find themselves before handoff. Documented case: identified entrypoint bug through self-reflection.
+
+**Trade-off:**
+Adds ~30 seconds per task, but catches issues before review.
+
+---
+
+### 5. requesting-code-review: Add Explicit File Reading
+
+**Modify the code-reviewer template:**
+
+**Add at the beginning:**
+
+```markdown
+## Files to Review
+
+BEFORE analyzing, read these files:
+
+1. [List specific files that changed in the diff]
+2. [Files referenced by changes but not modified]
+
+Use Read tool to load each file.
+
+If you cannot find a file:
+- Check exact path from diff
+- Try alternate locations
+- Report: "Cannot locate [path] - please verify file exists"
+
+DO NOT proceed with review until you've read the actual code.
+```
+
+**Why this works:**
+Explicit instruction prevents "file not found" issues.
+
+---
+
+### 6. testing-anti-patterns: Add Mock-Interface Drift Anti-Pattern
+
+**Add new Anti-Pattern 6:**
+
+```markdown
+## Anti-Pattern 6: Mocks Derived from Implementation
+
+**The violation:**
+```typescript
+// Code (BUGGY) calls cleanup()
+await adapter.cleanup();
+
+// Mock (MATCHES BUG) has cleanup()
+const mock = {
+ cleanup: vi.fn().mockResolvedValue(undefined)
+};
+
+// Interface (CORRECT) defines close()
+interface PlatformAdapter {
+ close(): Promise;
+}
+```
+
+**Why this is wrong:**
+- Mock encodes the bug into the test
+- TypeScript can't catch inline mocks with wrong method names
+- Test passes because both code and mock are wrong
+- Runtime crashes when real object is used
+
+**The fix:**
+```typescript
+// ✅ GOOD: Derive mock from interface
+
+// Step 1: Open interface definition (PlatformAdapter)
+// Step 2: List methods defined there (close, initialize, etc.)
+// Step 3: Mock EXACTLY those methods
+
+const mock = {
+ initialize: vi.fn().mockResolvedValue(undefined),
+ close: vi.fn().mockResolvedValue(undefined), // From interface!
+};
+
+// Now test FAILS because code calls cleanup() which doesn't exist
+// That failure reveals the bug BEFORE runtime
+```
+
+### Gate Function
+
+```
+BEFORE writing any mock:
+
+ 1. STOP - Do NOT look at the code under test yet
+ 2. FIND: The interface/type definition for the dependency
+ 3. READ: The interface file
+ 4. LIST: Methods defined in the interface
+ 5. MOCK: ONLY those methods with EXACTLY those names
+ 6. DO NOT: Look at what your code calls
+
+ IF your test fails because code calls something not in mock:
+ ✅ GOOD - The test found a bug in your code
+ Fix the code to call the correct interface method
+ NOT the mock
+
+ Red flags:
+ - "I'll mock what the code calls"
+ - Copying method names from implementation
+ - Mock written without reading interface
+ - "The test is failing so I'll add this method to the mock"
+```
+
+**Detection:**
+
+When you see runtime error "X is not a function" and tests pass:
+1. Check if X is mocked
+2. Compare mock methods to interface methods
+3. Look for method name mismatches
+```
+
+**Why this works:**
+Directly addresses the failure pattern from feedback.
+
+---
+
+### 7. subagent-driven-development: Require Skills Reading for Test Subagents
+
+**Add to prompt template when task involves testing:**
+
+```markdown
+BEFORE writing any tests:
+
+1. Read testing-anti-patterns skill:
+ Use Skill tool: superpowers:testing-anti-patterns
+
+2. Apply gate functions from that skill when:
+ - Writing mocks
+ - Adding methods to production classes
+ - Mocking dependencies
+
+This is NOT optional. Tests that violate anti-patterns will be rejected in review.
+```
+
+**Why this works:**
+Ensures skills are actually used, not just exist.
+
+**Trade-off:**
+Adds time to each task, but prevents entire classes of bugs.
+
+---
+
+### 8. subagent-driven-development: Allow Implementer to Fix Self-Identified Issues
+
+**Modify Step 2:**
+
+**Current:**
+```
+Subagent reports back with summary of work.
+```
+
+**Proposed:**
+```
+Subagent performs self-reflection, then:
+
+IF self-reflection identifies fixable issues:
+ 1. Fix the issues
+ 2. Re-run verification
+ 3. Report: "Initial implementation + self-reflection fix"
+
+ELSE:
+ Report: "Implementation complete"
+
+Include in report:
+- Self-reflection findings
+- Whether fixes were applied
+- Final verification results
+```
+
+**Why this works:**
+Reduces latency when implementer already knows the fix. Documented case: would have saved one round-trip for entrypoint bug.
+
+**Trade-off:**
+Slightly more complex prompt, but faster end-to-end.
+
+---
+
+## Implementation Plan
+
+### Phase 1: High-Impact, Low-Risk (Do First)
+
+1. **verification-before-completion: Configuration change verification**
+ - Clear addition, doesn't change existing content
+ - Addresses high-impact problem (false confidence in tests)
+ - File: `skills/verification-before-completion/SKILL.md`
+
+2. **testing-anti-patterns: Mock-interface drift**
+ - Adds new anti-pattern, doesn't modify existing
+ - Addresses high-impact problem (runtime crashes)
+ - File: `skills/testing-anti-patterns/SKILL.md`
+
+3. **requesting-code-review: Explicit file reading**
+ - Simple addition to template
+ - Fixes concrete problem (reviewers can't find files)
+ - File: `skills/requesting-code-review/SKILL.md`
+
+### Phase 2: Moderate Changes (Test Carefully)
+
+4. **subagent-driven-development: Process hygiene**
+ - Adds new section, doesn't change workflow
+ - Addresses medium-high impact (test reliability)
+ - File: `skills/subagent-driven-development/SKILL.md`
+
+5. **subagent-driven-development: Self-reflection**
+ - Changes prompt template (higher risk)
+ - But documented to catch bugs
+ - File: `skills/subagent-driven-development/SKILL.md`
+
+6. **subagent-driven-development: Skills reading requirement**
+ - Adds prompt overhead
+ - But ensures skills are actually used
+ - File: `skills/subagent-driven-development/SKILL.md`
+
+### Phase 3: Optimization (Validate First)
+
+7. **subagent-driven-development: Lean context option**
+ - Adds complexity (two approaches)
+ - Needs validation that it doesn't cause confusion
+ - File: `skills/subagent-driven-development/SKILL.md`
+
+8. **subagent-driven-development: Allow implementer to fix**
+ - Changes workflow (higher risk)
+ - Optimization, not bug fix
+ - File: `skills/subagent-driven-development/SKILL.md`
+
+---
+
+## Open Questions
+
+1. **Lean context approach:**
+ - Should we make it the default for pattern-based tasks?
+ - How do we decide which approach to use?
+ - Risk of being too lean and missing important context?
+
+2. **Self-reflection:**
+ - Will this slow down simple tasks significantly?
+ - Should it only apply to complex tasks?
+ - How do we prevent "reflection fatigue" where it becomes rote?
+
+3. **Process hygiene:**
+ - Should this be in subagent-driven-development or a separate skill?
+ - Does it apply to other workflows beyond E2E tests?
+ - How do we handle cases where process SHOULD persist (dev servers)?
+
+4. **Skills reading enforcement:**
+ - Should we require ALL subagents to read relevant skills?
+ - How do we keep prompts from becoming too long?
+ - Risk of over-documenting and losing focus?
+
+---
+
+## Success Metrics
+
+How do we know these improvements work?
+
+1. **Configuration verification:**
+ - Zero instances of "test passed but wrong config was used"
+ - Jesse doesn't say "that's not actually testing what you think"
+
+2. **Process hygiene:**
+ - Zero instances of "test hit wrong server"
+ - No port conflict errors during E2E test runs
+
+3. **Mock-interface drift:**
+ - Zero instances of "tests pass but runtime crashes on missing method"
+ - No method name mismatches between mocks and interfaces
+
+4. **Self-reflection:**
+ - Measurable: Do implementer reports include self-reflection findings?
+ - Qualitative: Do fewer bugs make it to code review?
+
+5. **Skills reading:**
+ - Subagent reports reference skill gate functions
+ - Fewer anti-pattern violations in code review
+
+---
+
+## Risks and Mitigations
+
+### Risk: Prompt Bloat
+**Problem:** Adding all these requirements makes prompts overwhelming
+**Mitigation:**
+- Phase implementation (don't add everything at once)
+- Make some additions conditional (E2E hygiene only for E2E tests)
+- Consider templates for different task types
+
+### Risk: Analysis Paralysis
+**Problem:** Too much reflection/verification slows execution
+**Mitigation:**
+- Keep gate functions quick (seconds, not minutes)
+- Make lean context opt-in initially
+- Monitor task completion times
+
+### Risk: False Sense of Security
+**Problem:** Following checklist doesn't guarantee correctness
+**Mitigation:**
+- Emphasize gate functions are minimums, not maximums
+- Keep "use judgment" language in skills
+- Document that skills catch common failures, not all failures
+
+### Risk: Skill Divergence
+**Problem:** Different skills give conflicting advice
+**Mitigation:**
+- Review changes across all skills for consistency
+- Document how skills interact (Integration sections)
+- Test with real scenarios before deployment
+
+---
+
+## Recommendation
+
+**Proceed with Phase 1 immediately:**
+- verification-before-completion: Configuration change verification
+- testing-anti-patterns: Mock-interface drift
+- requesting-code-review: Explicit file reading
+
+**Test Phase 2 with Jesse before finalizing:**
+- Get feedback on self-reflection impact
+- Validate process hygiene approach
+- Confirm skills reading requirement is worth overhead
+
+**Hold Phase 3 pending validation:**
+- Lean context needs real-world testing
+- Implementer-fix workflow change needs careful evaluation
+
+These changes address real problems documented by users while minimizing risk of making skills worse.
diff --git a/skills/ralph/__pycache__/agent_capability_registry.cpython-312.pyc b/skills/ralph/__pycache__/agent_capability_registry.cpython-312.pyc
new file mode 100644
index 00000000..d7fcc5ba
Binary files /dev/null and b/skills/ralph/__pycache__/agent_capability_registry.cpython-312.pyc differ
diff --git a/skills/ralph/__pycache__/dynamic_agent_selector.cpython-312.pyc b/skills/ralph/__pycache__/dynamic_agent_selector.cpython-312.pyc
new file mode 100644
index 00000000..de5fc972
Binary files /dev/null and b/skills/ralph/__pycache__/dynamic_agent_selector.cpython-312.pyc differ
diff --git a/skills/ralph/__pycache__/meta_agent_orchestrator.cpython-312.pyc b/skills/ralph/__pycache__/meta_agent_orchestrator.cpython-312.pyc
new file mode 100644
index 00000000..4ff8095c
Binary files /dev/null and b/skills/ralph/__pycache__/meta_agent_orchestrator.cpython-312.pyc differ
diff --git a/skills/ralph/__pycache__/ralph_agent_integration.cpython-312.pyc b/skills/ralph/__pycache__/ralph_agent_integration.cpython-312.pyc
new file mode 100644
index 00000000..a552bb88
Binary files /dev/null and b/skills/ralph/__pycache__/ralph_agent_integration.cpython-312.pyc differ
diff --git a/supercharge.sh b/supercharge.sh
index c6399005..494328c4 100755
--- a/supercharge.sh
+++ b/supercharge.sh
@@ -1,28 +1,26 @@
#!/bin/bash
################################################################################
-# SuperCharge Claude Code - Ultimate Installation Script
+# SuperCharge Claude Code - Ultimate Installation Script v3.0
################################################################################
# This script transforms any Claude Code installation into a supercharged
# version with all customizations, skills, agents, plugins, and integrations.
#
-# Features:
-# - 30+ Custom Skills (cognitive, development, UI/UX, brainstorming)
+# Features v3.0:
+# - 291 Custom Skills (cognitive, development, UI/UX, brainstorming, agents)
# - RalphLoop autonomous agent integration
+# - Prometheus code analysis integration (6 commands)
+# - Dexto multi-agent harness (12 commands)
+# - Clawd autonomous gateway
+# - Intelligent auto-routing system
# - Multi-AI consultation (Qwen integration)
# - Agent management system with sync capabilities
# - Custom hooks for session management
-# - MCP servers integration
+# - MCP servers integration (10 servers)
# - Plugin marketplace setup
-# - Optional Claude Code installation with Z.AI API support
#
# Usage: ./supercharge.sh [options]
# --skip-deps Skip dependency installation
# --dev-mode Development mode (verbose output)
-#
-# For Claude Code installation: ./install-claude-code.sh [options]
-# --auto Automatic installation with API key prompt (default)
-# --manual Show manual installation steps only
-# --skip-install Skip Claude Code installation, just configure API
################################################################################
set -e
@@ -93,6 +91,8 @@ print_banner() {
║ ╚══════╝╚═╝╚═╝╚═╝╚══════╝╚═╝ ╚═══╝ ║
║ ║
║ Ultimate Installation Script ║
+║ Version 3.0 ║
+║ 291 Skills • 21 Commands • 10 MCP Servers ║
║ ║
╚═══════════════════════════════════════════════════════════════╝
EOF
@@ -189,16 +189,32 @@ install_dependencies() {
log_success "Git found: $(git --version)"
fi
- # Install Ralph Orchestrator (Python package for /ralph autonomous agent)
+ # Install Ralph Orchestrator
+ install_ralph_orchestrator
+
+ # Install Prometheus Integration
+ install_prometheus_integration
+
+ # Install Dexto Integration
+ install_dexto_integration
+
+ # Install Clawd Gateway
+ install_clawd_gateway
+
+ # Configure MCP Servers
+ configure_mcp_servers
+}
+
+install_ralph_orchestrator() {
+ log_step "Installing Ralph Orchestrator..."
+
RALPH_INSTALLED=false
- # Check if ralph command exists
if command -v ralph &> /dev/null; then
- log_success "Ralph Orchestrator found: $(ralph --version 2>/dev/null || echo 'installed')"
+ log_success "Ralph Orchestrator found: $(ralph --version 2>/dev/null || echo installed)"
RALPH_INSTALLED=true
fi
- # Check if Python package is installed
if python3 -c "import ralph_orchestrator" 2>/dev/null; then
if [ "$RALPH_INSTALLED" = false ]; then
log_success "Ralph Orchestrator Python package found"
@@ -206,50 +222,105 @@ install_dependencies() {
fi
fi
- # Install if not found
if [ "$RALPH_INSTALLED" = false ]; then
log_info "Installing Ralph Orchestrator..."
if command -v pip3 &> /dev/null; then
- # Try installing from requirements.txt if it exists in script dir
if [ -f "$SCRIPT_DIR/requirements.txt" ]; then
log_info "Installing from requirements.txt..."
pip3 install -r "$SCRIPT_DIR/requirements.txt" 2>/dev/null && {
log_success "Ralph Orchestrator installed from requirements.txt"
} || {
- # Fallback to direct install
log_warn "requirements.txt install failed, trying direct install..."
pip3 install ralph-orchestrator pyyaml 2>/dev/null || {
- log_error "Failed to install Ralph Orchestrator"
- echo ""
- echo -e "${YELLOW}Ralph Orchestrator is required for /ralph command${NC}"
- echo "Install manually:"
- echo " pip3 install ralph-orchestrator"
- echo ""
- echo "The /ralph command will not work without it."
+ log_warn "Failed to install Ralph Orchestrator"
}
}
else
- # Direct install
- pip3 install ralph-orchestrator pyyaml 2>/dev/null && {
- log_success "Ralph Orchestrator installed"
- } || {
+ pip3 install ralph-orchestrator pyyaml 2>/dev/null || {
log_warn "Failed to install Ralph Orchestrator"
}
fi
else
log_warn "pip3 not found. Skipping Ralph Orchestrator installation."
- echo ""
- echo -e "${YELLOW}Install pip3 first:${NC}"
- echo " sudo apt-get install python3-pip"
- echo " Then: pip3 install ralph-orchestrator"
fi
fi
- # Verify installation
if command -v ralph &> /dev/null || python3 -c "import ralph_orchestrator" 2>/dev/null; then
- log_success "Ralph Orchestrator ready for /ralph command"
+ log_success "Ralph Orchestrator ready"
else
- log_warn "Ralph Orchestrator not available - /ralph command will use fallback mode"
+ log_warn "Ralph Orchestrator not available - /ralph will use fallback mode"
+ fi
+}
+
+install_prometheus_integration() {
+ log_step "Installing Prometheus Integration..."
+
+ if [ -d "$SCRIPT_DIR/prometheus" ]; then
+ mkdir -p "$CLAUDE_DIR/prometheus"
+ cp -r "$SCRIPT_DIR/prometheus/"* "$CLAUDE_DIR/prometheus/" 2>/dev/null || true
+ log_success "Prometheus integration installed (6 commands)"
+ else
+ log_warn "Prometheus directory not found"
+ fi
+}
+
+install_dexto_integration() {
+ log_step "Installing Dexto Integration..."
+
+ if [ -d "$SCRIPT_DIR/dexto" ]; then
+ mkdir -p "$CLAUDE_DIR/dexto"
+ cp -r "$SCRIPT_DIR/dexto/"* "$CLAUDE_DIR/dexto/" 2>/dev/null || true
+ log_success "Dexto integration installed (12 commands)"
+ else
+ log_warn "Dexto directory not found"
+ fi
+}
+
+install_clawd_gateway() {
+ log_step "Installing Clawd Gateway..."
+
+ if [ -d "$SCRIPT_DIR/clawd" ]; then
+ mkdir -p "$CLAUDE_DIR/clawd"
+ cp -r "$SCRIPT_DIR/clawd/"* "$CLAUDE_DIR/clawd/" 2>/dev/null || true
+
+ # Setup Python virtual environment if needed
+ if [ -f "$CLAUDE_DIR/clawd/gateway/requirements.txt" ]; then
+ if [ ! -d "$CLAUDE_DIR/clawd/gateway/venv" ]; then
+ log_info "Setting up Clawd gateway virtual environment..."
+ python3 -m venv "$CLAUDE_DIR/clawd/gateway/venv" 2>/dev/null || {
+ log_warn "Failed to create virtual environment"
+ }
+ fi
+
+ if [ -d "$CLAUDE_DIR/clawd/gateway/venv" ]; then
+ "$CLAUDE_DIR/clawd/gateway/venv/bin/pip" install -r "$CLAUDE_DIR/clawd/gateway/requirements.txt" 2>/dev/null || {
+ log_warn "Failed to install Clawd dependencies"
+ }
+ fi
+ fi
+
+ log_success "Clawd gateway installed"
+ else
+ log_warn "Clawd directory not found"
+ fi
+}
+
+configure_mcp_servers() {
+ log_step "Configuring MCP Servers..."
+
+ mkdir -p "$CLAUDE_DIR/mcp-servers"
+
+ if [ -f "$SCRIPT_DIR/mcp-servers/registry.json" ]; then
+ cp "$SCRIPT_DIR/mcp-servers/registry.json" "$CLAUDE_DIR/mcp-servers/"
+ log_success "MCP servers registry configured (10 servers)"
+ else
+ log_warn "MCP servers registry not found"
+ fi
+
+ if [ -f "$SCRIPT_DIR/mcp-servers/manager.sh" ]; then
+ cp "$SCRIPT_DIR/mcp-servers/manager.sh" "$CLAUDE_DIR/mcp-servers/"
+ chmod +x "$CLAUDE_DIR/mcp-servers/manager.sh"
+ log_success "MCP servers manager installed"
fi
}
@@ -258,11 +329,10 @@ install_skills() {
mkdir -p "$CLAUDE_DIR/skills"
- # Copy all skills
if [ -d "$SCRIPT_DIR/skills" ]; then
cp -r "$SCRIPT_DIR/skills/"* "$CLAUDE_DIR/skills/" 2>/dev/null || true
- local skill_count=$(find "$SCRIPT_DIR/skills" -name "SKILL.md" | wc -l)
- log_success "Installed $skill_count custom skills"
+ local skill_count=$(find "$SCRIPT_DIR/skills" -name "SKILL.md" 2>/dev/null | wc -l)
+ log_success "Installed ${skill_count:-291} custom skills"
else
log_warn "Skills directory not found"
fi
@@ -277,7 +347,6 @@ install_agents() {
cp -r "$SCRIPT_DIR/agents/"* "$CLAUDE_DIR/agents/" 2>/dev/null || true
log_success "Agent management system installed"
- # Make scripts executable
find "$CLAUDE_DIR/agents" -name "*.sh" -exec chmod +x {} \;
else
log_warn "Agents directory not found"
@@ -292,18 +361,16 @@ install_hooks() {
if [ -d "$SCRIPT_DIR/hooks" ]; then
cp -r "$SCRIPT_DIR/hooks/"* "$CLAUDE_DIR/hooks/" 2>/dev/null || true
- # Make hook scripts executable
find "$CLAUDE_DIR/hooks" -name "*.sh" -exec chmod +x {} \;
- log_success "Custom hooks installed"
+ log_success "Custom hooks installed (intelligent routing enabled)"
else
log_warn "Hooks directory not found"
fi
- # Install hooks.json if it doesn't exist
- if [ -f "$SCRIPT_DIR/templates/hooks.json" ] && [ ! -f "$CLAUDE_DIR/hooks.json" ]; then
- cp "$SCRIPT_DIR/templates/hooks.json" "$CLAUDE_DIR/hooks.json"
- log_success "Hooks configuration installed"
+ if [ -f "$SCRIPT_DIR/hooks.json" ]; then
+ cp "$SCRIPT_DIR/hooks.json" "$CLAUDE_DIR/hooks.json"
+ log_success "Hooks configuration (v5) installed"
fi
}
@@ -315,21 +382,20 @@ install_commands() {
if [ -d "$SCRIPT_DIR/commands" ]; then
cp -r "$SCRIPT_DIR/commands/"* "$CLAUDE_DIR/commands/" 2>/dev/null || true
local cmd_count=$(ls -1 "$SCRIPT_DIR/commands" 2>/dev/null | wc -l)
- log_success "Installed $cmd_count custom commands"
+ log_success "Installed ${cmd_count:-21} custom commands"
else
log_warn "Commands directory not found"
fi
}
install_plugins() {
- log_step "Installing plugin references..."
+ log_step "Installing plugin marketplace..."
mkdir -p "$CLAUDE_DIR/plugins"
if [ -d "$SCRIPT_DIR/plugins" ]; then
cp -r "$SCRIPT_DIR/plugins/"* "$CLAUDE_DIR/plugins/" 2>/dev/null || true
- local plugin_count=$(find "$SCRIPT_DIR/plugins" -type d -mindepth 1 | wc -l)
- log_success "Installed $plugin_count plugin references"
+ log_success "Plugin marketplace configured"
else
log_warn "Plugins directory not found"
fi
@@ -344,7 +410,6 @@ install_binaries() {
cp "$SCRIPT_DIR/bin/ralphloop" "$HOME/.local/bin/"
chmod +x "$HOME/.local/bin/ralphloop"
- # Add to PATH if not already there
if ! echo "$PATH" | grep -q "$HOME/.local/bin"; then
echo "" >> "$HOME/.bashrc"
echo "# SuperCharge Claude Code - Add local bin to PATH" >> "$HOME/.bashrc"
@@ -366,7 +431,6 @@ install_scripts() {
if [ -d "$SCRIPT_DIR/scripts" ]; then
cp -r "$SCRIPT_DIR/scripts/"* "$CLAUDE_DIR/scripts/" 2>/dev/null || true
- # Make scripts executable
find "$CLAUDE_DIR/scripts" -name "*.sh" -exec chmod +x {} \;
log_success "Utility scripts installed"
@@ -379,38 +443,29 @@ install_config_templates() {
log_step "Installing configuration templates..."
if [ -d "$SCRIPT_DIR/templates" ]; then
- # Install config.json if not exists
if [ -f "$SCRIPT_DIR/templates/config.json" ] && [ ! -f "$CLAUDE_DIR/config.json" ]; then
cp "$SCRIPT_DIR/templates/config.json" "$CLAUDE_DIR/config.json"
log_success "config.json installed"
fi
- # Merge settings.json
if [ -f "$SCRIPT_DIR/templates/settings.json" ]; then
if [ -f "$CLAUDE_DIR/settings.json" ]; then
- # Merge existing settings with template
local temp_file=$(mktemp)
python3 -c "
import json
-import sys
-
try:
with open('$CLAUDE_DIR/settings.json', 'r') as f:
existing = json.load(f)
except:
existing = {}
-
try:
with open('$SCRIPT_DIR/templates/settings.json', 'r') as f:
template = json.load(f)
except:
template = {}
-
-# Merge: template values take precedence for keys that exist in template
for key in template:
- if key != 'permissions': # Don't override permissions
+ if key != 'permissions':
existing[key] = template[key]
-
with open('$temp_file', 'w') as f:
json.dump(existing, f, indent=2)
" 2>/dev/null || cp "$SCRIPT_DIR/templates/settings.json" "$temp_file"
@@ -420,12 +475,6 @@ with open('$temp_file', 'w') as f:
fi
log_success "settings.json configured"
fi
-
- # Install settings.local.json if not exists
- if [ -f "$SCRIPT_DIR/templates/settings.local.json" ] && [ ! -f "$CLAUDE_DIR/settings.local.json" ]; then
- cp "$SCRIPT_DIR/templates/settings.local.json" "$CLAUDE_DIR/settings.local.json"
- log_success "settings.local.json installed"
- fi
fi
}
@@ -443,39 +492,70 @@ sync_agents() {
print_summary() {
echo ""
echo -e "${GREEN}${BOLD}╔═══════════════════════════════════════════════════════════════╗${NC}"
- echo -e "${GREEN}${BOLD}║ INSTALLATION COMPLETE! ║${NC}"
+ echo -e "${GREEN}${BOLD}║ INSTALLATION COMPLETE v3.0! ║${NC}"
echo -e "${GREEN}${BOLD}╚═══════════════════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "${BOLD}Your Claude Code installation is now SUPERCHARGED!${NC}"
echo ""
echo -e "${CYAN}Installed Features:${NC}"
- echo -e " ${GREEN}✓${NC} 30+ Custom Skills (cognitive, development, UI/UX)"
- echo -e " ${GREEN}✓${NC} RalphLoop Autonomous Agent Integration"
+ echo -e " ${GREEN}✓${NC} 291 Custom Skills (cognitive, development, UI/UX, agents)"
+ echo -e " ${GREEN}✓${NC} RalphLoop Autonomous Agent"
+ echo -e " ${GREEN}✓${NC} Prometheus Code Analysis (6 commands)"
+ echo -e " ${GREEN}✓${NC} Dexto Multi-Agent Harness (12 commands)"
+ echo -e " ${GREEN}✓${NC} Clawd Autonomous Gateway"
+ echo -e " ${GREEN}✓${NC} Intelligent Auto-Routing System"
echo -e " ${GREEN}✓${NC} Multi-AI Consultation (Qwen)"
- echo -e " ${GREEN}✓${NC} Agent Management System"
- echo -e " ${GREEN}✓${NC} Custom Hooks & Commands"
- echo -e " ${GREEN}✓${NC} Plugin Marketplace Setup"
+ echo -e " ${GREEN}✓${NC} 10 MCP Servers Configured"
+ echo -e " ${GREEN}✓${NC} Plugin Marketplace"
echo ""
- echo -e "${CYAN}New Commands Available:${NC}"
- echo -e " ${YELLOW}/ralph${NC} - Autonomous \"Tackle Until Solved\" agent"
- echo -e " ${YELLOW}/brainstorm${NC} - Multi-AI brainstorming session"
- echo -e " ${YELLOW}/write-plan${NC} - Create implementation plans"
- echo -e " ${YELLOW}/execute-plan${NC} - Execute written plans"
+ echo -e "${CYAN}Available Commands (21 total):${NC}"
+ echo ""
+ echo -e "${BOLD}Autonomous Agents:${NC}"
+ echo -e " ${YELLOW}/clawd${NC} - Fully autonomous task execution"
+ echo -e " ${YELLOW}/ralph${NC} - Iterative architecture & orchestration"
+ echo ""
+ echo -e "${BOLD}Prometheus (Code Analysis):${NC}"
+ echo -e " ${YELLOW}/prometheus${NC} - Master command (auto-routes to sub-agent)"
+ echo -e " ${YELLOW}/prometheus-bug${NC} - Bug analysis and fixing"
+ echo -e " ${YELLOW}/prometheus-feature${NC} - Feature implementation"
+ echo -e " ${YELLOW}/prometheus-context${NC} - Code context understanding"
+ echo -e " ${YELLOW}/prometheus-edit${NC} - Code editing and refactoring"
+ echo -e " ${YELLOW}/prometheus-test${NC} - Test generation and validation"
+ echo -e " ${YELLOW}/prometheus-classify${NC} - Issue classification"
+ echo ""
+ echo -e "${BOLD}Dexto (Specialized Agents):${NC}"
+ echo -e " ${YELLOW}/dexto${NC} - Master command (auto-routes to sub-agent)"
+ echo -e " ${YELLOW}/dexto-code${NC} - Code analysis and generation"
+ echo -e " ${YELLOW}/dexto-database${NC} - Database optimization"
+ echo -e " ${YELLOW}/dexto-github${NC} - GitHub PR/issue analysis"
+ echo -e " ${YELLOW}/dexto-pdf${NC} - PDF document analysis"
+ echo -e " ${YELLOW}/dexto-image-edit${NC}- Image editing and enhancement"
+ echo -e " ${YELLOW}/dexto-nano-banana${NC}- AI image generation"
+ echo -e " ${YELLOW}/dexto-sora${NC} - AI video generation"
+ echo -e " ${YELLOW}/dexto-music${NC} - AI music/audio generation"
+ echo -e " ${YELLOW}/dexto-podcast${NC} - AI podcast generation"
+ echo -e " ${YELLOW}/dexto-research${NC} - Product research and ideation"
+ echo -e " ${YELLOW}/dexto-triage${NC} - Support ticket triage"
+ echo -e " ${YELLOW}/dexto-explore${NC} - Codebase exploration"
+ echo ""
+ echo -e "${CYAN}Intelligent Auto-Routing:${NC}"
+ echo -e " The system automatically detects task patterns and suggests"
+ echo -e " the best agent. Just describe your task naturally!"
echo ""
echo -e "${CYAN}Quick Start:${NC}"
echo -e " 1. Restart your terminal or run: ${YELLOW}source ~/.bashrc${NC}"
echo -e " 2. Run Claude Code: ${YELLOW}claude${NC}"
- echo -e " 3. Try: ${YELLOW}/ralph \"Design a microservices architecture\"${NC}"
+ echo -e " 3. Try any command or just describe your task - auto-routing will help!"
+ echo ""
+ echo -e "${CYAN}Examples:${NC}"
+ echo -e " ${YELLOW}claude${NC} \"Fix the authentication bug\" → Auto-routes to /prometheus-bug"
+ echo -e " ${YELLOW}claude${NC} \"Generate an image of a city\" → Auto-routes to /dexto-nano-banana"
+ echo -e " ${YELLOW}claude${NC} \"Design a microservices architecture\" → Auto-routes to /ralph"
echo ""
echo -e "${CYAN}Configuration:${NC}"
echo -e " Config dir: ${YELLOW}$CLAUDE_DIR${NC}"
echo -e " Backup: ${YELLOW}$BACKUP_DIR${NC}"
echo ""
- echo -e "${CYAN}Optional Configuration:${NC}"
- echo -e " ${YELLOW}export RALPH_AGENT=claude${NC} # Set Ralph agent"
- echo -e " ${YELLOW}export RALPH_MAX_ITERATIONS=100${NC} # Set max iterations"
- echo -e " ${YELLOW}export QWEN_CONSULT_MODE=always${NC} # Qwen consultation mode"
- echo ""
echo -e "${GREEN}${BOLD}Enjoy your supercharged Claude Code experience!${NC}"
echo ""
}
@@ -487,7 +567,6 @@ print_summary() {
main() {
print_banner
- # Parse arguments
while [[ $# -gt 0 ]]; do
case $1 in
--skip-deps)
@@ -512,7 +591,6 @@ main() {
esac
done
- # Run installation steps
if ! check_claude_code; then
log_info "Customizations installed. Install Claude Code to use them."
echo ""
@@ -537,5 +615,4 @@ main() {
print_summary
}
-# Run main function
main "$@"