/implement
    │
    ▼
┌────────────────────────────────────────────────────┐
│  1. FIND: Locate approved spec                     │
│     Check: specs/{feature}/design.md               │
│     Verify: "Status: Approved" in frontmatter      │
└────────────────────────────────────────────────────┘
    │
    ▼
┌────────────────────────────────────────────────────┐
│  2. ANALYZE: Read spec content                     │
│     Parse: design.md sections and keywords         │
│     Identify: Backend, frontend, docs, eval scope  │
└────────────────────────────────────────────────────┘
    │
    ▼
┌────────────────────────────────────────────────────┐
│  3. ROUTE: Based on detected type                  │
└────────────────────────────────────────────────────┘
    │
    ├── Backend only → code-agent
    │
    ├── Frontend only → ui-agent
    │
    ├── Backend + Frontend → code-agent → ui-agent (sequential)
    │
    ├── Documentation only → docs-agent
    │
    ├── Evaluation only → eval-agent
    │
    └── Mixed → Route to multiple agents per section

## Architecture
├── "Database" subsection → Backend component
├── "API" subsection → Backend component
├── "Components" subsection → Frontend component
└── "Pages" subsection → Frontend component

## Implementation
├── Tasks mention Prisma/tRPC → Backend
├── Tasks mention React/shadcn → Frontend
└── Tasks mention both → Mixed (code-agent → ui-agent)

┌─────────────────────────────────────────────────────────────────┐
│  /implement                                                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ERROR: No approved spec found                                   │
│                                                                  │
│  Checked locations:                                              │
│  • specs/{feature}/design.md - Not found                         │
│  • specs/{feature}/requirements.md - Not found                   │
│                                                                  │
│  To create a spec, run:                                          │
│  /plan                                                           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│  /implement                                                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Spec found but type unclear: specs/utils/design.md              │
│                                                                  │
│  What type of implementation is this?                            │
│                                                                  │
│  1. Backend (API, database, server logic)     → code-agent       │
│  2. Frontend (UI, components, styling)        → ui-agent         │
│  3. Full-stack (both)                         → code → ui        │
│  4. Documentation                             → docs-agent       │
│  5. LLM evaluation                            → eval-agent       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

interface RoutingResult {
  agents: ("code-agent" | "ui-agent" | "docs-agent" | "eval-agent")[];
  reason: string;
  spec: { path: string; sections: string[] };
}

function routeImplement(specPath: string): RoutingResult {
  // 1. Read and parse spec
  const spec = readSpec(specPath);
  if (!spec) {
    throw new Error("No approved spec found. Run /plan first.");
  }

  // 2. Detect sections
  const sections = detectSections(spec.content);

  // 3. Build agent sequence
  const agents: RoutingResult["agents"] = [];

  if (hasBackendIndicators(sections)) {
    agents.push("code-agent");
  }

  if (hasFrontendIndicators(sections)) {
    agents.push("ui-agent");
  }

  if (hasDocsIndicators(sections)) {
    agents.push("docs-agent");
  }

  if (hasEvalIndicators(sections)) {
    agents.push("eval-agent");
  }

  // 4. Handle ambiguous case
  if (agents.length === 0) {
    throw new Error(
      "Unable to determine implementation type. Please clarify: backend, frontend, full-stack, docs, or eval?"
    );
  }

  return {
    agents,
    reason: `Detected: ${agents.join(", ")}`,
    spec: { path: specPath, sections },
  };
}

function detectSections(content: string): string[] {
  const indicators = {
    backend: /prisma|trpc|api|database|schema|mutation|query|server/i,
    frontend: /react|component|form|ui|hook|page|layout|shadcn/i,
    docs: /readme|documentation|guide|tutorial/i,
    eval: /evaluation|grader|benchmark|pass@k|llm test/i,
  };

  return Object.entries(indicators)
    .filter(([_, regex]) => regex.test(content))
    .map(([type]) => type);
}

## Routing: SUCCESS

**Spec:** specs/user-authentication/design.md
**Detected:** Full-stack (backend + frontend)

### Execution Chain

1. **code-agent** (backend)
   - code-researcher → code-writer → code-validator
   - Scope: Prisma schema, tRPC router

2. **ui-agent** (frontend)
   - ui-researcher → ui-builder → ui-validator
   - Scope: Login form, auth context

3. **check-agent** (verification)
   - Parallel: build, types, lint, tests, security

## Routing: ERROR

**Reason:** No approved spec found

### Next Steps

1. Run `/plan` to create a spec
2. Review and approve the spec
3. Run `/implement` again

## Routing: CLARIFY

**Spec:** specs/utils/design.md
**Reason:** Unable to determine implementation type

### Detected Content

- No backend keywords (Prisma, tRPC, API)
- No frontend keywords (React, component, UI)
- No docs keywords (README, guide)
- No eval keywords (grader, benchmark)

### Question

What type of implementation is this?

1. Backend (code-agent)
2. Frontend (ui-agent)
3. Full-stack (code-agent → ui-agent)
4. Documentation (docs-agent)
5. Evaluation (eval-agent)