/implement user authentication
/implement real-time notifications
/implement dashboard analytics

AskUserQuestion(
  questions=[
    {
      "question": "What scope for this implementation?",
      "header": "Scope",
      "options": [
        {"label": "Full-stack (Recommended)", "description": "Backend + frontend + tests + docs"},
        {"label": "Backend only", "description": "API + database + backend tests"},
        {"label": "Frontend only", "description": "UI components + state + frontend tests"},
        {"label": "Quick prototype", "description": "Minimal working version, skip tests"}
      ],
      "multiSelect": false
    },
    {
      "question": "Any constraints I should know about?",
      "header": "Constraints",
      "options": [
        {"label": "None (Recommended)", "description": "Use best practices and modern patterns"},
        {"label": "Match existing patterns", "description": "Follow existing codebase conventions exactly"},
        {"label": "Minimal dependencies", "description": "Avoid adding new packages"},
        {"label": "Specific tech stack", "description": "I'll specify the technologies to use"}
      ],
      "multiSelect": false
    }
  ]
)

# 1. Create main implementation task IMMEDIATELY
TaskCreate(
  subject="Implement: {feature}",
  description="Full-stack implementation with parallel agents",
  activeForm="Implementing {feature}"
)

# 2. Create subtasks for each phase (10-phase process)
TaskCreate(subject="Research best practices", activeForm="Researching best practices")
TaskCreate(subject="Design architecture", activeForm="Designing architecture")
TaskCreate(subject="Micro-plan each task", activeForm="Creating micro-plans")
TaskCreate(subject="Setup git worktree (optional)", activeForm="Setting up worktree")
TaskCreate(subject="Implement backend", activeForm="Implementing backend")
TaskCreate(subject="Implement frontend", activeForm="Implementing frontend")
TaskCreate(subject="Write tests", activeForm="Writing tests")
TaskCreate(subject="Integration verification", activeForm="Verifying integration")
TaskCreate(subject="Scope creep check", activeForm="Checking for scope creep")
TaskCreate(subject="Post-implementation reflection", activeForm="Reflecting on implementation")

# 3. Update status as you progress
TaskUpdate(taskId="2", status="in_progress")  # When starting
TaskUpdate(taskId="2", status="completed")    # When done

# PARALLEL - Web searches (launch all in ONE message)
WebSearch("React 19 best practices 2026")
WebSearch("FastAPI async patterns 2026")
WebSearch("TypeScript 5.x strict mode 2026")

# PARALLEL - Library docs (launch all in ONE message)
mcp__context7__query-docs(libraryId="/vercel/next.js", query="app router")
mcp__context7__query-docs(libraryId="/tiangolo/fastapi", query="dependencies")

## Micro-Plan: [Task Name]

### Scope (What's IN)
- [ ] Specific change 1
- [ ] Specific change 2
- [ ] Test for change 1
- [ ] Test for change 2

### Out of Scope (What's NOT in this task)
- Feature X (separate task)
- Optimization Y (future task)

### Files to Touch
| File | Change Type | Description |
|------|-------------|-------------|
| path/file.py | CREATE | New service class |
| path/test.py | CREATE | Tests for service |
| path/api.py | MODIFY | Add endpoint |

### Acceptance Criteria
- [ ] Tests pass
- [ ] Lint clean
- [ ] Types valid
- [ ] Manually verified

### Estimated Time
[X] minutes / hours

# Create feature worktree
git worktree add ../project-feature-name feature/feature-name

# Navigate to worktree
cd ../project-feature-name

# Work in isolation...

# When done, merge and cleanup
git checkout main
git merge feature/feature-name
git worktree remove ../project-feature-name

Task(
  subagent_type="workflow-architect",
  prompt="""SCOPE CREEP DETECTION for: $ARGUMENTS

  Compare implementation against original micro-plans:

  1. PLANNED vs ACTUAL FILES
     - Files that were planned
     - Files actually modified
     - Unplanned file changes?

  2. PLANNED vs ACTUAL FEATURES
     - Features in original scope
     - Features actually implemented
     - Unplanned features added?

  3. SCOPE CREEP INDICATORS
     - "While I'm here..." changes
     - Premature optimization
     - Goldplating (unnecessary polish)
     - Refactoring outside scope

  4. IMPACT ASSESSMENT
     - Time spent on unplanned work
     - Risk introduced by unplanned changes
     - Testing gaps from scope expansion

  Output:
  {
    "planned_files": N,
    "actual_files": M,
    "unplanned_changes": ["file - change type - justification needed"],
    "scope_creep_score": 0-10 (0=perfect, 10=major creep),
    "recommendations": ["action"]
  }

  SUMMARY: End with: "SCOPE: [score]/10 creep - [N] unplanned changes - [key issue]"
  """,
  run_in_background=True
)

agent-browser open http://localhost:5173
agent-browser wait --load networkidle
agent-browser snapshot -i
agent-browser screenshot /tmp/feature.png
agent-browser close

mcp__mem0__add-memory(content="Implementation decisions...", userId="project-decisions")

Task(
  subagent_type="workflow-architect",
  prompt="""POST-IMPLEMENTATION REFLECTION for: $ARGUMENTS

  Reflect on the implementation process:

  1. WHAT WENT WELL
     - Approaches that worked smoothly
     - Good decisions made
     - Time-saving patterns used

  2. WHAT COULD BE IMPROVED
     - Pain points encountered
     - Decisions that had to be revised
     - Time sinks

  3. ESTIMATION ACCURACY
     - Original estimate: [X]
     - Actual time: [Y]
     - Variance reason: [why]

  4. REUSABLE PATTERNS
     - Patterns worth extracting to skills
     - Code worth making into utilities
     - Documentation worth adding

  5. TECHNICAL DEBT
     - Shortcuts taken (with justification)
     - TODOs left behind
     - Known limitations

  6. KNOWLEDGE GAPS DISCOVERED
     - Things we didn't know at start
     - Research needed mid-implementation
     - Skills/tools to learn for future

  Output:
  {
    "went_well": ["item"],
    "improvements": ["item"],
    "estimate_accuracy": "X%",
    "reusable_patterns": ["pattern - where to use"],
    "tech_debt": ["debt - priority - plan"],
    "knowledge_gaps": ["gap - how filled"]
  }

  SUMMARY: End with: "REFLECTION: [estimate accuracy]% accuracy - [key lesson]"
  """,
  run_in_background=True
)

# Store in memory for future implementations
mcp__memory__create_entities(entities=[{
  "name": "{feature}-lessons-learned",
  "entityType": "Reflection",
  "observations": [
    "Lesson 1: ...",
    "Lesson 2: ...",
    "Pattern to reuse: ..."
  ]
}])

# Quick checkpoint after each task
print(f"""
TASK CHECKPOINT: {task_name}
- Completed: {what_was_done}
- Tests: {pass/fail}
- Time: {actual} vs {estimated}
- Blockers: {any issues}
- Scope changes: {any deviations}
""")

# Update task status
TaskUpdate(taskId=task_id, status="completed")