clawpowers 1.1.4 → 2.0.0

package/skills/self-healing-code/SKILL.md

@@ -1,369 +0,0 @@
----
-name: self-healing-code
-description: On test failure, automatically capture the failure, run hypothesis-driven debugging, generate ≥2 candidate patches, apply and measure each, auto-commit the winner or escalate with full context. Max 3 iteration cycles with coverage guard.
-version: 1.0.0
-requires:
-  tools: [bash, git]
-  runtime: true
-metrics:
-  tracks: [healing_attempts, auto_commits, escalations, patches_generated, coverage_delta, cycles_used]
-  improves: [patch_quality, hypothesis_accuracy, escalation_context_completeness]
----
-
-# Self-Healing Code
-
-## When to Use
-
-Apply this skill when:
-
-- A CI run or local test suite produces a failure
-- A previously green test suite goes red after a code change
-- An automated pipeline fails and needs remediation without human intervention
-- Bill runs tests and the output contains `FAILED`, `ERROR`, or non-zero exit code
-
-**Skip when:**
-- Tests fail because of a missing environment variable or missing external service (that's a configuration issue, not a code defect)
-- The failure is a flaky test known to fail intermittently — check `~/.clawpowers/state/known-flaky.json` first
-- A previous healing cycle for this exact error is already in progress (check `~/.clawpowers/state/healing-lock.json`)
-
-**Decision tree:**
-```
-Did the test suite produce a failure?
-├── No  → no action
-└── Yes → Is this a known flaky test?
-          ├── Yes → skip, add flaky annotation, report
-          └── No  → Is a healing cycle already running for this error?
-                    ├── Yes → wait for completion or check lock age
-                    └── No  → self-healing-code ← YOU ARE HERE
-```
-
-## Core Methodology
-
-### Guardrails (enforce before any healing action)
-
-```bash
-# Max cycles — never exceed 3 healing iterations per error
-MAX_CYCLES=3
-HEALING_STATE=~/.clawpowers/state/healing-$(echo "$ERROR_SIG" | md5).json
-CURRENT_CYCLE=$(cat "$HEALING_STATE" 2>/dev/null | node -e "const d=require('/dev/stdin');console.log(d.cycle||0)" 2>/dev/null || echo 0)
-
-if (( CURRENT_CYCLE >= MAX_CYCLES )); then
-  echo "Max cycles ($MAX_CYCLES) reached. Escalating."
-  # → go to Step 6: Escalation
-fi
-
-# Coverage guard — baseline before any patch
-COVERAGE_BASELINE=$(bash runtime/persistence/store.sh get "coverage:baseline:$PROJECT" 2>/dev/null || echo "0")
-```
-
-### Step 1: Capture the Failure
-
-Collect everything needed to understand and reproduce the failure:
-
-```bash
-# Run tests and capture full output
-TEST_OUTPUT=$(bash -c "$TEST_CMD 2>&1") || true
-EXIT_CODE=$?
-
-# Extract structured fields
-TEST_NAME=$(echo "$TEST_OUTPUT" | grep -E "^(FAILED|FAIL|Error in)" | head -1)
-ERROR_MSG=$(echo "$TEST_OUTPUT" | grep -A5 "AssertionError\|Error:\|Exception:" | head -10)
-STACK_TRACE=$(echo "$TEST_OUTPUT" | grep -A20 "Traceback\|at [A-Za-z]" | head -30)
-
-# Diff from last green commit
-LAST_GREEN=$(bash runtime/persistence/store.sh get "last-green:$PROJECT" 2>/dev/null || git log --oneline | grep -i "green\|pass\|ci:" | head -1 | awk '{print $1}')
-DIFF_FROM_GREEN=""
-if [[ -n "$LAST_GREEN" ]]; then
-  DIFF_FROM_GREEN=$(git diff "$LAST_GREEN" HEAD -- . 2>/dev/null | head -200)
-fi
-
-# Error signature hash (for dedup and state tracking)
-ERROR_SIG=$(echo "${TEST_NAME}${ERROR_MSG}" | md5)
-
-# Log the capture
-CAPTURE_RECORD=~/.clawpowers/state/healing-$ERROR_SIG-capture.json
-cat > "$CAPTURE_RECORD" <<EOF
-{
-  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-  "test_name": $(echo "$TEST_NAME" | node -e "process.stdin.on('data',d=>console.log(JSON.stringify(d.toString().trim())))"),
-  "error_msg": $(echo "$ERROR_MSG" | node -e "process.stdin.on('data',d=>console.log(JSON.stringify(d.toString().trim())))"),
-  "exit_code": $EXIT_CODE,
-  "last_green_commit": "$LAST_GREEN",
-  "error_signature": "$ERROR_SIG"
-}
-EOF
-```
-
-**Capture checklist:**
-- [ ] Test name (exact test identifier)
-- [ ] Full error message (not truncated)
-- [ ] Stack trace (full, not just last frame)
-- [ ] Diff from last green commit
-- [ ] Environment snapshot (language version, key deps)
-
-### Step 2: Hypothesis Tree (Systematic Debugging Integration)
-
-Apply the `systematic-debugging` methodology to form ranked hypotheses. This is not optional — random patches without hypotheses produce random results.
-
-```bash
-# Check persistent hypothesis memory first (see systematic-debugging enhancement)
-KNOWN_HYP=$(bash runtime/persistence/store.sh get "debug:hypothesis:$ERROR_SIG" 2>/dev/null)
-if [[ -n "$KNOWN_HYP" ]]; then
-  echo "Known error pattern found. Starting with previously successful hypothesis."
-  echo "$KNOWN_HYP"
-fi
-```
-
-**Hypothesis template for common failure patterns:**
-
-| Failure pattern | Likely hypothesis | Experiment |
-|----------------|------------------|-----------|
-| `AttributeError: 'NoneType' has no attribute X` | Null not guarded in refactored path | Add null check before access |
-| `AssertionError: expected X, got Y` | Logic changed in upstream function | Bisect to find commit, inspect callers |
-| `ConnectionRefusedError` | Service not started or port changed | Check env config, not a code fix |
-| `KeyError: 'field_name'` | Schema changed, consumer not updated | Find all consumers of that key |
-| `TypeError: expected str, got int` | Type coercion removed | Restore coercion or fix caller |
-
-Form 2-4 specific hypotheses before generating patches.
-
-### Step 3: Generate Candidate Patches (Minimum 2)
-
-For each top hypothesis, generate a candidate patch. Generate patches **before** applying any:
-
-```bash
-# Stash current state for rollback safety
-git stash push -m "self-healing-pre-patch-$ERROR_SIG-$(date +%s)"
-STASH_REF=$(git stash list | head -1 | awk '{print $1}' | tr -d ':')
-
-# Generate patch candidates (store as files, don't apply yet)
-mkdir -p ~/.clawpowers/state/patches/$ERROR_SIG
-```
-
-**Patch generation principles:**
-- **Patch A:** Minimal fix — smallest change that addresses the hypothesis (prefer this)
-- **Patch B:** Alternative approach — different mechanism, same outcome
-- **Patch C (if needed):** Defensive fix — add guards to prevent the class of error
-
-**Example (Python null guard):**
-```python
-# Patch A — minimal: add None check at the failure site
-# Before:
-result = user.profile.settings["theme"]
-# After:
-result = user.profile.settings.get("theme", "default") if user.profile else "default"
-
-# Patch B — alternative: fix upstream to guarantee non-null
-# Before:
-def get_user(user_id):
-    return db.query(User).filter_by(id=user_id).first()  # can return None
-# After:
-def get_user(user_id):
-    user = db.query(User).filter_by(id=user_id).first()
-    if user is None:
-        raise UserNotFoundError(f"User {user_id} not found")
-    return user
-```
-
-Write each patch to a file:
-```bash
-# Write patches to staging area
-cat > ~/.clawpowers/state/patches/$ERROR_SIG/patch-a.diff <<'EOF'
-[patch content here]
-EOF
-
-# Capture reasoning for each patch
-echo '{"patch":"a","hypothesis":"null not guarded","mechanism":"add get() with default","confidence":"high"}' \
-  > ~/.clawpowers/state/patches/$ERROR_SIG/patch-a-meta.json
-```
-
-### Step 4: Apply, Test, Measure
-
-Apply patches in order, testing each. Stop at the first winner.
-
-```bash
-# Measure baseline coverage before any patch
-COVERAGE_BEFORE=$(bash -c "$COVERAGE_CMD 2>&1" | grep -E "TOTAL.*[0-9]+%" | grep -oE "[0-9]+%" | tail -1)
-
-for PATCH in a b c; do
-  PATCH_FILE=~/.clawpowers/state/patches/$ERROR_SIG/patch-$PATCH.diff
-  [[ -f "$PATCH_FILE" ]] || continue
-
-  echo "=== Applying patch $PATCH ==="
-
-  # Restore clean state from stash before each patch
-  git stash pop 2>/dev/null || true
-  git stash push -m "self-healing-between-patches-$ERROR_SIG" 2>/dev/null || true
-  git checkout -- . 2>/dev/null || true
-
-  # Apply the patch
-  git apply "$PATCH_FILE" 2>/dev/null || patch -p1 < "$PATCH_FILE" 2>/dev/null
-
-  # Run full test suite
-  TEST_RESULT=$(bash -c "$TEST_CMD 2>&1")
-  TEST_EXIT=$?
-
-  # Measure coverage after patch
-  COVERAGE_AFTER=$(bash -c "$COVERAGE_CMD 2>&1" | grep -E "TOTAL.*[0-9]+%" | grep -oE "[0-9]+%" | tail -1)
-
-  # Coverage guard: never reduce
-  COVERAGE_OK=true
-  if [[ -n "$COVERAGE_BEFORE" && -n "$COVERAGE_AFTER" ]]; then
-    BEFORE_NUM=$(echo "$COVERAGE_BEFORE" | tr -d '%')
-    AFTER_NUM=$(echo "$COVERAGE_AFTER" | tr -d '%')
-    if (( AFTER_NUM < BEFORE_NUM )); then
-      COVERAGE_OK=false
-      echo "Coverage dropped: $COVERAGE_BEFORE → $COVERAGE_AFTER. Patch $PATCH rejected."
-    fi
-  fi
-
-  if [[ $TEST_EXIT -eq 0 && "$COVERAGE_OK" == "true" ]]; then
-    echo "Patch $PATCH PASSED all tests. Coverage: $COVERAGE_BEFORE → $COVERAGE_AFTER"
-    WINNING_PATCH=$PATCH
-    break
-  else
-    echo "Patch $PATCH FAILED. Exit: $TEST_EXIT. Coverage OK: $COVERAGE_OK"
-  fi
-done
-```
-
-### Step 5: Auto-Commit the Winner
-
-If a patch passes all tests and maintains coverage:
-
-```bash
-if [[ -n "$WINNING_PATCH" ]]; then
-  # Commit with full context
-  git add -A
-  git commit -m "fix: self-healing patch for ${TEST_NAME}
-
-Error signature: $ERROR_SIG
-Patch applied: $WINNING_PATCH
-Hypothesis: $(cat ~/.clawpowers/state/patches/$ERROR_SIG/patch-$WINNING_PATCH-meta.json | node -e "const d=require('/dev/stdin');process.stdin.pipe(d.hypothesis)")
-Coverage: $COVERAGE_BEFORE → $COVERAGE_AFTER
-Cycles used: $((CURRENT_CYCLE + 1))/$MAX_CYCLES
-
-[self-healing-code]"
-
-  # Store last-green reference
-  bash runtime/persistence/store.sh set "last-green:$PROJECT" "$(git rev-parse HEAD)"
-
-  # Record success
-  bash runtime/metrics/collector.sh record \
-    --skill self-healing-code \
-    --outcome success \
-    --notes "patch-$WINNING_PATCH won, coverage $COVERAGE_BEFORE→$COVERAGE_AFTER, cycle $((CURRENT_CYCLE+1))/$MAX_CYCLES"
-
-  # Clean up healing state
-  rm -rf ~/.clawpowers/state/patches/$ERROR_SIG
-  rm -f ~/.clawpowers/state/healing-$ERROR_SIG*.json
-fi
-```
-
-### Step 6: Rollback Protocol
-
-If no patch wins after all candidates are tried:
-
-```bash
-if [[ -z "$WINNING_PATCH" ]]; then
-  # Restore to pre-healing state
-  git checkout -- .
-  git stash drop 2>/dev/null || true
-  echo "All patches failed. State restored to pre-healing baseline."
-
-  # Increment cycle counter
-  NEW_CYCLE=$((CURRENT_CYCLE + 1))
-  echo "{\"cycle\": $NEW_CYCLE, \"error_sig\": \"$ERROR_SIG\"}" > "$HEALING_STATE"
-
-  if (( NEW_CYCLE < MAX_CYCLES )); then
-    echo "Cycle $NEW_CYCLE/$MAX_CYCLES complete. Forming new hypotheses."
-    # → Loop back to Step 2 with refined hypotheses
-  else
-    # → Escalate
-    echo "Max cycles reached. Escalating with full context."
-  fi
-fi
-```
-
-### Step 7: Escalation Package
-
-When all cycles are exhausted, escalate with enough context that a human can immediately begin debugging:
-
-```markdown
-## Self-Healing Escalation Report
-
-**Error:** [test_name]
-**Error signature:** [hash]
-**Cycles attempted:** 3/3
-**Time spent:** [duration]
-
-### Failure Details
-[Full test output — not truncated]
-
-### Patches Attempted
-1. Patch A — [hypothesis] — [outcome]
-2. Patch B — [hypothesis] — [outcome]
-3. Patch C — [hypothesis] — [outcome]
-
-### Diff from Last Green
-[git diff output]
-
-### Recommended Next Step
-[Best remaining hypothesis with suggested experiment]
-
-### Relevant Files
-[files touched by failing test]
-```
-
-```bash
-# Record escalation
-bash runtime/metrics/collector.sh record \
-  --skill self-healing-code \
-  --outcome failure \
-  --notes "escalated: $MAX_CYCLES cycles, $PATCHES_TRIED patches, test: $TEST_NAME"
-```
-
-## ClawPowers Enhancement
-
-When `~/.clawpowers/` runtime is initialized:
-
-**Healing state persistence (resumable across sessions):**
-
-```bash
-# Save healing progress
-bash runtime/persistence/store.sh set "healing:$ERROR_SIG:cycle" "$CURRENT_CYCLE"
-bash runtime/persistence/store.sh set "healing:$ERROR_SIG:stash" "$STASH_REF"
-bash runtime/persistence/store.sh set "healing:$ERROR_SIG:patches_tried" "$PATCHES_TRIED"
-
-# Resume an interrupted healing session
-ERROR_SIG="<hash>"
-CYCLE=$(bash runtime/persistence/store.sh get "healing:$ERROR_SIG:cycle")
-STASH=$(bash runtime/persistence/store.sh get "healing:$ERROR_SIG:stash")
-echo "Resuming healing cycle $CYCLE for error $ERROR_SIG"
-```
-
-**Regression detection:**
-```bash
-# After auto-commit, verify no regressions in related tests
-RELATED_TESTS=$(git diff HEAD~1 HEAD --name-only | xargs grep -l "def test_" 2>/dev/null | head -10)
-bash -c "$TEST_CMD $RELATED_TESTS 2>&1"
-```
-
-**Pattern learning (feeds systematic-debugging):**
-```bash
-# After successful heal, store the winning pattern
-bash runtime/persistence/store.sh set "debug:hypothesis:$ERROR_SIG" \
-  "$(cat ~/.clawpowers/state/patches/$ERROR_SIG/patch-$WINNING_PATCH-meta.json)"
-```
-
-## Anti-Patterns
-
-| Anti-Pattern | Why It Fails | Correct Approach |
-|-------------|-------------|-----------------|
-| Apply patches without stashing first | No rollback path if all patches fail | Always stash before first patch |
-| Skip hypothesis formation | Random patches waste all 3 cycles | Form ranked hypotheses before any patch |
-| Generate only 1 patch | Single point of failure | Always generate ≥ 2 patches before applying |
-| Skip coverage check | Patches that delete tests always "pass" | Coverage guard is non-negotiable |
-| Apply patches sequentially without reset | Patches contaminate each other | Reset to clean state between each patch |
-| Commit without full test suite pass | Partial fixes break other tests | Run full suite, not just the failing test |
-| Exceed 3 cycles | Spiraling into a rabbit hole | Hard limit at 3; escalate cleanly |
-| Escalate without full context | Human must re-investigate from scratch | Escalation package must include all evidence |

package/skills/subagent-driven-development/SKILL.md

@@ -1,244 +0,0 @@
----
-name: subagent-driven-development
-description: Orchestrate complex tasks by dispatching fresh subagents with isolated context, two-stage review, and Git worktree isolation. Activate when a task is large enough to benefit from parallelism or context separation.
-version: 1.0.0
-requires:
-  tools: [git, bash]
-  runtime: false
-metrics:
-  tracks: [tasks_dispatched, subagent_success_rate, review_pass_rate, time_to_completion]
-  improves: [task_decomposition_quality, spec_clarity, review_threshold]
----
-
-# Subagent-Driven Development
-
-## When to Use
-
-Apply this skill when you encounter:
-
-- A task with 3+ logically independent workstreams
-- A task so large it would exhaust a single context window
-- A feature requiring multiple specialists (frontend + backend + tests + docs)
-- Any work where a bug in one component shouldn't block another
-- A task with clear interfaces between components (you can spec them up front)
-
-**Skip this skill when:**
-- The task is tightly coupled — one change cascades everywhere
-- You need to maintain narrative continuity across all components
-- The task is < 2 hours of work for a single agent
-- You don't have enough information to spec subagent boundaries yet
-
-**Decision tree:**
-```
-Can the task be split into N parts with defined interfaces?
-├── No  → single-agent execution
-└── Yes → Can subagents work concurrently without blocking each other?
-          ├── No  → sequential execution with checkpointing (executing-plans)
-          └── Yes → subagent-driven-development ← YOU ARE HERE
-```
-
-## Core Methodology
-
-### Stage 0: Task Decomposition (do this yourself, not in a subagent)
-
-Before dispatching anything, produce:
-
-1. **Task tree** — hierarchical breakdown of the full work
-2. **Subagent boundaries** — where one agent's output is another's input
-3. **Interface contracts** — what each subagent accepts and delivers
-4. **Dependency order** — which can run in parallel, which must sequence
-
-**Decomposition heuristic:** Each subagent task should be completable in 1 context window (roughly 2-5K tokens of output). If larger, decompose further.
-
-**Example decomposition for "Build authentication service":**
-```
-auth-service/
-├── Subagent A: API design + OpenAPI spec     [no dependencies]
-├── Subagent B: Database schema + migrations   [no dependencies]  
-├── Subagent C: Core auth logic (JWT, bcrypt)  [depends on: A, B specs]
-├── Subagent D: Integration tests              [depends on: C output]
-└── Subagent E: Documentation                 [depends on: A, C, D output]
-```
-
-### Stage 1: Spec Writing (per subagent)
-
-For each subagent, write a precise spec that includes:
-
-```markdown
-## Subagent Spec: [Component Name]
-
-**Objective:** [Single sentence — what this subagent produces]
-
-**Context provided:**
-- [File or artifact they receive as input]
-- [Interface contract from upstream subagent]
-
-**Deliverables:**
-- [Specific file or artifact, not vague output]
-- [Test file covering the deliverable]
-
-**Constraints:**
-- [Language/framework requirements]
-- [Performance requirements if applicable]
-- [Must not break: existing interfaces]
-
-**Done criteria:**
-- [ ] All tests pass
-- [ ] Interface contract satisfied
-- [ ] No TODOs or stubs in production code
-```
-
-**Anti-pattern:** Vague specs produce vague output. "Build the auth logic" is not a spec. "Implement JWT issuance and validation with RS256, returning {token, expiresAt, userId} from issue() and {valid, userId, error} from validate()" is a spec.
-
-### Stage 2: Worktree Isolation
-
-Each subagent works in an isolated Git worktree to prevent interference:
-
-```bash
-# Create worktrees for parallel subagents
-git worktree add ../task-auth-api feature/auth-api
-git worktree add ../task-auth-db feature/auth-db
-git worktree add ../task-auth-core feature/auth-core
-
-# Verify isolation
-git worktree list
-```
-
-Worktrees share the repo history but have independent working directories. A subagent working in `../task-auth-api` cannot accidentally overwrite files in `../task-auth-core`.
-
-See: `skills/using-git-worktrees/SKILL.md` for full worktree management protocol.
-
-### Stage 3: Subagent Dispatch
-
-Dispatch each subagent with:
-1. The spec (complete, not abbreviated)
-2. All input artifacts (relevant files, interface contracts)
-3. Access to their assigned worktree
-4. No instruction to "skip complicated parts" or "use a stub"
-
-**Dispatch instruction template:**
-```
-You are implementing [component]. Your spec is below. Work only in the provided 
-worktree directory. Produce real, working code with tests — no stubs, no TODOs.
-Deliver: [specific files]. When done, output a JSON summary of what you built.
-
-[Full spec here]
-```
-
-### Stage 4: Two-Stage Review
-
-**Stage 4a: Spec review** — Before running any subagent code, review that:
-- The output matches the spec's deliverables
-- Interface contracts are satisfied (types match, method signatures match)
-- No stubs or mocks in production code paths
-- Tests exist and cover the critical paths
-
-**Stage 4b: Quality review** — After running the code:
-- All tests pass (zero failing)
-- No linting errors
-- Performance meets requirements
-- Security: no hardcoded credentials, no SQL injection vectors, no unvalidated inputs
-
-**Review failure protocol:**
-```
-If Stage 4a fails → return spec to subagent with specific failure reason
-If Stage 4b fails → return to subagent with exact failing test output
-Never merge code that fails either review stage
-```
-
-### Stage 5: Integration
-
-After all subagents pass review:
-
-1. Merge worktrees in dependency order
-2. Run full integration test suite
-3. Resolve any interface mismatches (typically minor type issues)
-4. Clean up worktrees
-
-```bash
-# Merge in order (B and C are independent, merge alphabetically)
-git checkout main
-git merge feature/auth-db
-git merge feature/auth-api  
-git merge feature/auth-core   # depends on both
-git merge feature/auth-tests
-git merge feature/auth-docs
-
-# Clean up
-git worktree remove ../task-auth-api
-git worktree remove ../task-auth-db
-# ... etc
-```
-
-## ClawPowers Enhancement
-
-When `~/.clawpowers/` runtime is initialized:
-
-**Persistent Execution DB:** Every subagent dispatch is logged with spec hash, start time, subagent ID, and outcome. If a session is interrupted, you know exactly which subagents completed and which to re-run.
-
-```bash
-# Record dispatch
-bash runtime/persistence/store.sh set "subagent:auth-api:status" "dispatched"
-bash runtime/persistence/store.sh set "subagent:auth-api:spec_hash" "$(echo "$SPEC" | sha256sum | cut -c1-8)"
-
-# Check on resume
-bash runtime/persistence/store.sh get "subagent:auth-api:status"
-```
-
-**Resumable Checkpoints:** The framework saves the task tree and each subagent's completion state. A session that crashes mid-dispatch resumes from the last successful checkpoint, not from scratch.
-
-**Outcome Metrics:** After integration, record:
-```bash
-bash runtime/metrics/collector.sh record \
-  --skill subagent-driven-development \
-  --outcome success \
-  --duration 3600 \
-  --notes "auth-service: 5 subagents, 2 review cycles, 0 integration failures"
-```
-
-**Metric-driven decomposition:** After 10+ executions, `runtime/feedback/analyze.sh` identifies your optimal subagent granularity — tasks that are too small (high coordination overhead) or too large (high review failure rate).
-
-## Anti-Patterns
-
-| Anti-Pattern | Why It Fails | Correct Approach |
-|-------------|-------------|-----------------|
-| Vague spec ("build the auth thing") | Subagent guesses, output is wrong | Write spec with deliverables and done criteria |
-| Skip the failure witness | Review catches nothing | Require all tests to pass in the review stage |
-| Merge before review | Bad code enters main | Two-stage review is non-negotiable |
-| Single worktree for multiple agents | Files overwrite each other | One worktree per subagent, always |
-| Decompose too fine | Excessive coordination cost | Target 1-context-window tasks (2-5K token output) |
-| Decompose too coarse | Subagent context exhaustion | If output > 1 context window, split further |
-| Stub the hard parts | Tech debt accumulates | "No stubs" is a hard constraint in the spec |
-
-## Examples
-
-### Example 1: Simple (2 subagents)
-
-**Task:** Add email verification to existing user signup
-
-**Decomposition:**
-- Subagent A: Email service integration (SendGrid/SES wrapper, template rendering)
-- Subagent B: Verification flow (token generation, storage, verification endpoint)
-- Sequential: B depends on A's interface
-
-**Specs:** A delivers `EmailService` class with `send(to, template, vars)` → B uses that interface
-
-### Example 2: Complex (5 subagents)
-
-**Task:** Build real-time dashboard
-
-**Decomposition:**
-- Subagent A: WebSocket server (connection mgmt, message routing) [parallel]
-- Subagent B: Data aggregation service (query engine, caching) [parallel]
-- Subagent C: Frontend dashboard components (React, chart library) [parallel]
-- Subagent D: Integration tests (WebSocket + aggregation E2E) [depends on A, B]
-- Subagent E: Dashboard state management (connects C to A/B) [depends on A, B, C]
-
-**Parallel dispatch:** A, B, C run concurrently. D and E run after A, B, C complete review.
-
-## Integration with Other Skills
-
-- Use `writing-plans` first if you don't have a clear task tree yet
-- Apply `using-git-worktrees` for worktree lifecycle management
-- Use `dispatching-parallel-agents` if subagents run as independent processes
-- Apply `verification-before-completion` before final integration merge