---
description: "Analyse a wiring spec and produce an optimal agent assignment plan with zero file overlap. Usage: /assign-agents <path-to-spec>"
allowed-tools: ["Read", "Glob", "Grep"]
---

# Assign Agents: $ARGUMENTS

You are an agent orchestrator. Your job is to read a wiring spec, map every file each item touches, find the maximum safe parallelism with zero file overlap, and output an assignment plan.

## Step 1: Read the spec

Read the file at: `$ARGUMENTS`

If no path given, search for the most recent spec in `specs/` that contains an "Inventory Item Checklist" section.

## Step 2: Extract the file conflict map

For EVERY numbered item in the spec's checklist:
1. Read the "Changes needed (Swift)" and "Changes needed (HTML)" sections
2. Extract every file path mentioned (exact paths from the spec)
3. Record: Item # → [list of files it touches]

## Step 3: Build the conflict matrix

Create a matrix showing which files are touched by which items. Identify:
- **Bottleneck files** — touched by 3+ items (these CANNOT be parallelised)
- **Isolated files** — touched by only 1-2 items (safe for dedicated agents)
- **New files** — files that don't exist yet (safe, no conflicts)

## Step 4: Determine maximum parallelism

Rules:
- Two agents CANNOT write to the same file
- An agent owns ALL changes to its assigned files
- Bottleneck files must be handled by a single integration agent that runs AFTER parallel agents
- The HTML preview file (`preview/chat.html` or equivalent) should run LAST because it must mirror the final Swift code for parity (per Mandatory rule #3)
- Group related items that touch the same isolated file into one agent
- Minimise total agents — don't create an agent for a single 2-line change

## Step 5: Output the assignment plan

Output this EXACTLY in chat (not to a file — this is a decision aid, not a document):

```
## File Conflict Map

| File | Items | Touch Count |
|------|-------|-------------|
| `<file>` | #N, #N, #N | N |

Bottlenecks: <list files touched by 3+ items>
Isolated: <list files touched by 1-2 items>
New files: <list files that need creating>

## Agent Assignment

### Phase 1 (parallel — N agents)

| Agent | Name | Files (exclusive) | Spec Items | Est. Changes |
|-------|------|--------------------|------------|-------------|
| A | `<name>` | `<files>` | #N, #N | N lines |
| B | `<name>` | `<files>` | #N, #N | N lines |

### Phase 2 (sequential — after phase 1)

| Agent | Name | Files | Spec Items | Why Sequential |
|-------|------|-------|------------|----------------|
| C | `<name>` | `<bottleneck files>` | #N, #N, #N | Touches shared files, integrates callbacks from phase 1 |

### Phase 3 (sequential — after phase 2)

| Agent | Name | Files | Spec Items | Why Last |
|-------|------|-------|------------|----------|
| D | `html-parity` | `preview/*.html` | All HTML portions | Must read final Swift to ensure 1:1 parity |

## Summary

| Metric | Value |
|--------|-------|
| Total agents | N |
| Max concurrent | N |
| Phases | N |
| Total spec items | N |
| Items per agent (avg) | N |

## Launch Order

Phase 1: Launch A, B, C in parallel
Phase 2: After phase 1 completes, launch D
Phase 3: After phase 2 completes, launch E
```

## Rules

- NEVER assign two agents to the same file
- Always put HTML as the LAST phase (parity requirement)
- Always put bottleneck files (ChatView, ChatViewModel, etc.) in their own sequential phase
- If a spec item touches both an isolated file AND a bottleneck file, split it: the isolated file change goes to the parallel agent, the bottleneck file change goes to the integration agent
- Name agents descriptively based on what they own (e.g. `input-agent`, `bubble-agent`, not `agent-1`)
- Estimate changes as: small (< 20 lines), medium (20-80 lines), large (80+ lines)
- If the entire spec has fewer than 5 items, recommend a single agent instead of splitting
- The output goes to CHAT only — do not write a file. This is a planning tool, not a document.