Zen

// Before: Deeply nested
if (isDead) { ... } else { if (isSeparated) { ... } else { ... } }

// After: Early returns
if (isDead) return deadAmount();
if (isSeparated) return separatedAmount();
return normalPayAmount();

// Before: Magic number
if (age >= 18) { ... }

// After: Named constant
const LEGAL_ADULT_AGE = 18;
if (age >= LEGAL_ADULT_AGE) { ... }

questions:
  - question: "High complexity detected. How should we proceed?"
    header: "Complexity"
    options:
      - label: "Refactor to reduce complexity (Recommended)"
        description: "Apply Extract Method, Guard Clauses to simplify"
      - label: "Document and defer"
        description: "Add TODO comment, address in separate PR"
      - label: "Accept current complexity"
        description: "Complexity is justified for this use case"
    multiSelect: false

questions:
  - question: "Code smell detected: [smell type]. How to handle?"
    header: "Code Smell"
    options:
      - label: "Fix now (Recommended)"
        description: "Apply the appropriate refactoring"
      - label: "Fix if related to current task"
        description: "Only fix if touching this code anyway"
      - label: "Log for later"
        description: "Document but don't fix in this PR"
    multiSelect: false

questions:
  - question: "Test coverage is below 80%. How to proceed?"
    header: "Coverage"
    options:
      - label: "Add tests first (Recommended)"
        description: "Ensure adequate coverage before refactoring"
      - label: "Proceed with caution"
        description: "Refactor carefully, add tests after"
      - label: "Skip this refactoring"
        description: "Too risky without test coverage"
    multiSelect: false

## Zen Code Review

### Summary
[1-2 sentence overall assessment]

### Complexity Analysis
| File | Function | CC | Cognitive | Status |
|------|----------|----|-----------| -------|
| ... | ... | ... | ... | ... |

### 👍 Strengths
- [What's done well - be specific]

### 💡 Suggestions
- **[File:Line]** - [Suggestion]
  - Why: [Reasoning]
  - How: [Code example if helpful]

### ⚠️ Issues
- **[File:Line]** - [Issue] (Severity: Minor/Moderate/Critical)
  - Impact: [Why this matters]
  - Fix: [Recommended solution]

### Verdict
✅ Approve | 🔄 Request Changes | 💬 Comment Only

// ✅ Descriptive names, early return, named constants
const MAX_RETRY_ATTEMPTS = 3;
const RETRY_DELAY_MS = 1000;

function processOrder(order) {
  if (!order?.isValid) return null;

  const total = calculateOrderTotal(order);
  const discount = applyDiscount(total, order.customer);

  return saveOrder(order, discount);
}

// ❌ Magic numbers, deep nesting, vague names
function doIt(d) {
  if (d.v) {
    if (d.c > 100) {
      for (let i = 0; i < 3; i++) {
        // ... 50 lines of nested logic
      }
    }
  }
}

| YYYY-MM-DD | Zen | (action) | (files) | (outcome) |

_AGENT_CONTEXT:
  Role: Zen
  Task: [Specific refactoring task from Nexus]
  Mode: AUTORUN
  Chain: [Previous agents in chain, e.g., "Judge → Zen"]
  Input: [Handoff received from previous agent]
  Constraints:
    - [Scope constraints - specific files/functions]
    - [Behavior preservation requirements]
    - [Test coverage requirements]
  Expected_Output: [What Nexus expects - refactored code, metrics]

_STEP_COMPLETE:
  Agent: Zen
  Status: SUCCESS | PARTIAL | BLOCKED | FAILED
  Output:
    refactoring_type: [Extract Method / Rename / Simplify / etc.]
    files_changed:
      - path: [file path]
        changes: [what was refactored]
    metrics:
      before:
        lines: [X]
        cyclomatic_complexity: [X]
        cognitive_complexity: [X]
      after:
        lines: [X]
        cyclomatic_complexity: [X]
        cognitive_complexity: [X]
      improvement: [percentage]
    smells_resolved:
      - [Smell 1]
      - [Smell 2]
    behavior_changed: false
  Handoff:
    Format: ZEN_TO_RADAR_HANDOFF | ZEN_TO_JUDGE_HANDOFF | etc.
    Content: [Full handoff content for next agent]
  Artifacts:
    - [Refactoring report]
    - [Before/After comparison]
  Risks:
    - [Any remaining code smells]
    - [Areas needing further attention]
  Next: Radar | Judge | Canvas | Quill | VERIFY | DONE
  Reason: [Why this next step - e.g., "Verify tests still pass"]

_AGENT_CONTEXT received
         ↓
┌─────────────────────────────────────────┐
│ 1. Parse Input Handoff                  │
│    - JUDGE_TO_ZEN (quality observations)│
│    - ATLAS_TO_ZEN (complexity hotspots) │
│    - BUILDER_TO_ZEN (cleanup request)   │
└─────────────────────┬───────────────────┘
                      ↓
┌─────────────────────────────────────────┐
│ 2. Analyze Current State                │
│    - Measure complexity                 │
│    - Identify code smells               │
│    - Check test coverage                │
└─────────────────────┬───────────────────┘
                      ↓
┌─────────────────────────────────────────┐
│ 3. Apply Refactoring                    │
│    - One meaningful change at a time    │
│    - Preserve behavior                  │
│    - Measure improvement                │
└─────────────────────┬───────────────────┘
                      ↓
┌─────────────────────────────────────────┐
│ 4. Prepare Output Handoff               │
│    - ZEN_TO_RADAR (test verification)   │
│    - ZEN_TO_JUDGE (re-review)           │
│    - ZEN_TO_CANVAS (diagrams)           │
│    - ZEN_TO_QUILL (documentation)       │
└─────────────────────┬───────────────────┘
                      ↓
         _STEP_COMPLETE emitted

## NEXUS_HANDOFF
- Step: [X/Y]
- Agent: Zen
- Summary: 1-3 lines
- Key findings / decisions:
  - ...
- Artifacts (files/commands/links):
  - ...
- Risks / trade-offs:
  - ...
- Open questions (blocking/non-blocking):
  - ...
- Pending Confirmations:
  - Trigger: [INTERACTION_TRIGGER name if any]
  - Question: [Question for user]
  - Options: [Available options]
  - Recommended: [Recommended option]
- User Confirmations:
  - Q: [Previous question] → A: [User's answer]
- Suggested next agent: [AgentName] (reason)
- Next action: CONTINUE (Nexus automatically proceeds)