feat(skills): spawn team agents from sprint briefing in start-sprint

Replace the solo plan-mode step with team orchestration: parse the
Agents line from the sprint briefing, create a team, create tasks
from tickets with dependency chains, and spawn all listed agents as
background teammates. User confirmation gates the spawn.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.claude/skills/start-sprint/SKILL.md

@@ -6,7 +6,7 @@ description: >
   /start-sprint. Merges main into the team branch, finds the active sprint,
   reads the sprint briefing, and presents the work plan with ticket details.
 user-invocable: true
-allowed-tools: Bash, Read, Grep, Glob
+allowed-tools: Bash, Read, Grep, Glob, TeamCreate, Task, TaskCreate, TaskUpdate, TaskList, SendMessage, AskUserQuestion
 ---
 
 # Start Sprint Skill
@@ -80,25 +80,88 @@ Output a summary:
 
 Do NOT mark any ticket as `in_progress` yet.
 
-### 8. Enter plan mode
+### 8. Confirm and spawn the team
 
-After presenting the work plan summary, you MUST enter plan mode using the
-`EnterPlanMode` tool. In plan mode:
+Before spawning agents, use `AskUserQuestion` to confirm the work plan and
+agent lineup with the user. If declined, stop.
 
-1. **Create a concrete sprint plan** — for each actionable ticket, outline:
-   - What files need to be created or modified
-   - What the implementation approach is
-   - What order tickets should be tackled in (respecting dependencies)
-   - Any open questions or risks per ticket
+Once confirmed:
 
-2. **Include blocked tickets** — note what unblocks them and when they might
-   become actionable during the sprint.
+#### 8a. Parse agents from the briefing
 
-3. **Write the plan to the plan file** — the plan should be self-contained so
-   you can follow it step-by-step once approved.
+Extract agent names from the `**Agents:**` line. Format:
+```
+**Agents:** Name (role), Name (role), ...
+```
 
-4. **Exit plan mode** — use `ExitPlanMode` to present the plan for user
-   approval before starting any implementation work.
+Map each name to its `subagent_type` (lowercase):
+- "Dudley (simulation)" → `dudley`
+- "Stig (UI)" → `stig`
+- "Tyre (architecture)" → `tyre`
+- "Hoshe (QA)" → `hoshe`
+- "Mellanie (author)" → `mellanie`
+- etc. (see `.claude/agents/` for full roster)
 
-Only after the user approves the plan should you mark the first ticket as
-`in_progress` and begin implementation.
+#### 8b. Create the team
+
+```
+TeamCreate(team_name: "sprint-{N}-{team}")
+```
+
+This makes you the team lead.
+
+#### 8c. Create tasks from tickets
+
+For each ticket in the briefing, create a task:
+
+```
+TaskCreate(
+  subject: "#{id}: {title}",
+  description: "Full ticket details from step 5, plus briefing notes
+    and integration points for this ticket.",
+  activeForm: "Working on #{id}: {short_title}"
+)
+```
+
+After creating all tasks, mirror the dependency chain from the briefing
+using `TaskUpdate` with `addBlockedBy`.
+
+#### 8d. Spawn agents
+
+For each agent from the `**Agents:**` line, spawn a teammate in the
+background. Spawn all agents in parallel (one message, multiple Task calls):
+
+```
+Task(
+  subagent_type: "{name_lowercase}",
+  team_name: "sprint-{N}-{team}",
+  name: "{name_lowercase}",
+  prompt: "You are on the {team} team for Sprint {N}.
+    Branch: `{team}`
+
+    1. Read the sprint briefing: docs/sprints/sprint-{N}/{team}.md
+    2. Read the decision files referenced in the briefing.
+    3. Check TaskList for available work.
+    4. Claim an unblocked task (TaskUpdate with owner: your name),
+       mark it in_progress, and implement it.
+    5. When done, mark the task completed and check TaskList for
+       the next available task.
+
+    Use `db/connectors/ticket show <id>` for full ticket specs.",
+  description: "Sprint {N} {team}: {name}",
+  run_in_background: true
+)
+```
+
+#### 8e. Report
+
+Output to the user:
+- Team name: `sprint-{N}-{team}`
+- Agents spawned (names and roles)
+- Tasks created (count actionable vs blocked)
+- How to interact: `SendMessage` to talk to agents, `TaskList` to
+  check progress
+
+You are now the team lead. Agents work autonomously — monitor via
+`TaskList`, communicate via `SendMessage`, and handle blockers as
+they arise.