team-review

Unified team skill for code review. 3-role pipeline: scanner, reviewer, fixer. Triggers on team-review.

Quality

60%

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Passed

No known issues

Optimize this skill with Tessl

npx tessl skill review --optimize ./.codex/skills/team-review/SKILL.md

Team Review

Orchestrate multi-agent code review: scanner -> reviewer -> fixer. Toolchain + LLM scan, deep analysis with root cause enrichment, and automated fix with rollback-on-failure.

Architecture

Skill(skill="team-review", args="task description")
                    |
         SKILL.md (this file) = Router
                    |
     +--------------+--------------+
     |                             |
  no --role flag              --role <name>
     |                             |
  Coordinator                  Worker
  roles/coordinator/role.md    roles/<name>/role.md
     |
     +-- analyze -> dispatch -> spawn workers -> STOP
                                    |
                    +-------+-------+-------+
                    v       v       v
                [scan]  [review]  [fix]
                team-worker agents, each loads roles/<role>/role.md

Role Registry

Role	Path	Prefix	Inner Loop
coordinator	roles/coordinator/role.md	—	—
scanner	roles/scanner/role.md	SCAN-*	false
reviewer	roles/reviewer/role.md	REV-*	false
fixer	roles/fixer/role.md	FIX-*	true

Role Router

Parse $ARGUMENTS:

Has --role <name> -> Read roles/<name>/role.md, execute Phase 2-4
No --role -> roles/coordinator/role.md, execute entry router

Delegation Lock

Coordinator is a PURE ORCHESTRATOR. It coordinates, it does NOT do.

Before calling ANY tool, apply this check:

Tool Call	Verdict	Reason
`spawn_agent`, `wait_agent`, `close_agent`, `send_message`, `assign_task`	ALLOWED	Orchestration
`list_agents`	ALLOWED	Agent health check
`request_user_input`	ALLOWED	User interaction
`mcp__ccw-tools__team_msg`	ALLOWED	Message bus
`Read/Write` on `.workflow/.team/` files	ALLOWED	Session state
`Read` on `roles/`, `commands/`, `specs/`	ALLOWED	Loading own instructions
`Read/Grep/Glob` on project source code	BLOCKED	Delegate to worker
`Edit` on any file outside `.workflow/`	BLOCKED	Delegate to worker
`Bash("ccw cli ...")`	BLOCKED	Only workers call CLI
`Bash` running build/test/lint commands	BLOCKED	Delegate to worker

If a tool call is BLOCKED: STOP. Create a task, spawn a worker.

No exceptions for "simple" tasks. Even a single-file read-and-report MUST go through spawn_agent.

Shared Constants

Session prefix: RV
Session path: .workflow/.team/RV-<slug>-<date>/
Team name: review
CLI tools: ccw cli --mode analysis (read-only), ccw cli --mode write (modifications)
Message bus: mcp__ccw-tools__team_msg(session_id=<session-id>, ...)

Worker Spawn Template

Coordinator spawns workers using this template:

spawn_agent({
  agent_type: "team_worker",
  task_name: "<task-id>",
  fork_context: false,
  items: [
    { type: "text", text: `## Role Assignment
role: <role>
role_spec: <skill_root>/roles/<role>/role.md
session: <session-folder>
session_id: <session-id>
requirement: <task-description>
inner_loop: <true|false>

Read role_spec file (<skill_root>/roles/<role>/role.md) to load Phase 2-4 domain instructions.` },

    { type: "text", text: `## Task Context
task_id: <task-id>
title: <task-title>
description: <task-description>
pipeline_phase: <pipeline-phase>` },

    { type: "text", text: `## Upstream Context
<prev_context>` }
  ]
})

After spawning, use wait_agent({ targets: [...], timeout_ms: 900000 }) to collect results, then close_agent({ target }) each worker.

Model Selection Guide

Role	model	reasoning_effort	Rationale
Scanner (SCAN-*)	(default)	medium	Toolchain scanning + pattern matching, less reasoning
Reviewer (REV-*)	(default)	high	Deep root cause analysis requires full reasoning
Fixer (FIX-*)	(default)	high	Code modification needs precision

Override model/reasoning_effort in spawn_agent when cost optimization is needed:

spawn_agent({
  agent_type: "team_worker",
  task_name: "<task-id>",
  fork_context: false,
  model: "<model-override>",
  reasoning_effort: "<effort-level>",
  items: [...]
})

User Commands

Command	Action
`check` / `status`	View pipeline status graph
`resume` / `continue`	Advance to next step
`--full`	Enable scan + review + fix pipeline
`--fix`	Fix-only mode (skip scan/review)
`-q` / `--quick`	Quick scan only
`--dimensions=sec,cor,prf,mnt`	Custom dimensions
`-y` / `--yes`	Skip confirmations

v4 Agent Coordination

Message Semantics

Intent	API	Example
Send scan findings to running reviewer	`send_message`	Queue scan results to REV-* as supplementary context
Not used in this skill	`assign_task`	No resident agents -- sequential 3-stage pipeline
Check running agents	`list_agents`	Verify agent health during resume

Pipeline Pattern

This is a sequential 3-stage pipeline (scan -> review -> fix). No parallel phases. Each stage completes before the next starts. The coordinator may skip stages (0 findings -> skip review+fix; user declines fix -> skip fix).

Agent Health Check

Use list_agents({}) in handleResume and handleComplete:

// Reconcile session state with actual running agents
const running = list_agents({})
// Compare with tasks.json active_agents
// Reset orphaned tasks (in_progress but agent gone) to pending

Named Agent Targeting

Workers are spawned with task_name: "<task-id>" enabling direct addressing:

send_message({ target: "REV-001", items: [...] }) -- queue scan findings to running reviewer
close_agent({ target: "SCAN-001" }) -- cleanup by name after completion

Completion Action

When pipeline completes, coordinator presents:

request_user_input({
  questions: [{
    question: "Review pipeline complete. What would you like to do?",
    header: "Completion",
    multiSelect: false,
    options: [
      { label: "Archive & Clean (Recommended)", description: "Archive session, clean up" },
      { label: "Keep Active", description: "Keep session for follow-up work" },
      { label: "Export Results", description: "Export deliverables to target directory" }
    ]
  }]
})

Session Directory

.workflow/.team/RV-<slug>-<date>/
├── .msg/messages.jsonl     # Team message bus
├── .msg/meta.json          # Session state + cross-role state
├── wisdom/                 # Cross-task knowledge
├── scan/                   # Scanner output
├── review/                 # Reviewer output
└── fix/                    # Fixer output

Specs Reference

specs/pipelines.md — Pipeline definitions and task registry
specs/dimensions.md — Review dimension definitions (SEC/COR/PRF/MNT)
specs/finding-schema.json — Finding data schema
specs/team-config.json — Team configuration

Error Handling

Scenario	Resolution
Unknown --role value	Error with available role list
Role not found	Error with expected path (roles/<name>/role.md)
CLI tool fails	Worker fallback to direct implementation
Scanner finds 0 findings	Report clean, skip review + fix
User declines fix	Delete FIX tasks, complete with review-only results
Fast-advance conflict	Coordinator reconciles on next callback
Completion action fails	Default to Keep Active

Repository: catlog22/Claude-Code-Workflow
Commit: 0f8e801

Last updated: 4 days ago
Created: 4 days ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.