brewcode:teams

<instructions>

Teams

Manage dynamic teams of domain-specific agents with tracking framework.

Arguments: $ARGUMENTS

Phase 1: Parse Arguments

EXECUTE using Bash tool:

bash "${CLAUDE_SKILL_DIR}/scripts/detect-mode.sh" "$ARGUMENTS" && echo "OK" || echo "FAILED"

Output: MODE:, TEAM_NAME:, PROMPT: (optional). Store all three.

Universal Prelude (EVERY mode)

Step 0: Init + Validate + Confirm

1. Output detection result:

`` Mode: {MODE}, Team: {TEAM_NAME} ``

1. Load environment:

| Action | Command / Path | |--------|----------------| | Read agent template | ${CLAUDE_SKILL_DIR}/references/agent-template.md | | Read framework templates | ${CLAUDE_SKILL_DIR}/references/framework-files.md | | Check team dir | .claude/teams/{TEAM_NAME}/ -- exists? | | Check existing agents | .claude/agents/ -- list all | | If team.md exists | Read, show current roster | | If trace.jsonl exists | Show entry counts via trace-ops.sh read |

1. If team exists -- verify:

EXECUTE using Bash tool: ``bash bash "${CLAUDE_SKILL_DIR}/scripts/verify-team.sh" "TEAM_NAME_HERE" && echo "PASS" || echo "FAIL" ``

1. Formulate action plan for current mode.

1. Confirm via AskUserQuestion:

``` AskUserQuestion: question: "Here's my plan: {plan}. Continue?" options:

• "Yes, continue"
• "No, I want changes"
• "Cancel"

```

• "changes" -> AskUserQuestion for details, revise plan
• "Cancel" -> STOP

Mode: CREATE (9 phases)

C1: Project Analysis

Spawn 3-5 Explore agents in ONE message via Task tool:

| # | Agent | Focus | |---|-------|-------| | 1 | Explore | Code structure: modules, packages, domains, architectural layers | | 2 | Explore | Existing agents (.claude/agents/, brewcode/agents/, ~/.claude/agents/) + Claude Code infrastructure | | 3 | Explore | Tech stack: build files, frameworks, dependencies, languages | | 4 | Explore | CI/CD, testing, deploy, infrastructure | | 5 | Explore (optional) | Domain boundaries: business logic, API, data layer, UI |

All via Task(subagent_type="Explore"). Consolidate results into a single analysis document.

C2: Team Proposal (interactive)

Based on analysis + PROMPT (if provided), propose 3 variants:

AskUserQuestion:
  question: |
    Project analysis complete. {if PROMPT: "Noted: {PROMPT}"}
    
    **Minimal (5 agents):**
    | Agent | Domain | Mission |
    | ... | ... | ... |
    
    **Balanced (10-12 agents) -- Recommended:**
    | Agent | Domain | Mission |
    | ... | ... | ... |
    
    **Maximum (15-20 agents):**
    | Agent | Domain | Mission |
    | ... | ... | ... |
  options:
    - "Minimal (5)"
    - "Balanced (recommended)"
    - "Maximum (15-20)"
    - "Custom -- I'll specify"

If "Custom" -- second AskUserQuestion for free input. Final confirmation of agent list via AskUserQuestion before proceeding.

C2.5: Model Selection (AskUserQuestion)

Before creating agents, confirm model for the team:

AskUserQuestion:
  question: |
    Default model for domain agents: **Opus** (most reliable).
    
    | Model | Best for | Cost |
    | opus | Complex domains, architecture, critical logic | High |
    | sonnet | Standard domains, CRUD, testing, utilities | Medium |
    | haiku | Simple utility agents, formatting, validation | Low |
    
    Choose default model for this team's agents:
  options:
    - "Opus (recommended)"
    - "Sonnet"
    - "Haiku"
    - "Mixed -- I'll choose per agent"

If "Mixed" -- in C3, ask model per agent via AskUserQuestion. Store as DEFAULT_MODEL (default: opus).

C3: Agent Creation (agent-creator x N)

1. Read ${CLAUDE_SKILL_DIR}/references/agent-template.md -- unified template
2. For each agent -- spawn Task(subagent_type="brewcode:agent-creator"):

| Parameter | Value | |-----------|-------| | Placement | .claude/agents/ | | Model | DEFAULT_MODEL (or per-agent if "Mixed") | | Context | Template, mission, domain, character, project analysis, colleague list |

1. Batch 3-4 agents in parallel per message.
2. After each batch -- optimize created files:

`` Skill(skill="brewtools:text-optimize", args="-l .claude/agents/{agent-name}.md") ``

C4: Framework Setup + Verification

1. Create team directory:

EXECUTE using Bash tool: ``bash mkdir -p ".claude/teams/TEAM_NAME_HERE" && echo "OK" || echo "FAILED" ``

1. Write files from templates in ${CLAUDE_SKILL_DIR}/references/framework-files.md:
2. team.md -- fill with real agent data
3. touch trace.jsonl -- empty file for trace data

1. Verify:

EXECUTE using Bash tool: ``bash bash "${CLAUDE_SKILL_DIR}/scripts/verify-team.sh" "TEAM_NAME_HERE" && echo "PASS" || echo "FAIL" ``

> STOP if FAIL -- fix missing files before continuing.

1. AskUserQuestion: final report + suggest running /brewcode:teams status {TEAM_NAME}

C5: Quorum Review

Spawn 3 reviewer agents in ONE message via Task tool. Reviewers are domain experts matching the team's scope.

| # | Agent | Focus | |---|-------|-------| | 1 | brewcode:reviewer | Instruction quality: clarity, imperative form, completeness, word budget | | 2 | brewcode:reviewer | Domain accuracy: correct scope, tool selection, model fit, description triggers | | 3 | brewcode:reviewer | Architecture: consistency across agents, no domain overlaps, proper Task Acceptance Protocol |

Each reviewer reads ALL created agent files in .claude/agents/ and outputs structured findings:

FILE: .claude/agents/{name}.md
SEVERITY: critical/important/minor
ISSUE: description
FIX: suggested fix

C6: Consensus Filter

Compare findings from all 3 reviewers. Apply quorum threshold: 2/3 agreement = confirmed.

| Match criteria | Rule | |----------------|------| | Same file | Exact match | | Same area | +/- 5 lines or same section | | Same category | instruction/domain/architecture/trigger |

| Outcome | Action | |---------|--------| | 2/3+ confirm | Mark as confirmed, keep severity from highest reporter | | 1/3 only | Log as unconfirmed, skip | | Minor severity (all reporters) | Log but skip fix |

Output: confirmed findings list with severity (critical > important > minor).

C7: Verification

Spawn 1 verification agent via Task tool:

Task(subagent_type="brewcode:reviewer", prompt="
  Verify these findings against actual agent files. For each:
  1. Read the agent file
  2. Check if the issue actually exists
  3. Mark: VERIFIED or FALSE_POSITIVE
  {confirmed_findings}
")

Filter out false positives. Final list = verified critical + important issues.

C8: Fix

For each verified critical/important issue -- spawn agent-creator to fix:

Task(subagent_type="brewcode:agent-creator", prompt="
  Fix this issue in {agent_file}:
  ISSUE: {description}
  FIX: {suggested_fix}
  SEVERITY: {severity}
  Read the file, apply the fix, validate.
")

Batch fixes: up to 3 parallel per message. Minor issues are skipped.

C9: Re-verify

Spawn verification agent to check all fixes:

Task(subagent_type="brewcode:reviewer", prompt="
  Re-verify these fixes. For each:
  1. Read the fixed agent file
  2. Check the original issue is resolved
  3. Check no regression introduced
  Mark: FIXED or REGRESSION
  {fixes_applied}
")

| Outcome | Action | |---------|--------| | All FIXED | Pipeline complete, proceed to Epilogue | | REGRESSION found | Return to C8 for that file (max 2 cycles) | | Still failing after 2 cycles | Log as unresolved, proceed to Epilogue |

To skip the review pipeline: add --skip-review to create arguments.

To run review on existing team: /brewcode:teams update {TEAM_NAME} --review

Mode: STATUS (read-only)

No modifications. Read + report only.

Step 1: Read .claude/teams/{TEAM_NAME}/team.md Step 2: Read trace data:

EXECUTE using Bash tool:

bash "${CLAUDE_SKI