feat(agent-teams): add plugin for multi-agent team orchestration

New plugin with 7 presets (review, debug, feature, fullstack, research,
security, migration), 4 specialized agents, 7 slash commands, 6 skills
with reference docs, and Context7 MCP integration for research teams.

plugins/agent-teams/skills/task-coordination-strategies/references/dependency-graphs.md

@@ -0,0 +1,97 @@
+# Dependency Graph Patterns
+
+Visual patterns for task dependency design with trade-offs.
+
+## Pattern 1: Fully Independent (Maximum Parallelism)
+
+```
+Task A ─┐
+Task B ─┼─→ Final Integration
+Task C ─┘
+```
+
+- **Parallelism**: Maximum — all tasks run simultaneously
+- **Risk**: Integration may reveal incompatibilities late
+- **Use when**: Tasks operate on completely separate files/modules
+- **TaskCreate**: No blockedBy relationships; integration task blocked by all
+
+## Pattern 2: Sequential Chain (No Parallelism)
+
+```
+Task A → Task B → Task C → Task D
+```
+
+- **Parallelism**: None — each task waits for the previous
+- **Risk**: Bottleneck at each step; one delay cascades
+- **Use when**: Each task depends on the output of the previous (avoid if possible)
+- **TaskCreate**: Each task blockedBy the previous
+
+## Pattern 3: Diamond (Shared Foundation)
+
+```
+           ┌→ Task B ─┐
+Task A ──→ ┤          ├→ Task D
+           └→ Task C ─┘
+```
+
+- **Parallelism**: B and C run in parallel after A completes
+- **Risk**: A is a bottleneck; D must wait for both B and C
+- **Use when**: B and C both need output from A (e.g., shared types)
+- **TaskCreate**: B and C blockedBy A; D blockedBy B and C
+
+## Pattern 4: Fork-Join (Phased Parallelism)
+
+```
+Phase 1:  A1, A2, A3  (parallel)
+          ────────────
+Phase 2:  B1, B2      (parallel, after phase 1)
+          ────────────
+Phase 3:  C1          (after phase 2)
+```
+
+- **Parallelism**: Within each phase, tasks are parallel
+- **Risk**: Phase boundaries add synchronization delays
+- **Use when**: Natural phases with dependencies (build → test → deploy)
+- **TaskCreate**: Phase 2 tasks blockedBy all Phase 1 tasks
+
+## Pattern 5: Pipeline (Streaming)
+
+```
+Task A ──→ Task B ──→ Task C
+  └──→ Task D ──→ Task E
+```
+
+- **Parallelism**: Two parallel chains
+- **Risk**: Chains may diverge in approach
+- **Use when**: Two independent feature branches from a common starting point
+- **TaskCreate**: B blockedBy A; D blockedBy A; C blockedBy B; E blockedBy D
+
+## Anti-Patterns
+
+### Circular Dependency (Deadlock)
+
+```
+Task A → Task B → Task C → Task A  ✗ DEADLOCK
+```
+
+**Fix**: Extract shared dependency into a separate task that all three depend on.
+
+### Unnecessary Dependencies
+
+```
+Task A → Task B → Task C
+(where B doesn't actually need A's output)
+```
+
+**Fix**: Remove the blockedBy relationship; let B run independently.
+
+### Star Pattern (Single Bottleneck)
+
+```
+     ┌→ B
+A →  ├→ C  → F
+     ├→ D
+     └→ E
+```
+
+**Fix**: If A is slow, all downstream tasks are delayed. Try to parallelize A's work.