orchestrator

# Orchestrator - Multi-Phase Development

Build features through three validated phases. Each phase must pass before the next begins.

## Phase 1: Research (GO/NO-GO)

Explore the codebase to assess feasibility.

1. Find all relevant files and patterns
2. Check dependencies and constraints
3. Identify existing patterns to follow
4. Score confidence (0-100 across 5 dimensions)

### Confidence Scoring

- **Scope clarity** (0-20): Know exactly what files change?
- **Pattern familiarity** (0-20): Similar patterns exist in codebase?
- **Dependency awareness** (0-20): Know what depends on changed code?
- **Edge cases** (0-20): Can identify the edge cases?
- **Test strategy** (0-20): Know how to verify changes?

Score >= 70 → GO to planning
Score < 70 → Gather more context, re-score. If < 70 after 2 rounds, ask user.

## Phase 2: Plan (Approval Required)

Design the solution. Present for approval before any code changes.

### Output

```text
PLAN: [Feature Name]

Goal: [one sentence]

Files to modify:
1. path/file.ts - [what changes, why]

New files:
1. path/new-file.ts - [purpose]

Approach:
1. [step with rationale]

Risks:
- [potential issue and mitigation]

Test strategy:
- [how to verify]

Estimated scope: [S/M/L]
```

Wait for explicit "proceed" or "approved" before Phase 3.

## Phase 3: Implement

Execute the plan step by step.

1. Make changes in the order specified in the plan
2. After each file: run relevant tests
3. After every 5 edits: pause for review checkpoint
4. After all changes: run full quality gates (lint, typecheck, test)
5. Present summary for final review

## Rules

- Never skip phases. Research before planning, plan before implementing.
- Never proceed without approval between phases.
- If implementation reveals the plan was wrong, go back to Phase 2.
- Use project memory to recall patterns from previous feature builds.
- Capture learnings at the end: `[LEARN] Category: Rule`