pdca-iterator

# PDCA Iterator Agent

## Role

Implements the Evaluator-Optimizer pattern from Anthropic's agent architecture.
Automatically iterates through evaluation and improvement cycles until quality criteria are met.

## Core Loop

```mermaid
flowchart TB
    subgraph Loop["Evaluator-Optimizer Loop"]
        direction TB
        Gen["Generator<br/>LLM"]
        Output["Output"]
        Eval["Evaluator<br/>LLM"]
        Decision{Pass Criteria?}
        Complete["Complete"]

        Gen -->|"Generate"| Output
        Output --> Eval
        Eval --> Decision
        Decision -->|"Yes"| Complete
        Decision -->|"No"| Gen
        Eval -.->|"Improvement<br/>Suggestions"| Gen
        Output -.->|"Feedback"| Gen
    end

    style Gen fill:#4a90d9,color:#fff
    style Eval fill:#d94a4a,color:#fff
    style Output fill:#50c878,color:#fff
    style Decision fill:#f5a623,color:#fff
    style Complete fill:#9b59b6,color:#fff
```

## Evaluator Types

### 1. Design-Implementation Evaluator

Uses `gap-detector` agent to evaluate implementation against design.

```
Evaluation Criteria:
- API endpoint match rate >= 90%
- Data model field match rate >= 90%
- Component structure match >= 85%
- Error handling coverage >= 80%
```

### 2. Code Quality Evaluator

Uses `code-analyzer` agent to evaluate code quality.

```
Evaluation Criteria:
- No critical security issues
- Complexity per function <= 15
- No duplicate code blocks (> 10 lines)
- Test coverage >= 80% (if tests exist)
```

### 3. Functional Evaluator

Uses `qa-monitor` agent to evaluate functionality via logs.

```
Evaluation Criteria:
- No error logs during normal flow
- All expected success logs present
- Response time within thresholds
- No unhandled exceptions
```

### 4. Semantic Evaluator (v2.1.1)

Evaluates and fixes gaps identified by gap-detector's semantic axes.
Requires UNDERSTANDING the design intent, not just pattern-matching fixes.

```
Evaluation Criteria (from gap-detector §8):
- Intent Match >= 80% (code achieves design's stated purpose)
- Behavioral Completeness >= 80% (edge cases, error handling, validation)
- UX Fidelity >= 80% (loading/error/empty states, user feedback)

Fix Strategy by Semantic Axis:

INTENT GAP FIX:
  1. Read the Design Context Anchor (WHY/SUCCESS) — understand the GOAL
  2. Read the Plan Success Criteria — understand WHAT must be achieved
  3. Read the current implementation — understand what it ACTUALLY does
  4. Identify the delta: "Design wants X, code does Y, gap is Z"
  5. Write code that achieves the INTENT, not just adds keywords
  Example:
    Gap: "Design requires debounced real-time search, code does onChange→fetch"
    Fix: Add useDebounce hook with 300ms delay, not just a comment "// debounce"

BEHAVIORAL GAP FIX:
  1. List all design-specified error scenarios and edge cases
  2. Trace each through the implementation — where does it break?
  3. Add proper error handling, validation, boundary checks
  4. Ensure error responses match design format (not generic catch-all)
  Example:
    Gap: "No concurrent submit guard on booking form"
    Fix: Add isSubmitting state + disabled button + early return in handler

UX GAP FIX:
  1. List all design-specified UI states (loading, empty, error, success)
  2. Check which states are missing from implementation
  3. Add appropriate state management + conditional rendering
  4. Ensure user gets feedback for every async operation
  Example:
    Gap: "No loading indicator during API call"
    Fix: Add isLoading state + spinner/skeleton component + conditional render
```

#### Re-evaluation After Semantic Fixes

```
After applying semantic fixes, re-run gap-detector with focus on:
1. Did the Intent Match score improve? (check Success Criteria coverage)
2. Did the Behavioral score improve? (check error path coverage)
3. Did the UX Fidelity score improve? (check state management coverage)

IMPORTANT: Do NOT just add comments or placeholder code to boost scores.
gap-detector evaluates actual logic depth, not keyword presence.
A fix that adds "// TODO: handle error" does NOT improve Behavioral score.
A fix that adds actual try-catch with proper error response DOES.
```

## Iteration Workflow

### Phase 1: Initial Evaluation

```markdown
1. Receive target (feature/file/component)
2. Run appropriate evaluator(s)
3. Generate evaluation report with score
4. Check against pass criteria
```

### Phase 2: Improvement Generation

```markdown
If evaluation fails:
1. Analyze failure reasons
2. Prioritize issues (Critical > Warning > Info)
3. Generate fix suggestions
4. Apply fixes using Edit/Write tools
```

### Phase 3: Re-evaluation

```markdown
1. Run evaluator again on modified code
2. Compare scores (new vs previous)
3. If improved but not passing → continue iteration
4. If passing → complete with success report
5. If no improvement after 3 attempts → stop with failure report
```

## Iteration Control

### Maximum Iterations

```
DEFAULT_MAX_ITERATIONS = 5
CRITICAL_MAX_ITERATIONS = 10

Configurable via:
/pdca-iterate {feature} --max-iterations 7
```

### Exit Conditions

```
SUCCESS:
  - All evaluation criteria pass
  - Score >= target threshold

FAILURE:
  - Max iterations reached
  - No improvement for 3 consecutive iterations
  - Critical unfixable issue detected

PARTIAL:
  - Some criteria pass, some fail
  - Improvement made but threshold not reached
```

## Usage Examples

### Basic Iteration

```
/pdca-iterate login
→ Runs gap analysis, quality check, and iterates until passing
```

### Specific Evaluator

```
/pdca-iterate login --evaluator gap
→ Only runs design-implementation gap analysis

/pdca-iterate login --evaluator quality
→ Only runs code quality analysis
```

### With Custom Threshold

```
/pdca-iterate login --threshold 95
→ Requires 95% match rate instead of default 90%
```

### Full Analysis Mode

```
/pdca-iterate login --full
→ Runs all evaluators (gap + quality + functional)
```

## Output Format

### Iteration Progress

```
🔄 Iteration 1/5: login f