mirror of
https://github.com/wshobson/agents.git
synced 2026-03-18 09:37:15 +00:00
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.
This commit is contained in:
Seth Hobson
91
plugins/agent-teams/commands/team-debug.md
Normal file
91
plugins/agent-teams/commands/team-debug.md
Normal file
@@ -0,0 +1,91 @@
|
||||
---
|
||||
description: "Debug issues using competing hypotheses with parallel investigation by multiple agents"
|
||||
argument-hint: "<error-description-or-file> [--hypotheses N] [--scope files|module|project]"
|
||||
---
|
||||
|
||||
# Team Debug
|
||||
|
||||
Debug complex issues using the Analysis of Competing Hypotheses (ACH) methodology. Multiple debugger agents investigate different hypotheses in parallel, gathering evidence to confirm or falsify each one.
|
||||
|
||||
## Pre-flight Checks
|
||||
|
||||
1. Verify `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` is set
|
||||
2. Parse `$ARGUMENTS`:
|
||||
- `<error-description-or-file>`: description of the bug, error message, or path to a file exhibiting the issue
|
||||
- `--hypotheses N`: number of hypotheses to generate (default: 3)
|
||||
- `--scope`: investigation scope — `files` (specific files), `module` (module/package), `project` (entire project)
|
||||
|
||||
## Phase 1: Initial Triage
|
||||
|
||||
1. Analyze the error description or file:
|
||||
- If file path: read the file, look for obvious issues, collect error context
|
||||
- If error description: search the codebase for related code, error messages, stack traces
|
||||
2. Identify the symptom clearly: what is failing, when, and how
|
||||
3. Gather initial context: recent git changes, related tests, configuration
|
||||
|
||||
## Phase 2: Hypothesis Generation
|
||||
|
||||
Generate N hypotheses about the root cause, covering different failure mode categories:
|
||||
|
||||
1. **Logic Error** — Incorrect algorithm, wrong condition, off-by-one, missing edge case
|
||||
2. **Data Issue** — Invalid input, type mismatch, null/undefined, encoding problem
|
||||
3. **State Problem** — Race condition, stale cache, incorrect initialization, mutation bug
|
||||
4. **Integration Failure** — API contract violation, version mismatch, configuration error
|
||||
5. **Resource Issue** — Memory leak, connection exhaustion, timeout, disk space
|
||||
6. **Environment** — Missing dependency, wrong version, platform-specific behavior
|
||||
|
||||
Present hypotheses to user: "Generated {N} hypotheses. Spawning investigators..."
|
||||
|
||||
## Phase 3: Investigation
|
||||
|
||||
1. Use `Teammate` tool with `operation: "spawnTeam"`, team name: `debug-{timestamp}`
|
||||
2. For each hypothesis, use `Task` tool to spawn a teammate:
|
||||
- `name`: `investigator-{n}` (e.g., "investigator-1")
|
||||
- `subagent_type`: "agent-teams:team-debugger"
|
||||
- `prompt`: Include the hypothesis, investigation scope, and relevant context
|
||||
3. Use `TaskCreate` for each investigator's task:
|
||||
- Subject: "Investigate hypothesis: {hypothesis summary}"
|
||||
- Description: Full hypothesis statement, scope boundaries, evidence criteria
|
||||
|
||||
## Phase 4: Evidence Collection
|
||||
|
||||
1. Monitor TaskList for completion
|
||||
2. As investigators complete, collect their evidence reports
|
||||
3. Track: "{completed}/{total} investigations complete"
|
||||
|
||||
## Phase 5: Arbitration
|
||||
|
||||
1. Compare findings across all investigators:
|
||||
- Which hypotheses were confirmed (high confidence)?
|
||||
- Which were falsified (contradicting evidence)?
|
||||
- Which are inconclusive (insufficient evidence)?
|
||||
|
||||
2. Rank confirmed hypotheses by:
|
||||
- Confidence level (High > Medium > Low)
|
||||
- Strength of causal chain
|
||||
- Amount of supporting evidence
|
||||
- Absence of contradicting evidence
|
||||
|
||||
3. Present root cause analysis:
|
||||
|
||||
```
|
||||
## Debug Report: {error description}
|
||||
|
||||
### Root Cause (Most Likely)
|
||||
**Hypothesis**: {description}
|
||||
**Confidence**: {High/Medium/Low}
|
||||
**Evidence**: {summary with file:line citations}
|
||||
**Causal Chain**: {step-by-step from cause to symptom}
|
||||
|
||||
### Recommended Fix
|
||||
{specific fix with code changes}
|
||||
|
||||
### Other Hypotheses
|
||||
- {hypothesis 2}: {status} — {brief evidence summary}
|
||||
- {hypothesis 3}: {status} — {brief evidence summary}
|
||||
```
|
||||
|
||||
## Phase 6: Cleanup
|
||||
|
||||
1. Send `shutdown_request` to all investigators
|
||||
2. Call `Teammate` cleanup to remove team resources
|
||||
94
plugins/agent-teams/commands/team-delegate.md
Normal file
94
plugins/agent-teams/commands/team-delegate.md
Normal file
@@ -0,0 +1,94 @@
|
||||
---
|
||||
description: "Task delegation dashboard for managing team workload, assignments, and rebalancing"
|
||||
argument-hint: "[team-name] [--assign task-id=member-name] [--message member-name 'content'] [--rebalance]"
|
||||
---
|
||||
|
||||
# Team Delegate
|
||||
|
||||
Manage task assignments and team workload. Provides a delegation dashboard showing unassigned tasks, member workloads, blocked tasks, and rebalancing suggestions.
|
||||
|
||||
## Pre-flight Checks
|
||||
|
||||
1. Parse `$ARGUMENTS` for team name and action flags:
|
||||
- `--assign task-id=member-name`: assign a specific task to a member
|
||||
- `--message member-name 'content'`: send a message to a specific member
|
||||
- `--rebalance`: analyze and rebalance workload distribution
|
||||
|
||||
2. Read team config from `~/.claude/teams/{team-name}/config.json` using the Read tool
|
||||
3. Call `TaskList` to get current state
|
||||
|
||||
## Action: Assign Task
|
||||
|
||||
If `--assign` flag is provided:
|
||||
|
||||
1. Parse task ID and member name from `task-id=member-name` format
|
||||
2. Use `TaskUpdate` to set the task owner
|
||||
3. Use `SendMessage` with `type: "message"` to notify the member:
|
||||
- recipient: member name
|
||||
- content: "You've been assigned task #{id}: {subject}. {task description}"
|
||||
4. Confirm: "Task #{id} assigned to {member-name}"
|
||||
|
||||
## Action: Send Message
|
||||
|
||||
If `--message` flag is provided:
|
||||
|
||||
1. Parse member name and message content
|
||||
2. Use `SendMessage` with `type: "message"`:
|
||||
- recipient: member name
|
||||
- content: the message content
|
||||
3. Confirm: "Message sent to {member-name}"
|
||||
|
||||
## Action: Rebalance
|
||||
|
||||
If `--rebalance` flag is provided:
|
||||
|
||||
1. Analyze current workload distribution:
|
||||
- Count tasks per member (in_progress + pending assigned)
|
||||
- Identify members with 0 tasks (idle)
|
||||
- Identify members with 3+ tasks (overloaded)
|
||||
- Check for blocked tasks that could be unblocked
|
||||
|
||||
2. Generate rebalancing suggestions:
|
||||
|
||||
```
|
||||
## Workload Analysis
|
||||
|
||||
Member Tasks Status
|
||||
─────────────────────────────────
|
||||
implementer-1 3 overloaded
|
||||
implementer-2 1 balanced
|
||||
implementer-3 0 idle
|
||||
|
||||
Suggestions:
|
||||
1. Move task #5 from implementer-1 to implementer-3
|
||||
2. Assign unassigned task #7 to implementer-3
|
||||
```
|
||||
|
||||
3. Ask user for confirmation before executing rebalancing
|
||||
4. Execute approved moves with `TaskUpdate` and `SendMessage`
|
||||
|
||||
## Default: Delegation Dashboard
|
||||
|
||||
If no action flag is provided, display the full delegation dashboard:
|
||||
|
||||
```
|
||||
## Delegation Dashboard: {team-name}
|
||||
|
||||
### Unassigned Tasks
|
||||
#5 Review error handling patterns
|
||||
#7 Add integration tests
|
||||
|
||||
### Member Workloads
|
||||
implementer-1 3 tasks (1 in_progress, 2 pending)
|
||||
implementer-2 1 task (1 in_progress)
|
||||
implementer-3 0 tasks (idle)
|
||||
|
||||
### Blocked Tasks
|
||||
#6 Blocked by #4 (in_progress, owner: implementer-1)
|
||||
|
||||
### Suggestions
|
||||
- Assign #5 to implementer-3 (idle)
|
||||
- Assign #7 to implementer-2 (low workload)
|
||||
```
|
||||
|
||||
**Tip**: Use Shift+Tab to enter Claude Code's built-in delegate mode for ad-hoc task delegation.
|
||||
114
plugins/agent-teams/commands/team-feature.md
Normal file
114
plugins/agent-teams/commands/team-feature.md
Normal file
@@ -0,0 +1,114 @@
|
||||
---
|
||||
description: "Develop features in parallel with multiple agents using file ownership boundaries and dependency management"
|
||||
argument-hint: "<feature-description> [--team-size N] [--branch feature/name] [--plan-first]"
|
||||
---
|
||||
|
||||
# Team Feature
|
||||
|
||||
Orchestrate parallel feature development with multiple implementer agents. Decomposes features into work streams with strict file ownership, manages dependencies, and verifies integration.
|
||||
|
||||
## Pre-flight Checks
|
||||
|
||||
1. Verify `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` is set
|
||||
2. Parse `$ARGUMENTS`:
|
||||
- `<feature-description>`: description of the feature to build
|
||||
- `--team-size N`: number of implementers (default: 2)
|
||||
- `--branch`: git branch name (default: auto-generated from feature description)
|
||||
- `--plan-first`: decompose and get user approval before spawning
|
||||
|
||||
## Phase 1: Analysis
|
||||
|
||||
1. Analyze the feature description to understand scope
|
||||
2. Explore the codebase to identify:
|
||||
- Files that will need modification
|
||||
- Existing patterns and conventions to follow
|
||||
- Integration points with existing code
|
||||
- Test files that need updates
|
||||
|
||||
## Phase 2: Decomposition
|
||||
|
||||
1. Decompose the feature into work streams:
|
||||
- Each stream gets exclusive file ownership (no overlapping files)
|
||||
- Define interface contracts between streams
|
||||
- Identify dependencies between streams (blockedBy/blocks)
|
||||
- Balance workload across streams
|
||||
|
||||
2. If `--plan-first` is set:
|
||||
- Present the decomposition to the user:
|
||||
|
||||
```
|
||||
## Feature Decomposition: {feature}
|
||||
|
||||
### Stream 1: {name}
|
||||
Owner: implementer-1
|
||||
Files: {list}
|
||||
Dependencies: none
|
||||
|
||||
### Stream 2: {name}
|
||||
Owner: implementer-2
|
||||
Files: {list}
|
||||
Dependencies: blocked by Stream 1 (needs interface from {file})
|
||||
|
||||
### Integration Contract
|
||||
{shared types/interfaces}
|
||||
```
|
||||
|
||||
- Wait for user approval before proceeding
|
||||
- If user requests changes, adjust decomposition
|
||||
|
||||
## Phase 3: Team Spawn
|
||||
|
||||
1. If `--branch` specified, use Bash to create and checkout the branch:
|
||||
```
|
||||
git checkout -b {branch-name}
|
||||
```
|
||||
2. Use `Teammate` tool with `operation: "spawnTeam"`, team name: `feature-{timestamp}`
|
||||
3. Spawn a `team-lead` agent to coordinate
|
||||
4. For each work stream, use `Task` tool to spawn a `team-implementer`:
|
||||
- `name`: `implementer-{n}`
|
||||
- `subagent_type`: "agent-teams:team-implementer"
|
||||
- `prompt`: Include owned files, interface contracts, and implementation requirements
|
||||
|
||||
## Phase 4: Task Creation
|
||||
|
||||
1. Use `TaskCreate` for each work stream:
|
||||
- Subject: "{stream name}"
|
||||
- Description: Owned files, requirements, interface contracts, acceptance criteria
|
||||
2. Use `TaskUpdate` to set `blockedBy` relationships for dependent streams
|
||||
3. Assign tasks to implementers with `TaskUpdate` (set `owner`)
|
||||
|
||||
## Phase 5: Monitor and Coordinate
|
||||
|
||||
1. Monitor `TaskList` for progress
|
||||
2. As implementers complete tasks:
|
||||
- Check for integration issues
|
||||
- Unblock dependent tasks
|
||||
- Rebalance if needed
|
||||
3. Handle integration point coordination:
|
||||
- When an implementer completes an interface, notify dependent implementers
|
||||
|
||||
## Phase 6: Integration Verification
|
||||
|
||||
After all tasks complete:
|
||||
|
||||
1. Use Bash to verify the code compiles/builds: run appropriate build command
|
||||
2. Use Bash to run tests: run appropriate test command
|
||||
3. If issues found, create fix tasks and assign to appropriate implementers
|
||||
4. Report integration status to user
|
||||
|
||||
## Phase 7: Cleanup
|
||||
|
||||
1. Present feature summary:
|
||||
|
||||
```
|
||||
## Feature Complete: {feature}
|
||||
|
||||
Files modified: {count}
|
||||
Streams completed: {count}/{total}
|
||||
Tests: {pass/fail}
|
||||
|
||||
Changes are on branch: {branch-name}
|
||||
```
|
||||
|
||||
2. Send `shutdown_request` to all teammates
|
||||
3. Call `Teammate` cleanup
|
||||
78
plugins/agent-teams/commands/team-review.md
Normal file
78
plugins/agent-teams/commands/team-review.md
Normal file
@@ -0,0 +1,78 @@
|
||||
---
|
||||
description: "Launch a multi-reviewer parallel code review with specialized review dimensions"
|
||||
argument-hint: "<target> [--reviewers security,performance,architecture,testing,accessibility] [--base-branch main]"
|
||||
---
|
||||
|
||||
# Team Review
|
||||
|
||||
Orchestrate a multi-reviewer parallel code review where each reviewer focuses on a specific quality dimension. Produces a consolidated, deduplicated report organized by severity.
|
||||
|
||||
## Pre-flight Checks
|
||||
|
||||
1. Verify `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` is set
|
||||
2. Parse `$ARGUMENTS`:
|
||||
- `<target>`: file path, directory, git diff range (e.g., `main...HEAD`), or PR number (e.g., `#123`)
|
||||
- `--reviewers`: comma-separated dimensions (default: `security,performance,architecture`)
|
||||
- `--base-branch`: base branch for diff comparison (default: `main`)
|
||||
|
||||
## Phase 1: Target Resolution
|
||||
|
||||
1. Determine target type:
|
||||
- **File/Directory**: Use as-is for review scope
|
||||
- **Git diff range**: Use Bash to run `git diff {range} --name-only` to get changed files
|
||||
- **PR number**: Use Bash to run `gh pr diff {number} --name-only` to get changed files
|
||||
2. Collect the full diff content for distribution to reviewers
|
||||
3. Display review scope to user: "{N} files to review across {M} dimensions"
|
||||
|
||||
## Phase 2: Team Spawn
|
||||
|
||||
1. Use `Teammate` tool with `operation: "spawnTeam"`, team name: `review-{timestamp}`
|
||||
2. For each requested dimension, use `Task` tool to spawn a teammate:
|
||||
- `name`: `{dimension}-reviewer` (e.g., "security-reviewer")
|
||||
- `subagent_type`: "agent-teams:team-reviewer"
|
||||
- `prompt`: Include the dimension assignment, target files, and diff content
|
||||
3. Use `TaskCreate` for each reviewer's task:
|
||||
- Subject: "Review {target} for {dimension} issues"
|
||||
- Description: Include file list, diff content, and dimension-specific checklist
|
||||
|
||||
## Phase 3: Monitor and Collect
|
||||
|
||||
1. Wait for all review tasks to complete (check `TaskList` periodically)
|
||||
2. As each reviewer completes, collect their structured findings
|
||||
3. Track progress: "{completed}/{total} reviews complete"
|
||||
|
||||
## Phase 4: Consolidation
|
||||
|
||||
1. **Deduplicate**: Merge findings that reference the same file:line location
|
||||
2. **Resolve conflicts**: If reviewers disagree on severity, use the higher rating
|
||||
3. **Organize by severity**: Group findings as Critical, High, Medium, Low
|
||||
4. **Cross-reference**: Note findings that appear in multiple dimensions
|
||||
|
||||
## Phase 5: Report and Cleanup
|
||||
|
||||
1. Present consolidated report:
|
||||
|
||||
```
|
||||
## Code Review Report: {target}
|
||||
|
||||
Reviewed by: {dimensions}
|
||||
Files reviewed: {count}
|
||||
|
||||
### Critical ({count})
|
||||
[findings...]
|
||||
|
||||
### High ({count})
|
||||
[findings...]
|
||||
|
||||
### Medium ({count})
|
||||
[findings...]
|
||||
|
||||
### Low ({count})
|
||||
[findings...]
|
||||
|
||||
### Summary
|
||||
Total findings: {count} (Critical: N, High: N, Medium: N, Low: N)
|
||||
```
|
||||
|
||||
2. Send `shutdown_request` to all reviewers
|
||||
3. Call `Teammate` cleanup to remove team resources
|
||||
50
plugins/agent-teams/commands/team-shutdown.md
Normal file
50
plugins/agent-teams/commands/team-shutdown.md
Normal file
@@ -0,0 +1,50 @@
|
||||
---
|
||||
description: "Gracefully shut down an agent team, collect final results, and clean up resources"
|
||||
argument-hint: "[team-name] [--force] [--keep-tasks]"
|
||||
---
|
||||
|
||||
# Team Shutdown
|
||||
|
||||
Gracefully shut down an active agent team by sending shutdown requests to all teammates, collecting final results, and cleaning up team resources.
|
||||
|
||||
## Phase 1: Pre-Shutdown
|
||||
|
||||
1. Parse `$ARGUMENTS` for team name and flags:
|
||||
- If no team name, check for active teams (same discovery as team-status)
|
||||
- `--force`: skip waiting for graceful shutdown responses
|
||||
- `--keep-tasks`: preserve task list after cleanup
|
||||
|
||||
2. Read team config from `~/.claude/teams/{team-name}/config.json` using the Read tool
|
||||
3. Call `TaskList` to check for in-progress tasks
|
||||
|
||||
4. If there are in-progress tasks and `--force` is not set:
|
||||
- Display warning: "Warning: {N} tasks are still in progress"
|
||||
- List the in-progress tasks
|
||||
- Ask user: "Proceed with shutdown? In-progress work may be lost."
|
||||
|
||||
## Phase 2: Graceful Shutdown
|
||||
|
||||
For each teammate in the team:
|
||||
|
||||
1. Use `SendMessage` with `type: "shutdown_request"` to request graceful shutdown
|
||||
- Include content: "Team shutdown requested. Please finish current work and save state."
|
||||
2. Wait for shutdown responses
|
||||
- If teammate approves: mark as shut down
|
||||
- If teammate rejects: report to user with reason
|
||||
- If `--force`: don't wait for responses
|
||||
|
||||
## Phase 3: Cleanup
|
||||
|
||||
1. Display shutdown summary:
|
||||
|
||||
```
|
||||
Team "{team-name}" shutdown complete.
|
||||
|
||||
Members shut down: {N}/{total}
|
||||
Tasks completed: {completed}/{total}
|
||||
Tasks remaining: {remaining}
|
||||
```
|
||||
|
||||
2. Unless `--keep-tasks` is set, call `Teammate` tool with `operation: "cleanup"` to remove team and task directories
|
||||
|
||||
3. If `--keep-tasks` is set, inform user: "Task list preserved at ~/.claude/tasks/{team-name}/"
|
||||
105
plugins/agent-teams/commands/team-spawn.md
Normal file
105
plugins/agent-teams/commands/team-spawn.md
Normal file
@@ -0,0 +1,105 @@
|
||||
---
|
||||
description: "Spawn an agent team using presets (review, debug, feature, fullstack, research, security, migration) or custom composition"
|
||||
argument-hint: "<preset|custom> [--name team-name] [--members N] [--delegate]"
|
||||
---
|
||||
|
||||
# Team Spawn
|
||||
|
||||
Spawn a multi-agent team using preset configurations or custom composition. Handles team creation, teammate spawning, and initial task setup.
|
||||
|
||||
## Pre-flight Checks
|
||||
|
||||
1. Verify that `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` is set:
|
||||
- If not set, inform the user: "Agent Teams requires the experimental feature flag. Set `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in your environment."
|
||||
- Stop execution if not enabled
|
||||
|
||||
2. Parse arguments from `$ARGUMENTS`:
|
||||
- First positional arg: preset name or "custom"
|
||||
- `--name`: team name (default: auto-generated from preset)
|
||||
- `--members N`: override default member count
|
||||
- `--delegate`: enter delegation mode after spawning
|
||||
|
||||
## Phase 1: Team Configuration
|
||||
|
||||
### Preset Teams
|
||||
|
||||
If a preset is specified, use these configurations:
|
||||
|
||||
**`review`** — Multi-dimensional code review (default: 3 members)
|
||||
|
||||
- Spawn 3 `team-reviewer` agents with dimensions: security, performance, architecture
|
||||
- Team name default: `review-team`
|
||||
|
||||
**`debug`** — Competing hypotheses debugging (default: 3 members)
|
||||
|
||||
- Spawn 3 `team-debugger` agents, each assigned a different hypothesis
|
||||
- Team name default: `debug-team`
|
||||
|
||||
**`feature`** — Parallel feature development (default: 3 members)
|
||||
|
||||
- Spawn 1 `team-lead` agent + 2 `team-implementer` agents
|
||||
- Team name default: `feature-team`
|
||||
|
||||
**`fullstack`** — Full-stack development (default: 4 members)
|
||||
|
||||
- Spawn 1 `team-implementer` (frontend), 1 `team-implementer` (backend), 1 `team-implementer` (tests), 1 `team-lead`
|
||||
- Team name default: `fullstack-team`
|
||||
|
||||
**`research`** — Parallel codebase, web, and documentation research (default: 3 members)
|
||||
|
||||
- Spawn 3 `general-purpose` agents, each assigned a different research question or area
|
||||
- Agents have access to codebase search (Grep, Glob, Read), web search (WebSearch, WebFetch), and library documentation (Context7 MCP)
|
||||
- Team name default: `research-team`
|
||||
|
||||
**`security`** — Comprehensive security audit (default: 4 members)
|
||||
|
||||
- Spawn 1 `team-reviewer` (OWASP/vulnerabilities), 1 `team-reviewer` (auth/access control), 1 `team-reviewer` (dependencies/supply chain), 1 `team-reviewer` (secrets/configuration)
|
||||
- Team name default: `security-team`
|
||||
|
||||
**`migration`** — Codebase migration or large refactor (default: 4 members)
|
||||
|
||||
- Spawn 1 `team-lead` (coordination + migration plan), 2 `team-implementer` (parallel migration streams), 1 `team-reviewer` (verify migration correctness)
|
||||
- Team name default: `migration-team`
|
||||
|
||||
### Custom Composition
|
||||
|
||||
If "custom" is specified:
|
||||
|
||||
1. Use AskUserQuestion to prompt for team size (2-5 members)
|
||||
2. For each member, ask for role selection: team-lead, team-reviewer, team-debugger, team-implementer
|
||||
3. Ask for team name if not provided via `--name`
|
||||
|
||||
## Phase 2: Team Creation
|
||||
|
||||
1. Use the `Teammate` tool with `operation: "spawnTeam"` to create the team
|
||||
2. For each team member, use the `Task` tool with:
|
||||
- `team_name`: the team name
|
||||
- `name`: descriptive member name (e.g., "security-reviewer", "hypothesis-1")
|
||||
- `subagent_type`: "general-purpose" (teammates need full tool access)
|
||||
- `prompt`: Role-specific instructions referencing the appropriate agent definition
|
||||
|
||||
## Phase 3: Initial Setup
|
||||
|
||||
1. Use `TaskCreate` to create initial placeholder tasks for each teammate
|
||||
2. Display team summary:
|
||||
- Team name
|
||||
- Member names and roles
|
||||
- Display mode (tmux/iTerm2/in-process)
|
||||
3. If `--delegate` flag is set, transition to delegation mode
|
||||
|
||||
## Output
|
||||
|
||||
Display a formatted team summary:
|
||||
|
||||
```
|
||||
Team "{team-name}" spawned successfully!
|
||||
|
||||
Members:
|
||||
- {member-1-name} ({role})
|
||||
- {member-2-name} ({role})
|
||||
- {member-3-name} ({role})
|
||||
|
||||
Use /team-status to monitor progress
|
||||
Use /team-delegate to assign tasks
|
||||
Use /team-shutdown to clean up
|
||||
```
|
||||
60
plugins/agent-teams/commands/team-status.md
Normal file
60
plugins/agent-teams/commands/team-status.md
Normal file
@@ -0,0 +1,60 @@
|
||||
---
|
||||
description: "Display team members, task status, and progress for an active agent team"
|
||||
argument-hint: "[team-name] [--tasks] [--members] [--json]"
|
||||
---
|
||||
|
||||
# Team Status
|
||||
|
||||
Display the current state of an active agent team including members, tasks, and progress.
|
||||
|
||||
## Phase 1: Team Discovery
|
||||
|
||||
1. Parse `$ARGUMENTS` for team name and flags:
|
||||
- If team name provided, use it directly
|
||||
- If no team name, check `~/.claude/teams/` for active teams
|
||||
- If multiple teams exist and no name specified, list all teams and ask user to choose
|
||||
- `--tasks`: show only task details
|
||||
- `--members`: show only member details
|
||||
- `--json`: output raw JSON instead of formatted table
|
||||
|
||||
2. Read team config from `~/.claude/teams/{team-name}/config.json` using the Read tool
|
||||
3. Call `TaskList` to get current task state
|
||||
|
||||
## Phase 2: Status Display
|
||||
|
||||
### Members Table
|
||||
|
||||
Display each team member with their current state:
|
||||
|
||||
```
|
||||
Team: {team-name}
|
||||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||||
|
||||
Members:
|
||||
Name Role Status
|
||||
─────────────────────────────────────────
|
||||
security-rev team-reviewer working on task #2
|
||||
perf-rev team-reviewer idle
|
||||
arch-rev team-reviewer working on task #4
|
||||
```
|
||||
|
||||
### Tasks Table
|
||||
|
||||
Display tasks with status, assignee, and dependencies:
|
||||
|
||||
```
|
||||
Tasks:
|
||||
ID Status Owner Subject
|
||||
─────────────────────────────────────────────────
|
||||
#1 completed security-rev Review auth module
|
||||
#2 in_progress security-rev Review API endpoints
|
||||
#3 completed perf-rev Profile database queries
|
||||
#4 in_progress arch-rev Analyze module structure
|
||||
#5 pending (unassigned) Consolidate findings
|
||||
|
||||
Progress: 40% (2/5 completed)
|
||||
```
|
||||
|
||||
### JSON Output
|
||||
|
||||
If `--json` flag is set, output the raw team config and task list as JSON.
|
||||
Reference in New Issue
Block a user