feat: Add Claude Code agent team support to execution skills

Add team mode as an optional execution path for all three execution
skills, gated behind TeamCreate detection and user choice:

- writing-plans: Third execution handoff option (team-based)
- subagent-driven-development: Full team mode with parallel
  implementers, sequential review gates, team lifecycle management
- dispatching-parallel-agents: Team mode alternative with
  inter-agent messaging and shared task tracking
- executing-plans: Within-batch parallelism via teams

All changes are additive and cross-platform safe - team features
only activate on Claude Code with teams enabled, existing behavior
is preserved on Codex, OpenCode, and Claude Code without teams.

Relates to: #469

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

Author: marciogranzotto

skills/dispatching-parallel-agents/SKILL.md

@@ -79,6 +79,37 @@ When agents return:
 - Run full test suite
 - Integrate all changes
 
+## Team Mode (Claude Code Only)
+
+If `TeamCreate` is available and the user opts in, use a coordinated team instead of individual `Task` calls.
+
+### Standard Mode vs Team Mode
+
+| Aspect | Standard (Task calls) | Team Mode |
+|--------|----------------------|-----------|
+| Dispatch | Individual `Task` tool calls | `TeamCreate` + team members |
+| Communication | None between agents | `SendMessage` for sharing findings |
+| Progress tracking | Wait for Task return | Shared `TaskList` with live status |
+| Result collection | Read each Task result | Agents report via messages + `TaskUpdate` |
+| Best for | Quick independent investigations | Longer investigations needing coordination |
+
+### When to Prefer Team Mode
+
+- Investigations may need to share context mid-flight (e.g., "I found the root cause is in module X, check if it affects your area too")
+- More than 3 parallel agents (better lifecycle management)
+- Agents may discover dependencies during investigation
+
+### Team Mode Pattern
+
+1. **Create team:** `TeamCreate` with descriptive name
+2. **Spawn investigators:** One team member per independent domain
+3. **Let them work:** Agents investigate, can message each other if relevant findings
+4. **Collect results:** Team lead monitors `TaskList`, reads agent messages
+5. **Integrate:** Same as standard - verify fixes don't conflict, run full suite
+6. **Shutdown:** `shutdown_request` to all members, then `TeamDelete`
+
+**Cross-platform note:** Team mode requires Claude Code with teams enabled (beta). On Codex, OpenCode, or Claude Code without teams, use the standard parallel `Task` dispatch. Always detect capability before offering team mode.
+
 ## Agent Prompt Structure
 
 Good agent prompts are:

skills/executing-plans/SKILL.md

@@ -49,6 +49,30 @@ After all tasks complete and verified:
 - **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
 - Follow that skill to verify tests, present options, execute choice
 
+### Team Mode (Claude Code Only)
+
+If `TeamCreate` is available and the user opted in during the writing-plans handoff, parallelize tasks within each batch.
+
+**What changes:**
+- Step 2 (Execute Batch): Instead of executing 3 tasks sequentially, spawn a team and assign batch tasks to team members working in parallel
+- Step 3 (Report): Wait for all batch members to complete, then report combined results
+- Steps 1, 4, 5: Unchanged (plan review, feedback loop, and completion stay the same)
+
+**What doesn't change:**
+- Batch boundaries and human review checkpoints remain
+- Default batch size is still 3 tasks
+- "Ready for feedback" checkpoint after each batch
+- The human-in-the-loop approval between batches is preserved
+
+**Team lifecycle per batch:**
+1. `TeamCreate` for the batch (or reuse existing team)
+2. Assign batch tasks to team members
+3. Wait for all to complete
+4. Report results, wait for feedback
+5. `TeamDelete` when all work is done (or reuse for next batch)
+
+**Cross-platform note:** Team mode requires Claude Code with teams enabled (beta). On Codex, OpenCode, or Claude Code without teams, use the standard sequential batch execution. Always detect capability before offering team mode.
+
 ## When to Stop and Ask for Help
 
 **STOP executing immediately when:**

skills/subagent-driven-development/SKILL.md

@@ -16,16 +16,20 @@ digraph when_to_use {
     "Have implementation plan?" [shape=diamond];
     "Tasks mostly independent?" [shape=diamond];
     "Stay in this session?" [shape=diamond];
-    "subagent-driven-development" [shape=box];
+    "TeamCreate available and user opted in?" [shape=diamond];
+    "subagent-driven-development (team mode)" [shape=box];
+    "subagent-driven-development (standard)" [shape=box];
     "executing-plans" [shape=box];
     "Manual execution or brainstorm first" [shape=box];
 
     "Have implementation plan?" -> "Tasks mostly independent?" [label="yes"];
     "Have implementation plan?" -> "Manual execution or brainstorm first" [label="no"];
     "Tasks mostly independent?" -> "Stay in this session?" [label="yes"];
     "Tasks mostly independent?" -> "Manual execution or brainstorm first" [label="no - tightly coupled"];
-    "Stay in this session?" -> "subagent-driven-development" [label="yes"];
+    "Stay in this session?" -> "TeamCreate available and user opted in?" [label="yes"];
     "Stay in this session?" -> "executing-plans" [label="no - parallel session"];
+    "TeamCreate available and user opted in?" -> "subagent-driven-development (team mode)" [label="yes"];
+    "TeamCreate available and user opted in?" -> "subagent-driven-development (standard)" [label="no"];
 }
 ```
 
@@ -35,6 +39,12 @@ digraph when_to_use {
 - Two-stage review after each task: spec compliance first, then code quality
 - Faster iteration (no human-in-loop between tasks)
 
+**Team mode vs. Standard mode:**
+- True parallelism (multiple implementers working simultaneously on independent tasks)
+- Persistent coordination via `SendMessage` and shared `TaskList`
+- Review gates remain sequential per task (spec then quality)
+- Requires Claude Code with teams feature enabled (beta)
+
 ## The Process
 
 ```dot
@@ -82,6 +92,88 @@ digraph process {
 }
 ```
 
+## Team Mode (Claude Code Only)
+
+When the user opts into team mode and `TeamCreate` is available, use this alternative flow instead of the standard sequential process above.
+
+**Core difference:** Independent tasks run in parallel via team members. Review gates remain sequential per task.
+
+### Team Composition
+
+- **Team Lead (you):** Orchestrates work, assigns tasks, reviews results
+- **Implementer agents:** One per independent task, spawned as team members
+- **Reviewer agents:** Dispatched per task after implementation completes (spec then quality)
+
+### Team Mode Process
+
+```dot
+digraph team_process {
+    rankdir=TB;
+
+    "Read plan, extract tasks, identify independent groups" [shape=box];
+    "TeamCreate with implementer agents" [shape=box];
+    "Assign independent tasks to implementers via TaskCreate" [shape=box];
+    "Implementers work in parallel" [shape=box];
+    "As each implementer completes:" [shape=box];
+
+    subgraph cluster_per_task {
+        label="Per Completed Task (sequential)";
+        "Dispatch spec reviewer for task" [shape=box];
+        "Spec passes?" [shape=diamond];
+        "Send fix instructions to implementer" [shape=box];
+        "Dispatch code quality reviewer" [shape=box];
+        "Quality passes?" [shape=diamond];
+        "Send quality fix instructions" [shape=box];
+        "Mark task complete" [shape=box];
+    }
+
+    "More tasks to assign?" [shape=diamond];
+    "Assign next batch to idle implementers" [shape=box];
+    "All tasks complete" [shape=box];
+    "Shutdown team" [shape=box];
+    "Final code review + finishing-a-development-branch" [shape=box];
+
+    "Read plan, extract tasks, identify independent groups" -> "TeamCreate with implementer agents";
+    "TeamCreate with implementer agents" -> "Assign independent tasks to implementers via TaskCreate";
+    "Assign independent tasks to implementers via TaskCreate" -> "Implementers work in parallel";
+    "Implementers work in parallel" -> "As each implementer completes:";
+    "As each implementer completes:" -> "Dispatch spec reviewer for task";
+    "Dispatch spec reviewer for task" -> "Spec passes?";
+    "Spec passes?" -> "Send fix instructions to implementer" [label="no"];
+    "Send fix instructions to implementer" -> "Dispatch spec reviewer for task";
+    "Spec passes?" -> "Dispatch code quality reviewer" [label="yes"];
+    "Dispatch code quality reviewer" -> "Quality passes?";
+    "Quality passes?" -> "Send quality fix instructions" [label="no"];
+    "Send quality fix instructions" -> "Dispatch code quality reviewer";
+    "Quality passes?" -> "Mark task complete" [label="yes"];
+    "Mark task complete" -> "More tasks to assign?";
+    "More tasks to assign?" -> "Assign next batch to idle implementers" [label="yes"];
+    "Assign next batch to idle implementers" -> "Implementers work in parallel";
+    "More tasks to assign?" -> "All tasks complete" [label="no"];
+    "All tasks complete" -> "Shutdown team";
+    "Shutdown team" -> "Final code review + finishing-a-development-branch";
+}
+```
+
+### Key Constraints in Team Mode
+
+- **Review gates are still sequential per task:** spec review must pass before code quality review
+- **Dependent tasks must wait:** only dispatch tasks whose dependencies are complete
+- **Implementers on different tasks in parallel is OK:** they work on separate files
+- **Implementers on the same task is NOT OK:** one implementer per task
+- **Team lead handles review dispatch:** don't delegate review scheduling to implementers
+- **Use SendMessage for fix instructions:** when a reviewer finds issues, message the implementer with specific fixes needed
+- **Use shared TaskList for tracking:** all task state lives in the team's task list
+
+### Team Lifecycle
+
+1. **Create:** `TeamCreate` at start of execution
+2. **Staff:** Spawn implementer agents as team members via `Task` with `team_name`
+3. **Assign:** Create tasks via `TaskCreate`, assign via `TaskUpdate` with `owner`
+4. **Coordinate:** Use `SendMessage` for review feedback, fix instructions
+5. **Shutdown:** Send `shutdown_request` to all team members when complete
+6. **Cleanup:** `TeamDelete` after all members shut down
+
 ## Prompt Templates
 
 - `./implementer-prompt.md` - Dispatch implementer subagent
@@ -212,6 +304,13 @@ Done!
 - **Start code quality review before spec compliance is ✅** (wrong order)
 - Move to next task while either review has open issues
 
+**Team mode specific - Never:**
+- Use team mode when `TeamCreate` is not available (fall back to standard mode)
+- Assume team mode works on non-Claude-Code environments (Codex, OpenCode)
+- Skip the user choice - always ask before spawning a team
+- Let implementers self-assign tasks (team lead assigns via `TaskUpdate`)
+- Forget to shutdown the team (always send `shutdown_request` + `TeamDelete`)
+
 **If subagent asks questions:**
 - Answer clearly and completely
 - Provide additional context if needed

skills/writing-plans/SKILL.md

@@ -96,14 +96,18 @@ git commit -m "feat: add specific feature"
 
 ## Execution Handoff
 
-After saving the plan, offer execution choice:
+After saving the plan, check for team support and offer execution choice:
 
-**"Plan complete and saved to `docs/plans/<filename>.md`. Two execution options:**
+**Detection:** Before presenting options, check if the `TeamCreate` tool is available in this environment. If it is, include Option 3 below. If not, only show Options 1 and 2.
+
+**"Plan complete and saved to `docs/plans/<filename>.md`. Execution options:**
 
 **1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration
 
 **2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints
 
+**3. Team-Based (parallel, this session)** *(only if TeamCreate is available)* - Spawn an agent team with parallel implementers and reviewers, coordinated via shared task list
+
 **Which approach?"**
 
 **If Subagent-Driven chosen:**
@@ -114,3 +118,9 @@ After saving the plan, offer execution choice:
 **If Parallel Session chosen:**
 - Guide them to open new session in worktree
 - **REQUIRED SUB-SKILL:** New session uses superpowers:executing-plans
+
+**If Team-Based chosen:**
+- **REQUIRED SUB-SKILL:** Use superpowers:subagent-driven-development (team mode)
+- Stay in this session
+- `TeamCreate` to spawn parallel implementers
+- Shared `TaskList` for coordination