claude-pro-minmax 1.0.0

package/.claude/commands/README.md

@@ -0,0 +1,381 @@
+> **[한국어 버전](README.ko.md)**
+
+# Commands Directory
+
+## Purpose
+Contains slash command definitions for common workflows.
+
+> **Path note:** Command/agent prompts reference installed paths (`~/.claude/...`). In this repository, the corresponding source paths are `./.claude/...` and `./scripts/...`.
+
+## Contents
+
+| Command | Purpose | Key Feature |
+|---------|---------|-------------|
+| `do.md` | Batch execution | Atomic plan+build+verify in ONE response with rollback on failure |
+| `do-sonnet.md` | Execute with Sonnet | context: fork, model: sonnet |
+| `do-opus.md` | Execute with Opus | context: fork, model: opus |
+| `plan.md` | Complex tasks | @planner → @builder chain |
+| `dplan.md` | Deep Planning | @dplanner (Sequential Thinking + Perplexity + Context7) |
+| `review.md` | Code review | Read-only, categories |
+| `learn.md` | Capture patterns | Auto-extract or explicit |
+| `session-save.md` | Save state | Secret scrubbing |
+| `session-load.md` | Resume work | Context restoration |
+| `load-context.md` | Load context | Read tool, cost economy |
+| `compact-phase.md` | Strategic compact | Phase-aware pruning |
+| `watch.md` | tmux monitoring | Zero message cost |
+| `llms-txt.md` | LLM Documentation | Fetch /llms.txt from URLs |
+| `analyze-failures.md` | Analyze tool errors | Hybrid learning (log + analyze) |
+
+## Command Categories
+
+### Execution Commands
+| Command | When to Use | Resource Usage |
+|---------|-------------|----------------|
+| `/do` | Simple-to-medium tasks (1-3 files). Atomic batch with rollback on failure | Minimal (session model) |
+| `/do-sonnet` | Complex logic requiring deeper reasoning | Moderate (Sonnet 4.6) |
+| `/do-opus` | Critical decisions, Sonnet failed | Higher (Opus 4.6—API pricing reflects cost) |
+| `/plan` | Multi-file tasks, architecture decisions | Moderate (Sonnet 4.6 → Haiku 4.5 chain) |
+| `/dplan` | Research-heavy, complex architecture | Higher (Sonnet 4.6 + MCP tools) |
+
+### Quality Assurance
+| Command | When to Use | Resource Usage |
+|---------|-------------|----------------|
+| `/review` | Post-implementation quality check | Minimal (Haiku 4.5, read-only) |
+
+### Session Management
+| Command | When to Use | Resource Usage |
+|---------|-------------|----------------|
+| `/session-save` | Save work summary for later | Local script (zero API usage) |
+| `/session-load` | Resume previous work | Minimal (Read tool for context) |
+
+### Context Management
+| Command | When to Use | Resource Usage |
+|---------|-------------|----------------|
+| `/load-context` | Load project context templates | Minimal (Read tool) |
+| `/compact-phase` | Strategic context pruning | Guidance only (no execution) |
+
+### Learning & Analysis
+| Command | When to Use | Resource Usage |
+|---------|-------------|----------------|
+| `/learn` | Capture patterns for future reference | Minimal (Write to learned/) |
+| `/analyze-failures` | Analyze accumulated tool failures | Moderate (requires LLM analysis) |
+
+### Utilities
+| Command | When to Use | Resource Usage |
+|---------|-------------|----------------|
+| `/watch` | Monitor long-running processes | Local tmux (zero API usage) |
+| `/llms-txt` | Fetch LLM-optimized documentation | Minimal (WebFetch) |
+
+## Workflow Examples
+
+### Simple Feature Implementation
+```bash
+# 1. Direct execution for simple, well-defined tasks
+/do Create a user service with CRUD operations
+
+# 2. Review after implementation
+/review src/services/user-service.ts
+```
+**Quota:** Low (Session model execution + Haiku 4.5 review)
+
+### Complex Feature Implementation
+```bash
+# 1. Plan architecture first
+/plan Add JWT authentication with refresh tokens
+
+# 2. Planner designs → Builder implements → Auto-review
+# (Agent chain handles this automatically)
+
+# 3. Manual review if needed
+/review src/auth/
+```
+**Quota:** Medium (Sonnet 4.6 planning + Haiku 4.5 implementation + Haiku 4.5 review)
+
+### Research-Heavy Architecture
+```bash
+# 1. Deep planning with research tools
+/dplan Analyze trade-offs between event sourcing and CQRS for our use case
+
+# 2. Load relevant context after research
+/load-context backend
+
+# 3. Implement based on research findings
+# (Use /plan or /do based on complexity)
+```
+**Quota:** High (Sonnet 4.6 + Sequential Thinking + Perplexity + Context7)
+
+### Debugging & Learning
+```bash
+# 1. Analyze recent failures
+/analyze-failures 50
+
+# 2. Extract patterns and create learned skills
+/learn "Use type guards before accessing union properties"
+
+# 3. Show learned patterns
+/learn --show
+```
+**Quota:** Medium (LLM analysis of failure logs)
+
+### Long Session Management
+```bash
+# 1. Load previous context
+/session-load auth-feature
+
+# 2. Work on tasks...
+
+# 3. Save progress before break
+/session-save auth-feature-v2
+
+# 4. Compact context strategically
+/compact-phase implementation
+```
+**Quota:** Low (mostly script-based operations)
+
+## Command Comparison
+
+### Execution: /do vs /do-sonnet vs /do-opus vs /plan vs /dplan
+
+| Aspect | /do | /do-sonnet | /do-opus | /plan | /dplan |
+|--------|-----|------------|----------|-------|--------|
+| **Model** | Session model | Sonnet 4.6 | Opus 4.6 | Sonnet 4.6 → Haiku 4.5 | Sonnet 4.6 + MCP |
+| **Relative Cost** | Low | Medium | High | Medium-High | Highest |
+| **Planning** | Internal (batch) | Internal (batch) | Internal (batch) | Architecture design | Deep research |
+| **Use Case** | Simple tasks | Complex logic | Critical decisions | Multi-file features | Unknown unknowns |
+| **Files Affected** | 1-3 | 1-3 | Any | 5+ | Any |
+| **Questions** | No | No | No | ≤3 (with defaults) | Unlimited |
+| **Research Tools** | No | No | No | No | Yes (Perplexity, Context7) |
+
+**Decision Tree:**
+```
+Task Complexity
+├─ Simple (1-3 files, clear requirements)
+│   └─→ /do
+│
+├─ Moderate (4-5 files, some complexity)
+│   ├─ Logic-heavy → /do-sonnet
+│   └─ Multi-file → /plan
+│
+└─ Complex (5+ files, unclear approach)
+    ├─ Known domain → /plan
+    ├─ Needs research → /dplan
+    └─ Critical/Sonnet failed → /do-opus
+```
+
+### Context: /session-save vs /load-context
+
+| Aspect | /session-save | /load-context |
+|--------|---------------|---------------|
+| **Purpose** | Save entire session state | Load pre-defined templates |
+| **Content** | Work history, decisions, code | Project structure, conventions |
+| **Scope** | Session-specific | Project-wide patterns |
+| **When** | End of work session | Start of new task |
+| **Format** | Markdown summary | Structured context file |
+
+**Use together:**
+```bash
+# Start of day
+/session-load yesterday-work     # Resume from yesterday
+/load-context backend             # Load project conventions
+
+# End of day
+/session-save today-progress      # Save for tomorrow
+```
+
+## Best Practices
+
+### 1. Choose the Right Execution Command
+
+**Use `/do` when:**
+- Task is well-defined with clear requirements
+- Affects 1-3 files only
+- No architectural decisions needed
+- Example: "Add validation to user input"
+
+**Use `/plan` when:**
+- Task affects 5+ files
+- Requires architectural decisions
+- Requirements need clarification
+- Example: "Add multi-tenant support"
+
+**Use `/dplan` when:**
+- Unknown technology or pattern
+- Need to evaluate multiple approaches
+- Debugging complex race conditions
+- Example: "Design distributed transaction handling"
+
+**Use `/do-opus` when:**
+- Task is critical (production hotfix)
+- Sonnet failed after 2 retries
+- Maximum reasoning capability needed
+- Example: "Fix memory leak in production"
+
+### 2. Strategic Context Management
+
+**Compact early and often:**
+```bash
+# After planning phase
+/compact-phase planning
+
+# After implementation
+/compact-phase implementation
+
+# After review
+/compact-phase review
+```
+
+**Load context selectively:**
+```bash
+# Don't load everything at once
+/load-context backend     # ✓ Load what you need
+/load-context frontend    # ✗ Don't load if not needed
+```
+
+### 3. Learning from Failures
+
+**Analyze failures regularly:**
+```bash
+# Weekly analysis
+/analyze-failures 100
+
+# After difficult debugging session
+/analyze-failures 20
+```
+
+**Capture patterns immediately:**
+```bash
+# Right after solving a tricky issue
+/learn "Use AbortController for cancellable fetch requests"
+```
+
+### 4. Session Management
+
+**Save at natural breakpoints:**
+- End of work session
+- Before switching tasks
+- After major milestone
+- Before experimental changes
+
+**Load when resuming:**
+- Start of work session
+- Switching back to previous task
+- Need context from past work
+
+### 5. Pro Plan Optimization
+
+**Minimize high-cost commands:**
+- Use `/do` instead of `/plan` when possible
+- Use `/do-sonnet` instead of `/do-opus` when possible
+- Use `/plan` instead of `/dplan` when research isn't critical
+
+**Batch operations:**
+```bash
+# ✗ Multiple separate /do calls
+/do Create user model
+/do Create user controller
+/do Create user tests
+
+# ✓ Single /plan call
+/plan Create user module with model, controller, and tests
+```
+
+**Use zero-cost tools:**
+- `/session-save`, `/session-load` (script-based)
+- `/watch` (tmux-based)
+- `/compact-phase` (guidance only)
+
+## Usage Examples
+
+```bash
+# Direct execution (simple tasks)
+/do Create a user service
+/do-sonnet Implement complex caching logic
+
+# Complex tasks (planning needed)
+/plan Add user authentication with JWT
+/dplan Analyze potential deadlocks in transaction manager
+
+# Code review
+/review src/auth/
+/review --security
+
+# Learning
+/learn "Always use zod for validation"
+/learn --show
+/analyze-failures 50
+
+# Sessions
+/session-save auth-feature
+/session-load
+
+# Context
+/load-context backend
+/load-context frontend
+
+# Phases
+/compact-phase implementation
+/watch tests
+/llms-txt https://docs.example.com
+```
+
+## Design Decisions
+
+| Decision | Rationale |
+|----------|-----------|
+| `/do-sonnet` and `/do-opus` as separate commands | Frontmatter `model:` field only works with `context: fork`. Separate commands are required to route execution through the intended subagent model |
+| `/plan` uses `agent: planner`, `/review` uses `agent: reviewer` | These commands need specific tool restrictions. `planner` is read-only (no Write/Edit). `reviewer` is also read-only. The `agent:` field applies that agent's tools/permissions |
+| `/load-context` with `disable-model-invocation: false` | Must be `false` so Claude can auto-invoke this command. If `true`, Claude cannot use Read tool to load context files |
+| `/compact-phase` as guidance only | Claude Code's `/compact` requires user input. This command provides phase-specific prompts to copy-paste |
+
+## Adding Custom Commands
+
+Create a new `.md` file with **frontmatter** (required for official compliance):
+
+```markdown
+---
+name: your-command
+description: What this command does and when to use it
+argument-hint: [required-arg] or --flag [optional]
+disable-model-invocation: true
+---
+
+# /your-command Command
+
+## Purpose
+What this command does.
+
+## Input
+$ARGUMENTS
+
+## Execution
+1. Step one
+2. Step two
+
+## Output
+\`\`\`
+Expected output format
+\`\`\`
+
+## Examples
+\`\`\`bash
+/your-command example
+\`\`\`
+```
+
+### Frontmatter Fields
+
+| Field | Required | Description |
+|-------|:--------:|-------------|
+| `name` | Yes | Command name (lowercase, hyphens) |
+| `description` | Yes | When to use this command (for Claude auto-invocation) |
+| `argument-hint` | No | Shows in autocomplete |
+| `disable-model-invocation` | No | `true` = manual only, `false` = Claude can auto-invoke |
+| `allowed-tools` | No | Restrict tools (e.g., `Read, Grep`) |
+| `model` | No | Force model (`sonnet`, `haiku`, `opus`) |
+| `context` | No | `fork` = run in subagent context |
+| `agent` | No | Subagent type when `context: fork` (e.g., `planner`, `reviewer`) |
+| `hooks` | No | Lifecycle hooks (`PreToolUse`, `PostToolUse`, `Stop`) |
+
+### Location
+- Global: `~/.claude/commands/` (all projects)
+- Project: `./.claude/commands/` (this project only)

package/.claude/commands/analyze-failures.md

@@ -0,0 +1,49 @@
+---
+name: analyze-failures
+description: Analyze accumulated tool failure logs to extract recurring patterns and suggest improvements.
+argument-hint: [limit] (default: 50)
+disable-model-invocation: false
+---
+
+# /analyze-failures Command
+
+Analyze tool failure logs to identify recurring errors and suggest patterns for the `/learn` command.
+
+## Input
+- `limit` (optional): Number of recent failures to analyze. Default is 50.
+
+## Execution
+Run the bash script to parse `~/.claude/logs/tool-failures.log`:
+
+```bash
+bash ~/.claude/scripts/analyze-failures.sh "$ARGUMENTS"
+```
+
+## How It Works
+1. **Collection**: Failures are automatically logged by `~/.claude/scripts/hooks/tool-failure-log.sh` (Zero-cost).
+2. **Analysis**: This command uses `awk` to aggregate and count errors locally (Zero-cost for generation).
+3. **Insight**: The output summary is added to context, allowing Claude to offer specific advice if needed.
+
+## Output Example
+```markdown
+## Failure Analysis
+
+**Total failures logged**: 120
+**Analyzing last**: 50
+
+### Top Failures
+1. **Edit tool**: "old_string not found" (15 failures)
+2. **Grep tool**: "pattern syntax error" (8 failures)
+
+### Most Problematic Tools
+- **Edit tool**: 25 failures
+- **Grep tool**: 12 failures
+
+💡 **Recommendations**:
+- Review frequent failures and update your approach
+- Consider saving learned patterns with `/learn [pattern]`
+```
+
+## Difference from `/learn`
+- **`/analyze-failures`**: **Quantitative**. Looks at *past errors* from logs. "What went wrong?"
+- **`/learn`**: **Qualitative**. Extracts *successful patterns* from current context. "What went right?"

package/.claude/commands/compact-phase.md

@@ -0,0 +1,75 @@
+---
+name: compact-phase
+description: Strategic phase-based context pruning. Removes unnecessary context based on planning, implementation, or review phase.
+argument-hint: planning | implementation | review | deep-planning
+disable-model-invocation: true
+---
+
+# /compact-phase Command
+
+Strategic phase-based context pruning.
+
+## Phase
+$ARGUMENTS
+
+## Execution
+This command provides the appropriate `/compact` instruction for your current phase. Copy and run the suggested command:
+
+```bash
+# After planning phase
+/compact Keep: decisions, task list, architecture choices. Discard: exploration attempts, rejected alternatives, research notes.
+
+# After implementation phase
+/compact Keep: final code, tests, working solutions. Discard: debug attempts, failed approaches, intermediate versions.
+
+# After review phase
+/compact Keep: final state, confirmed issues, applied fixes. Discard: iteration history, superseded feedback.
+
+# After deep planning phase
+/compact Keep: validated logic, research sources, architecture diagram. Discard: internal monologue, failed research queries, temporary notes.
+```
+
+> Note: This command guides you to run `/compact` with the right instructions. It does not automatically compact context.
+
+## Phase-Specific Rules
+
+| Phase | Keep | Discard |
+|-------|------|---------|
+| planning | Decisions, task list | Exploration, reviewed alternatives |
+| implementation | Final code, tests | Debug attempts, intermediate versions |
+| review | Final state, issue list | Iteration history |
+| deep-planning | Validated logic, final plan | Intermediate thoughts, raw search results |
+
+## Cost Savings
+- planning → implementation: ~40% context reduction
+- implementation → review: ~30% context reduction
+- review → complete: ~50% context reduction
+
+## Output
+```
+Compact: [phase] phase completed
+
+Kept:
+- [retained items]
+
+Discarded:
+- [removed items]
+
+Context reduced: [X]% → [Y]%
+```
+
+## When to Use
+```
+/plan feature-x          # Plan
+/compact-phase planning  # Prune exploration
+
+/do implement task-1     # Implement
+/do implement task-2
+/compact-phase implementation  # Prune debug attempts
+
+/review src/             # Review
+/compact-phase review    # Prune iterations
+
+/dplan analyze-race      # Deep Plan
+/compact-phase deep-planning # Keep verified logic, discard raw thoughts
+```

package/.claude/commands/do-opus.md

@@ -0,0 +1,43 @@
+---
+name: do-opus
+description: Direct execution with Opus model for critical decisions. Use for the most complex tasks requiring maximum reasoning.
+argument-hint: [task]
+context: fork
+model: opus
+---
+
+# /do-opus Command
+
+Direct execution with Opus model via subagent.
+
+## Task
+$ARGUMENTS
+
+## Protocol
+1. Check CRITICAL_ACTIONS → confirm if found
+2. **Snapshot**: `~/.claude/scripts/snapshot.sh push cpmm-opus`
+3. Execute immediately (no planner)
+4. Verify with `~/.claude/scripts/verify.sh` (runtime-adaptive)
+5. **On Success**: `~/.claude/scripts/snapshot.sh drop`
+6. **On Failure (2 retries)**: `~/.claude/scripts/snapshot.sh pop`. Then STOP + escalate.
+
+## Verification (Runtime-Adaptive)
+| Type | Verification |
+|------|--------------|
+| Config/Docs/Styles | Syntax only |
+| Logic changes | `~/.claude/scripts/verify.sh` |
+
+DO NOT call build tools directly. Use `~/.claude/scripts/verify.sh`.
+
+## Cost Note
+Opus is the most expensive model. Use only when:
+- Sonnet also failed on the task
+- Critical architectural decisions
+- Tasks requiring maximum reasoning depth
+
+## Escalation
+```
+Attempt 1 → FAIL → Attempt 2 → FAIL → STOP
+                                     → Report error
+                                     → Suggest: Break task into smaller pieces
+```

package/.claude/commands/do-sonnet.md

@@ -0,0 +1,43 @@
+---
+name: do-sonnet
+description: Direct execution with Sonnet model for complex logic. Use when default /do fails or task requires deeper reasoning.
+argument-hint: [task]
+context: fork
+model: sonnet
+---
+
+# /do-sonnet Command
+
+Direct execution with Sonnet model via subagent.
+
+## Task
+$ARGUMENTS
+
+## Protocol
+1. Check CRITICAL_ACTIONS → confirm if found
+2. **Snapshot**: `~/.claude/scripts/snapshot.sh push cpmm-sonnet`
+3. Execute immediately (no planner)
+4. Verify with `~/.claude/scripts/verify.sh` (runtime-adaptive)
+5. **On Success**: `~/.claude/scripts/snapshot.sh drop`
+6. **On Failure (2 retries)**: `~/.claude/scripts/snapshot.sh pop`. Then STOP + escalate.
+
+## Verification (Runtime-Adaptive)
+| Type | Verification |
+|------|--------------|
+| Config/Docs/Styles | Syntax only |
+| Logic changes | `~/.claude/scripts/verify.sh` |
+
+DO NOT call build tools directly. Use `~/.claude/scripts/verify.sh`.
+
+## Cost Note
+Sonnet costs ~3x more than Haiku (API pricing: $3 vs $1 /MTok input). Use only when:
+- Default `/do` failed after 2 retries
+- Task requires complex reasoning or multi-step logic
+- Architecture-level code changes
+
+## Escalation
+```
+Attempt 1 → FAIL → Attempt 2 → FAIL → STOP
+                                     → Report error
+                                     → Suggest: /plan for architecture review
+```

package/.claude/commands/do.md

@@ -0,0 +1,56 @@
+---
+name: do
+description: Direct execution without planner overhead. Use for simple bug fixes, single file changes, or clear tasks.
+argument-hint: [task]
+disable-model-invocation: true
+---
+
+# /do Command
+
+Direct execution. No agent overhead.
+
+## Task
+$ARGUMENTS
+
+## Model Selection
+- Default: current session model
+- For stronger model: use `/do-sonnet [task]` or `/do-opus [task]`
+
+## Protocol
+1. Check CRITICAL_ACTIONS → confirm if found
+2. **Snapshot**: `~/.claude/scripts/snapshot.sh push` → outputs `SNAPSHOT=true` or `SNAPSHOT=false`
+3. **Internal Planning** (no agent call): Identify files to modify, changes needed, verify approach
+4. **Execute all changes** in a single pass
+5. Verify with `~/.claude/scripts/verify.sh` (runtime-adaptive)
+6. **On Success**: `~/.claude/scripts/snapshot.sh drop` (auto-checks label — safe no-op if no snapshot)
+7. **On Failure (2 retries exhausted)**: `~/.claude/scripts/snapshot.sh pop` (restores snapshot or `git checkout .` fallback). Then escalate.
+
+## Batch Execution
+This command handles plan+build+verify in ONE response.
+- Do NOT spawn @planner — plan internally
+- Do NOT ask for confirmation between steps
+- Do NOT split work across multiple messages
+- Result: user sends 1 message, receives 1 complete response
+
+## Atomic Rollback
+All rollback logic is in `~/.claude/scripts/snapshot.sh` (deterministic, not model-reasoned):
+- **`push`**: Depth guard + labeled stash. Returns `SNAPSHOT=true/false`.
+- **`drop`**: Label check before drop. Safe no-op if no cpmm stash exists.
+- **`pop`**: Label check before pop. Falls back to `git checkout .` if no cpmm stash.
+- Cost: 0 API tokens (local git operation)
+- Limitation: Untracked (new) files are NOT stashed. For full cleanup after failure: `git clean -fd`
+
+## Verification (Runtime-Adaptive)
+| Type | Verification |
+|------|--------------|
+| Config/Docs/Styles | Syntax only |
+| Logic changes | `~/.claude/scripts/verify.sh` |
+
+DO NOT call build tools directly. Use `~/.claude/scripts/verify.sh`.
+
+## Escalation
+```
+Attempt 1 → FAIL → Attempt 2 → FAIL → STOP
+                                     → Report error
+                                     → Suggest: /do-sonnet or /plan
+```

package/.claude/commands/dplan.md

@@ -0,0 +1,36 @@
+---
+name: dplan
+description: Deep planning with @dplanner. Use for extremely complex tasks requiring Sequential Thinking, Perplexity research, and Context7 documentation.
+argument-hint: [complex feature description]
+context: fork
+agent: dplanner
+---
+
+# /dplan Command
+
+**"Deep Plan"** - Runs in **@dplanner** subagent context.
+
+## Purpose
+Invokes the **Deep Planner** for high-complexity architectural design and research.
+Unlike `/plan`, this command utilizes `sequential-thinking`, `perplexity`, and `context7` for maximum depth.
+
+## Arguments
+$ARGUMENTS
+
+## Flow
+1. Forks conversation to **@dplanner** context.
+2. **@dplanner**:
+   - Analyzes request.
+   - Uses Sequential Thinking for logic verification.
+   - Uses Perplexity for web research.
+   - Uses Context7 for library documentation.
+   - Produces a comprehensive "Deep Plan".
+3. Returns plan to main conversation.
+
+## When to Use
+- **New Architecture**: "Design microservices event bus"
+- **Complex Debugging**: "Analyze race condition in payment module"
+- **Tech Stack Research**: "Compare Redux vs Zustand for our specific needs"
+
+## Output Format
+See `@dplanner` documentation for detailed output structure.