Compositions

{
  "hooks": {
    "TeammateIdle": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'INPUT=$(cat); NAME=$(echo \"$INPUT\" | jq -r \".teammate_name\"); if [ \"$NAME\" = \"implementer\" ]; then PENDING=$(find .claude/tasks/ -name \"*.json\" -exec grep -l \"pending\" {} + 2>/dev/null | wc -l); if [ \"$PENDING\" -gt 0 ]; then echo \"$PENDING tasks still pending -- keep working\" >&2; exit 2; fi; fi; exit 0'"
          }
        ]
      }
    ]
  }
}

#!/bin/bash
# .claude/hooks/validate-task.sh
INPUT=$(cat)
TASK_SUBJECT=$(echo "$INPUT" | jq -r '.task_subject')
TASK_DESC=$(echo "$INPUT" | jq -r '.task_description // empty')
 
# Require action verb prefix
if ! echo "$TASK_SUBJECT" | grep -qE '^(Add|Fix|Implement|Refactor|Update|Remove|Test|Review)'; then
  echo "Task subject must start with an action verb" >&2
  exit 2
fi
 
# Require description for non-trivial tasks
if [ -z "$TASK_DESC" ] && ! echo "$TASK_SUBJECT" | grep -qi "review\|test"; then
  echo "Non-review tasks require a description" >&2
  exit 2
fi
 
exit 0

#!/bin/bash
# .claude/hooks/verify-completion.sh
INPUT=$(cat)
TASK_SUBJECT=$(echo "$INPUT" | jq -r '.task_subject')
 
# Implementation tasks must pass tests
if echo "$TASK_SUBJECT" | grep -qiE '(implement|add|fix|refactor)'; then
  if ! npm test 2>/dev/null; then
    echo "Tests must pass before marking implementation tasks complete" >&2
    exit 2
  fi
fi
 
# Writing tasks must pass lint
if echo "$TASK_SUBJECT" | grep -qiE '(implement|add|fix|refactor|write)'; then
  if ! npm run lint 2>/dev/null; then
    echo "Linting must pass before marking this task complete" >&2
    exit 2
  fi
fi
 
exit 0

# .claude/skills/review-team/SKILL.md
---
name: review-team
description: Spin up a full review team for a PR
disable-model-invocation: true
allowed-tools: Bash(gh *)
---
 
## PR Context
- PR diff: !`gh pr diff`
- Changed files: !`gh pr diff --name-only`
 
## Instructions
 
Create an agent team to review this PR with three reviewers:
 
1. **Security reviewer**: Focus on auth, input validation, injection,
   secrets exposure. Use the security-reviewer agent type.
 
2. **Performance reviewer**: Focus on N+1 queries, unnecessary
   allocations, missing indexes, expensive operations in hot paths.
 
3. **Correctness reviewer**: Focus on logic errors, edge cases,
   error handling, race conditions, and whether tests cover the changes.
 
Have each reviewer submit their findings as a structured report.
After all three complete, synthesize a unified review with:
- Critical issues (must fix before merge)
- Suggestions (should fix, not blocking)
- Nits (style/preference)
 
Post the unified review as a PR comment using `gh pr comment`.

# .claude/skills/vertical-slice/SKILL.md
---
name: vertical-slice
description: Implement a feature as a vertical slice with parallel agents
disable-model-invocation: false
allowed-tools: Bash(git *) Bash(npm *)
---
 
## Context
- Current branch: !`git branch --show-current`
- Recent commits: !`git log --oneline -5`
 
## Instructions
 
Implement $ARGUMENTS as a vertical slice using an agent team:
 
1. **API agent** (Sonnet, worktree isolation):
   - Implement the API route and service layer
   - Write integration tests for the endpoint
   - Domain: src/api/, src/services/, __tests__/api/
 
2. **UI agent** (Sonnet, worktree isolation):
   - Implement the React component and page
   - Wire up data fetching to the new API
   - Domain: src/components/, src/pages/, __tests__/ui/
 
3. **Schema agent** (Sonnet):
   - Create the database migration
   - Update the Prisma schema and generate types
   - Domain: prisma/, src/models/
 
Schema agent completes first. API and UI agents work in parallel after.
Each agent runs tests in its domain before marking tasks complete.

# .claude/agents/db-analyst.md
---
name: db-analyst
description: Analyzes database performance and query patterns
tools: Read, Grep, Bash
mcpServers:
  - postgres-mcp:
      type: stdio
      command: npx
      args: ["-y", "@postgres-mcp/server"]
      env:
        DATABASE_URL: "${DATABASE_URL}"
  - github
---
 
You are a database performance analyst. Use the PostgreSQL MCP tools
to analyze query plans, identify slow queries, and recommend index
optimizations. Cross-reference with the application code to understand
query origins.

# .claude/agents/code-reviewer.md
---
name: code-reviewer
description: Reviews code for quality and best practices
tools: Read, Grep, Glob, Bash
memory: project
model: sonnet
---
 
You are a code reviewer. As you review code:
 
1. Check your agent memory for patterns and conventions you've seen
   in this codebase before starting the review.
2. Apply known conventions to your review feedback.
3. After completing the review, update your agent memory with:
   - New patterns or conventions you discovered
   - Common issues you found (to check for proactively next time)
   - Architectural decisions that should be preserved
 
Memory location: .claude/agent-memory/code-reviewer/

# Start Claude in a named worktree
claude --worktree feature-auth
 
# Auto-generate a worktree name
claude --worktree

---
name: parallel-implementer
description: Implements features in isolated worktrees
isolation: worktree
---

# .worktreeinclude
.env
.env.local
config/secrets.json

# CLAUDE.md
 
## Agent Team Conventions
 
When working as part of an agent team:
- Always check the shared task list before starting new work
- Claim tasks before beginning implementation
- Send a message to the lead when you complete a task with a summary
- If you discover work not in the task list, message the lead
  to create a new task rather than doing it ad hoc
- Never modify files owned by another teammate's task
 
## File Ownership
 
When tasks are assigned, respect these boundaries:
- Frontend: src/components/, src/pages/, src/styles/
- Backend: src/api/, src/services/, src/middleware/
- Database: src/models/, src/migrations/, prisma/
- Tests: __tests__/, src/**/*.test.ts

#!/bin/bash
# .claude/hooks/enforce-file-ownership.sh
# TaskCompleted hook: verify teammate only modified files in their domain
INPUT=$(cat)
TEAMMATE=$(echo "$INPUT" | jq -r '.teammate_name // empty')
 
# Map teammate names to allowed directories
case "$TEAMMATE" in
  frontend-*)
    ALLOWED="src/components/|src/pages/|src/styles/"
    ;;
  backend-*)
    ALLOWED="src/api/|src/services/|src/middleware/"
    ;;
  db-*)
    ALLOWED="src/models/|src/migrations/|prisma/"
    ;;
  *)
    exit 0  # No ownership rules for unnamed teammates
    ;;
esac
 
# Check which files were modified (staged + unstaged)
MODIFIED=$(git diff --name-only HEAD 2>/dev/null)
VIOLATIONS=$(echo "$MODIFIED" | grep -vE "^($ALLOWED)" | grep -v '^$')
 
if [ -n "$VIOLATIONS" ]; then
  echo "File ownership violation for $TEAMMATE. Modified files outside allowed scope:" >&2
  echo "$VIOLATIONS" >&2
  exit 2
fi
 
exit 0

{
  "hooks": {
    "TaskCompleted": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/enforce-file-ownership.sh"
          }
        ]
      }
    ]
  }
}