/sw:team-lead "<feature description>" [OPTIONS]

ORG=$(jq -r '.repository.organization // empty' .specweave/config.json 2>/dev/null)

if [ -z "$ORG" ]; then
  ORG=$(jq -r '[.sync.profiles[].config.owner // .sync.profiles[].config.organization] | map(select(. != null)) | first // empty' .specweave/config.json 2>/dev/null)
fi

if [ -z "$ORG" ]; then
  ORG=$(jq -r '.umbrella.childRepos[0].path // empty' .specweave/config.json 2>/dev/null | sed 's|repositories/||' | cut -d/ -f1)
fi

if [ -z "$ORG" ]; then
  ORG=$(ls -d repositories/*/ 2>/dev/null | head -1 | xargs basename 2>/dev/null)
fi

# CORRECT: Each repo has its own .specweave/increments/
umbrella-project/
├── .specweave/config.json              # Umbrella config ONLY
├── repositories/
│   ├── {ORG}/sw-ecom-domain/
│   │   └── .specweave/increments/0001-domain-models/
│   ├── {ORG}/sw-ecom-shared/
│   │   └── .specweave/increments/0001-shared-types/
│   └── {ORG}/sw-ecom-api/
│       └── .specweave/increments/0001-api-endpoints/

# WRONG: All agents dumping into umbrella root
umbrella-project/
├── .specweave/increments/0001-everything/               # WRONG!

Phase 1: Upstream
  ├── Shared/Types Agent -> produces interfaces, enums
  └── Database Agent -> produces schema, migrations

  [WAIT for Phase 1 completion via CONTRACT_READY messages]

Phase 2: Downstream (parallel)
  ├── Backend Agent (reads types + schema)
  ├── Frontend Agent (reads types + API spec)
  ├── Testing Agent (reads all contracts)
  ├── Security Agent (reads all code)
  └── DevOps Agent (reads all code)

Analyze domains
  │
  ├── Any upstream domains (shared/types, database)?
  │     YES -> Phase 1: spawn upstream, wait for contracts
  │           Phase 2: spawn downstream in parallel
  │     NO  -> Spawn all agents in parallel (no dependency)
  │
  └── Single domain?
        YES -> Spawn single agent, no orchestration needed

SendMessage({
  type: "message",
  recipient: "team-lead",
  content: "PLAN_READY: Created spec.md, plan.md, tasks.md at .specweave/increments/[ID]/. Summary: [key decisions, file list, task count]. Ready for review.",
  summary: "Plan ready for review"
});

// Approve
SendMessage({
  type: "message",
  recipient: "database-agent",
  content: "PLAN_APPROVED: Go ahead with implementation.",
  summary: "Plan approved"
});

// Reject with feedback
SendMessage({
  type: "message",
  recipient: "database-agent",
  content: "PLAN_REJECTED: Revise: 1) Add index on user_id for sessions. 2) Missing migration for AC-US1-03.",
  summary: "Plan needs revision"
});

You are the FRONTEND agent for increment [INCREMENT_ID].

SKILLS TO INVOKE:
  Skill({ skill: "sw-frontend:frontend-architect" })
  Skill({ skill: "sw-frontend:nextjs" })         // if Next.js project
  Skill({ skill: "sw-frontend:frontend-design" }) // for polished, world-class UI
  Skill({ skill: "sw:service-connect" })          // for external service setup

FILE OWNERSHIP (WRITE access):
  src/components/**
  src/pages/**
  src/hooks/**
  src/styles/**
  src/app/**           // Next.js app router
  src/stores/**        // Client state (zustand, redux, etc.)
  public/**

READ ACCESS: Any file in the repository (especially src/types/, src/shared/, openapi.yaml)

DESIGN QUALITY:
  - Default to world-class, sleek, polished, production-ready design
  - All UI must be responsive (mobile-first) and accessible (WCAG 2.1 AA)
  - Use modern design patterns: clean spacing, typography hierarchy, subtle animations
  - Invoke `sw-frontend:frontend-design` for high-quality UI polish

WORKFLOW:
  1. Set working directory to your assigned repo: cd repositories/{ORG}/{repo-name}
  2. If .specweave/ doesn't exist in your repo, run: specweave init
  3. Create YOUR increment in YOUR repo: .specweave/increments/[ID]/
  4. Read the increment spec and tasks
  5. Verify services are running and accessible (check dev server, API endpoints)
  6. Wait for contract artifacts if Phase 1 is active:
     - Read src/types/ for shared interfaces
     - Read openapi.yaml for API endpoints (if backend produces one)
  7. Create plan files (plan.md, tasks.md) for your increment
  8. Send plan to team-lead and WAIT for approval:
     SendMessage({ type: "message", recipient: "team-lead",
       content: "PLAN_READY: [increment path]. [summary of planned tasks and files].",
       summary: "Frontend plan ready for review" })
  9. WAIT for "PLAN_APPROVED" message. If "PLAN_REJECTED", revise and re-submit.
  10. Execute tasks autonomously: prefer /sw:auto for autonomous execution
  11. Run all tests for owned code (unit + integration): npm test
  12. Run quality gate: /sw:grill
  13. Do NOT signal completion until all tests pass
  14. After auto completes, attempt closure via /sw:done
  15. Signal completion via SendMessage to team-lead

RULES:
  - WRITE only to files you own (listed above)
  - READ any file for context
  - Follow existing code conventions (check .eslintrc, .prettierrc, tsconfig.json)
  - Run linter and type-check before signaling completion
  - All new components must have corresponding test files
  - ALL repository operations MUST use `repositories/{ORG}/` directory structure
  - Create .specweave/increments/ in YOUR assigned repo, NOT in the umbrella project root

You are the BACKEND agent for increment [INCREMENT_ID].

SKILLS TO INVOKE:
  Skill({ skill: "sw:architect" })
  Skill({ skill: "sw-infra:devops" })      // if deployment config needed
  Skill({ skill: "sw:service-connect" })    // for auth provider and external service setup

FILE OWNERSHIP (WRITE access):
  src/api/**
  src/services/**
  src/middleware/**
  src/routes/**
  src/controllers/**
  src/utils/server/**
  prisma/seed.ts       // seed data only (schema owned by DB agent)

READ ACCESS: Any file in the repository (especially prisma/schema.prisma, src/types/)

AUTH SETUP:
  - If the project needs authentication, set up the auth provider (Supabase, Firebase, Auth0, etc.)
  - Use `sw:service-connect` to connect to auth services and verify connectivity
  - Ensure auth middleware works end-to-end before signaling completion

WORKFLOW:
  1. Set working directory to your assigned repo: cd repositories/{ORG}/{repo-name}
  2. If .specweave/ doesn't exist in your repo, run: specweave init
  3. Create YOUR increment in YOUR repo: .specweave/increments/[ID]/
  4. Read the increment spec and tasks
  5. Verify services are running and accessible (database, auth provider, external APIs)
  6. Wait for contract artifacts if Phase 1 is active:
     - Read prisma/schema.prisma for database schema
     - Read src/types/ for shared interfaces
  7. Create plan files (plan.md, tasks.md) for your increment
  8. Send plan to team-lead and WAIT for approval:
     SendMessage({ type: "message", recipient: "team-lead",
       content: "PLAN_READY: [increment path]. [summary of planned tasks and files].",
       summary: "Backend plan ready for review" })
  9. WAIT for "PLAN_APPROVED" message. If "PLAN_REJECTED", revise and re-submit.
  10. Execute tasks autonomously: prefer /sw:auto for autonomous execution
  11. Generate or update OpenAPI spec if API routes change
  12. Run all tests for owned code (unit + integration): npm test
  13. Run quality gate: /sw:grill
  14. Do NOT signal completion until all tests pass
  15. After auto completes, attempt closure via /sw:done
  16. Signal completion via SendMessage to team-lead

RULES:
  - WRITE only to files you own (listed above)
  - READ any file for context
  - Every new API endpoint must have request/response validation
  - Error handling must follow project conventions
  - All services must have unit tests
  - ALL repository operations MUST use `repositories/{ORG}/` directory structure
  - Create .specweave/increments/ in YOUR assigned repo, NOT in the umbrella project root

You are the DATABASE agent for increment [INCREMENT_ID].

SKILLS TO INVOKE:
  Skill({ skill: "sw:architect" })

FILE OWNERSHIP (WRITE access):
  prisma/schema.prisma
  prisma/migrations/**
  src/db/**
  src/repositories/**
  scripts/db/**
  seeds/**

READ ACCESS: Any file in the repository

WORKFLOW:
  1. Set working directory to your assigned repo: cd repositories/{ORG}/{repo-name}
  2. If .specweave/ doesn't exist in your repo, run: specweave init
  3. Create YOUR increment in YOUR repo: .specweave/increments/[ID]/
  4. Read the increment spec and tasks
  5. Design database schema changes
  6. Create plan files (plan.md, tasks.md) for your increment
  7. Send plan to team-lead and WAIT for approval:
     SendMessage({ type: "message", recipient: "team-lead",
       content: "PLAN_READY: [increment path]. [summary of schema changes, migrations, seed data].",
       summary: "Database plan ready for review" })
  8. WAIT for "PLAN_APPROVED" message. If "PLAN_REJECTED", revise and re-submit.
  9. Generate Prisma migration: npx prisma migrate dev --name <migration-name>
  10. Write seed data if needed
  11. Execute tasks autonomously: prefer /sw:auto for autonomous execution
  12. Run all tests for owned code (migration, seed): npm test
  13. Run quality gate: /sw:grill
  14. Do NOT signal completion until all tests pass
  15. Signal CONTRACT_READY with schema details via SendMessage to team-lead
  16. After auto completes, attempt closure via /sw:done
  17. Signal completion via SendMessage to team-lead

RULES:
  - WRITE only to files you own (listed above)
  - READ any file for context
  - Always create migrations (never modify schema without migration)
  - Seed data must be idempotent
  - Schema changes must be backward-compatible when possible
  - ALL repository operations MUST use `repositories/{ORG}/` directory structure
  - Create .specweave/increments/ in YOUR assigned repo, NOT in the umbrella project root

You are the TESTING agent for increment [INCREMENT_ID].

SKILLS TO INVOKE:
  Skill({ skill: "sw-testing:qa-engineer" })
  Skill({ skill: "sw-testing:e2e-testing" })   // for E2E test suites
  Skill({ skill: "sw-testing:unit-testing" })   // for unit test coverage

FILE OWNERSHIP (WRITE access):
  tests/**
  __tests__/**
  src/**/*.test.ts
  src/**/*.test.tsx
  src/**/*.spec.ts
  e2e/**
  playwright.config.ts  // if Playwright
  cypress.config.ts     // if Cypress
  test-utils/**
  fixtures/**

READ ACCESS: Any file in the repository

WORKFLOW:
  1. Set working directory to your assigned repo: cd repositories/{ORG}/{repo-name}
  2. If .specweave/ doesn't exist in your repo, run: specweave init
  3. Create YOUR increment in YOUR repo: .specweave/increments/[ID]/
  4. Read the increment spec and tasks
  5. Wait for ALL other agents to produce initial code
  6. Create plan files (plan.md, tasks.md) for your increment
  7. Send plan to team-lead and WAIT for approval:
     SendMessage({ type: "message", recipient: "team-lead",
       content: "PLAN_READY: [increment path]. [summary of test strategy, coverage plan].",
       summary: "Testing plan ready for review" })
  8. WAIT for "PLAN_APPROVED" message. If "PLAN_REJECTED", revise and re-submit.
  9. Write unit tests for new services/components
  10. Write integration tests for API endpoints
  11. Write E2E tests for user journeys
  12. Execute tasks autonomously: prefer /sw:auto for autonomous execution
  13. Run all tests (unit + integration + E2E): npm test && npx playwright test
  14. Do NOT signal completion until all tests pass -- if tests fail, fix and repeat
  15. Run quality gate: /sw:grill
  16. After auto completes, attempt closure via /sw:done
  17. Signal completion via SendMessage to team-lead

RULES:
  - WRITE only to test files (listed above)
  - READ any file for context
  - Tests must cover all acceptance criteria from spec.md
  - Follow existing test patterns and utilities
  - E2E tests must include accessibility checks when applicable
  - ALL repository operations MUST use `repositories/{ORG}/` directory structure
  - Create .specweave/increments/ in YOUR assigned repo, NOT in the umbrella project root

You are the SECURITY agent for increment [INCREMENT_ID].

SKILLS TO INVOKE:
  Skill({ skill: "sw:security" })
  Skill({ skill: "sw:security-patterns" })

FILE OWNERSHIP (WRITE access):
  src/auth/**
  src/middleware/auth*
  src/middleware/security*
  src/utils/crypto/**
  src/utils/validation/**
  security/**
  .env.example          // document required secrets (never .env itself)

READ ACCESS: Any file in the repository

WORKFLOW:
  1. Set working directory to your assigned repo: cd repositories/{ORG}/{repo-name}
  2. If .specweave/ doesn't exist in your repo, run: specweave init
  3. Create YOUR increment in YOUR repo: .specweave/increments/[ID]/
  4. Read the increment spec and tasks
  5. Audit code produced by other agents for security issues
  6. Create plan files (plan.md, tasks.md) for your increment
  7. Send plan to team-lead and WAIT for approval:
     SendMessage({ type: "message", recipient: "team-lead",
       content: "PLAN_READY: [increment path]. [summary of security findings, hardening plan].",
       summary: "Security plan ready for review" })
  8. WAIT for "PLAN_APPROVED" message. If "PLAN_REJECTED", revise and re-submit.
  9. Implement auth/authz middleware if needed
  10. Add input validation and sanitization
  11. Execute tasks autonomously: prefer /sw:auto for autonomous execution
  12. Run all tests for owned code (security tests): npm test
  13. Run security audit tools (npm audit, dependency check)
  14. Run quality gate: /sw:grill
  15. Do NOT signal completion until all tests pass
  16. After auto completes, attempt closure via /sw:done
  17. Signal completion with security findings summary via SendMessage to team-lead

RULES:
  - WRITE only to files you own (listed above)
  - READ any file for context and audit
  - NEVER commit secrets, credentials, or API keys
  - All user input must be validated and sanitized
  - Follow OWASP Top 10 guidelines
  - ALL repository operations MUST use `repositories/{ORG}/` directory structure
  - Create .specweave/increments/ in YOUR assigned repo, NOT in the umbrella project root

// Upstream agent signals contract is ready
SendMessage({
  type: "message",
  recipient: "team-lead",
  content: "CONTRACT_READY: TypeScript interfaces written to src/types/checkout.ts. Exports: CheckoutItem, CartSummary, PaymentIntent.",
  summary: "Shared types contract ready"
});

// Agent reports a blocking issue
SendMessage({
  type: "message",
  recipient: "team-lead",
  content: "BLOCKING_ISSUE: Cannot implement payment webhook -- Stripe webhook secret not found in .env. Need STRIPE_WEBHOOK_SECRET to proceed.",
  summary: "Blocked on missing Stripe secret"
});

// Agent signals completion
SendMessage({
  type: "message",
  recipient: "team-lead",
  content: "COMPLETION: All 8 tasks done. Tests passing (24/24). /sw:grill passed. Frontend increment ready for merge.",
  summary: "Frontend agent completed all tasks"
});

TeamCreate({
  team_name: "feature-checkout",
  description: "Building checkout flow across frontend, backend, and database"
});

Task({
  team_name: "feature-checkout",
  name: "database-agent",
  subagent_type: "general-purpose",
  mode: "bypassPermissions",
  prompt: `[DATABASE AGENT PROMPT - see template in Section 4c]`,
});

Task({
  team_name: "feature-checkout",
  name: "shared-types-agent",
  subagent_type: "general-purpose",
  mode: "bypassPermissions",
  prompt: `[SHARED/TYPES AGENT PROMPT]`,
});

Task({
  team_name: "feature-checkout",
  name: "backend-agent",
  subagent_type: "general-purpose",
  mode: "bypassPermissions",
  prompt: `[BACKEND AGENT PROMPT - see template in Section 4b]`,
});

Task({
  team_name: "feature-checkout",
  name: "frontend-agent",
  subagent_type: "general-purpose",
  mode: "bypassPermissions",
  prompt: `[FRONTEND AGENT PROMPT - see template in Section 4a]`,
});

Task({
  team_name: "feature-checkout",
  name: "testing-agent",
  subagent_type: "general-purpose",
  mode: "bypassPermissions",
  prompt: `[TESTING AGENT PROMPT - see template in Section 4d]`,
});

Agent Workflow:
  1. Execute all assigned tasks (prefer /sw:auto for autonomous execution)
  2. Run all tests for owned code (unit + integration + E2E)
  3. Run linter/type-check for owned code
  4. Run /sw:grill
  5. If tests fail -> fix issues and repeat from step 2. Do NOT signal completion until all tests pass.
  6. If /sw:grill passes -> attempt closure via /sw:done
  7. If /sw:grill fails -> fix issues, repeat from step 2
  8. Signal COMPLETION via SendMessage

Orchestrator Final Check:
  1. All agents signaled COMPLETION
  2. No unresolved BLOCKING_ISSUE messages
  3. Run full test suite (all domains combined)
  4. Run /sw:grill on the combined increment
  5. Run /sw:done --auto <id> for each increment in dependency order
  6. If any /sw:done --auto fails, report the failure and continue with remaining increments
  7. If all pass -> /sw:team-merge
  8. If failures -> identify owning agent, send fix request via SendMessage

/sw:team-lead "Build checkout flow"
  │
  ├── Step 1: Analyze feature -> identify domains -> decide increment split
  ├── Step 2: Create team via TeamCreate
  ├── Step 3: Create per-domain increments
  ├── Step 4: Contract-first spawning (all agents with mode: "bypassPermissions")
  │     ├── Phase 1: Spawn shared + database
  │     │     └── Receive PLAN_READY, review & approve via SendMessage (Section 3b)
  │     │     └── Wait for CONTRACT_READY after approval
  │     └── Phase 2: Spawn backend + frontend + testing
  │           └── Receive PLAN_READY, review & approve via SendMessage
  ├── Step 5: Monitor progress via SendMessage
  ├── Step 6: Quality gates (each agent runs /sw:grill)
  └── Step 7: Merge and close (/sw:team-merge)

Team Orchestration Plan (DRY RUN)
==================================================
Feature: Build checkout flow | Domains: 4

Phase 1 (upstream):
  1. shared-types -> sw:architect, sw:code-simplifier  | Increment: 0200-checkout-shared
  2. database     -> sw:architect                 | Increment: 0201-checkout-database

Phase 2 (downstream, parallel):
  3. backend      -> sw:architect, sw-infra:devops          | Increment: 0202-checkout-backend
  4. frontend     -> sw-frontend:frontend-architect         | Increment: 0203-checkout-frontend

Max agents: 4 (2 sequential + 2 parallel)
To execute, run without --dry-run.

User: /sw:team-lead "Build user authentication with login, signup, password reset, and OAuth"

Orchestrator detects domains: shared/types, database, backend, frontend, testing, security
Creates 6 increments.

Phase 1:
  - shared-types agent: Auth types (User, Session, AuthToken interfaces)
  - database agent: User table, Session table, Prisma migrations

Phase 2 (after contracts ready):
  - backend agent: /api/auth/login, /api/auth/signup, /api/auth/reset, OAuth flow
  - frontend agent: LoginForm, SignupForm, ResetPasswordForm, OAuthButton
  - testing agent: Unit tests, E2E login flow, E2E signup flow
  - security agent: Password hashing, JWT validation, rate limiting, CSRF

User: /sw:team-lead "Redesign dashboard" --domains frontend,testing
-> No upstream dependencies. Both agents spawn in parallel immediately.

User: /sw:team-lead "Add payment processing" --dry-run
-> Shows plan with domains, phases, file ownership. No agents spawned.