/refactor-full

Refactor Full

**Comprehensive refactor analysis that runs all refactor commands and merges results.**

Safe to run anytime. Runs multiple analysis passes and creates unified refactor plan without modifying files.

What This Does

Orchestrates a complete refactor analysis by: 1. **Running all 3 analyses in parallel** using specialized agents:

• `/medium` for quick classification
• `/simple` for focused analysis
• `/deep` for comprehensive analysis

2. Collecting results from all parallel agents 3. Reading and parsing all output files 4. Intelligently merging insights into one unified refactor plan 5. Writing merged plan to `./tmp/refactor-full-plan-[timestamp].md`

**Key advantage:** Much faster than running sequentially - all analyses run simultaneously!

When to Use

• **Complex changes** requiring multiple perspectives
• **Pre-PR comprehensive validation** with all analysis types
• **Large features** that benefit from layered analysis
• **Learning refactoring patterns** by seeing different analysis depths

For simple changes, just use `/simple` instead.

Process

Phase 1: Run Analysis Commands in Parallel

**CRITICAL: Launch all three agents in parallel using a SINGLE message with multiple Task tool calls.**

This runs all analyses simultaneously for maximum performance:

1. **Refactor Check Agent** - Quick classification and pattern check 2. **Simple Refactor Agent** - Focused analysis with refactor plan 3. **Deep Refactor Agent** - Comprehensive analysis

**Use the Task tool with three parallel invocations:**

// In a SINGLE message, make 3 Task tool calls:

Task({
  subagent_type: "general-purpose",
  description: "Run refactor-check analysis",
  prompt: "Execute the /medium slash command to perform quick classification and pattern checking. Return the complete console output including classification, quality score, issues found, and recommendations."
})

Task({
  subagent_type: "general-purpose",
  description: "Run simple-refactor analysis",
  prompt: "Execute the /simple slash command to perform focused refactor analysis. This will generate a plan file in ./tmp/simple-refactor-plan-[timestamp].md. Return the path to the generated plan file."
})

Task({
  subagent_type: "general-purpose",
  description: "Run deep-refactor analysis",
  prompt: "Execute the /deep slash command to perform comprehensive refactor analysis. This will generate a plan file in ./tmp/deep-refactor-plan-[timestamp].md. Return the path to the generated plan file."
})

**Show progress to user:**

🔍 Running comprehensive refactor analysis in parallel...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

⚡ Launching 3 parallel analysis agents:
  [1] refactor-check (quick classification)
  [2] simple-refactor (focused analysis)
  [3] deep-refactor (comprehensive analysis)

⏳ All agents running in parallel...

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✓ All analyses complete!

Results:
  [1] Refactor Check: Complete (console output captured)
  [2] Simple Refactor: ./tmp/simple-refactor-plan-[TS].md
  [3] Deep Refactor: ./tmp/deep-refactor-plan-[TS].md

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Phase 2: Collect Agent Results

**Agent results will include:**

1. **Refactor Check Agent** → Returns complete console output with classification and quality score 2. **Simple Refactor Agent** → Returns path to generated plan file 3. **Deep Refactor Agent** → Returns path to generated plan file

**If agents don't return paths explicitly, locate the most recent output files:**

# Find most recent simple refactor plan
ls -t ./tmp/simple-refactor-plan-*.md | head -1

# Find most recent deep refactor plan
ls -t ./tmp/deep-refactor-plan-*.md | head -1

**Note:** `/refactor-check` outputs to console only (no file), captured from agent output.

Phase 3: Read and Parse Reports

**Read both plan files:**

• `./tmp/simple-refactor-plan-[timestamp].md`
• `./tmp/deep-refactor-plan-[timestamp].md`

**Extract from each:**

• Classification metrics
• Quality scores
• Critical issues
• Warnings
• Info/suggestions
• Auto-fixable issues
• Manual fixes required
• Pattern compliance matrix
• Recommendations

Phase 4: Merge Reports Intelligently

**Merging strategy:**

**1. Use Deep Refactor as Base**

• Deep refactor is most comprehensive
• Provides the fullest pattern compliance matrix
• Has detailed cross-cutting concerns

**2. Enhance with Simple Refactor Insights**

• Add any unique issues simple refactor found
• Include any simpler explanations or references
• Merge quick-fix recommendations

**3. Add Refactor Check Summary**

• Include high-level classification from check
• Add any unique pattern detections

**4. Deduplicate Issues**

• Same file:line issues → Keep most detailed description
• Similar issues → Combine insights
• Different perspectives on same issue → Note both viewpoints

**5. Prioritize Issues Consistently**

• Critical (all sources agree) → Must fix
• Critical (one source) + Warning (another) → Should fix
• Warning + Info → Nice to have
• Deduplicate and merge reasoning

**6. Merge Auto-Fixable Lists**

• Combine all auto-fixable issues
• Remove duplicates
• Count total across all sources

**7. Merge Manual Fix Lists**

• Group by priority (P0, P1, P2)
• Combine similar issues
• Add context from multiple analyses

**8. Create Unified Quality Score (Orchestrator-Specific)**

• Show all three raw scores for comparison (these use the individual command thresholds)
• Calculate orchestrator's own weighted average (Deep 50%, Simple 30%, Check 20%)
• The orchestrator uses its own pass threshold (9.0) separate from individual commands (9.8)
• This allows the orchestrator to provide a holistic view without being influenced by individual command targets

**9. Consolidate Recommendations**

• Merge next steps from all sources
• Order by dependency and priority
• Remove duplicate suggestions

Phase 5: Generate Merged Plan

Write unified plan to `./tmp/refact