Team Architecture Optimization

Orchestrate multi-agent architecture optimization: analyze codebase -> design refactoring plan -> implement changes -> validate improvements -> review code quality.

Architecture

Skill(skill="team-arch-opt", 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       v       v
                 [analyzer][designer][refactorer][validator][reviewer]

Role Registry

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:

spawn_agent

wait_agent

close_agent

send_message

followup_task

list_agents

request_user_input

mcp__ccw-tools__team_msg

Read/Write

.workflow/.team/

Read

roles/

commands/

specs/

Read/Grep/Glob

Edit

.workflow/

Bash("ccw cli ...")

Bash

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:

  TAO

• Session path:

  .workflow/.team/TAO-<date>-<slug>/

• 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_turns: "none",
  message: `## 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.

## Task Context
task_id: <task-id>
title: <task-title>
description: <task-description>
pipeline_phase: <pipeline-phase>

## Upstream Context
<prev_context>`
})

After spawning, use

wait_agent({ timeout_ms: 1800000 })

result.timed_out

close_agent({ target: <name> })

Inner Loop roles (refactorer): Set

inner_loop: true

inner_loop: false

Model Selection Guide

Architecture optimization is reasoning-intensive. All analysis and design roles need high reasoning effort.

Override in spawn_agent when needed:

spawn_agent({
  agent_type: "team_worker",
  task_name: "<task-id>",
  fork_turns: "none",
  reasoning_effort: "high",
  message: "..."
})

User Commands

check

status

resume

continue

revise <TASK-ID> [feedback]

feedback <text>

recheck

improve [dimension]

Session Directory

.workflow/.team/TAO-<date>-<slug>/
├── session.json                    # Session metadata + status + parallel_mode
├── task-analysis.json              # Coordinator analyze output
├── artifacts/
│   ├── architecture-baseline.json  # Analyzer: pre-refactoring metrics
│   ├── architecture-report.md      # Analyzer: ranked structural issue findings
│   ├── refactoring-plan.md         # Designer: prioritized refactoring plan
│   ├── validation-results.json     # Validator: post-refactoring validation
│   ├── review-report.md            # Reviewer: code review findings
│   ├── aggregate-results.json      # Fan-out/independent: aggregated results
│   ├── branches/                   # Fan-out mode branch artifacts
│   │   └── B{NN}/
│   │       ├── refactoring-detail.md
│   │       ├── validation-results.json
│   │       └── review-report.md
│   └── pipelines/                  # Independent mode pipeline artifacts
│       └── {P}/
│           └── ...
├── explorations/
│   ├── cache-index.json            # Shared explore cache
│   └── <hash>.md
├── wisdom/
│   └── patterns.md                 # Discovered patterns and conventions
├── discussions/
│   ├── DISCUSS-REFACTOR.md
│   └── DISCUSS-REVIEW.md
└── .msg/
    ├── messages.jsonl              # Message bus log
    └── meta.json                   # Session state + cross-role state

Specs Reference

• specs/pipelines.md — Pipeline definitions, task registry, parallel modes

v4 Agent Coordination

Message Semantics

send_message

followup_task

list_agents

Agent Health Check

Use

list_agents({})

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

Named Agent Targeting

Workers are spawned with

task_name: "<task-id>"

• send_message({ target: "ANALYZE-001", message: "..." })

  -- queue analysis context without interrupting

• followup_task({ target: "REFACTOR-001", message: "..." })

  -- assign fix task after review feedback

• close_agent({ target: "VALIDATE-001" })

  -- cleanup by name

Merged Exploration Pattern

For architecture analysis, analyzer may need broad codebase exploration. Consider spawning analyzer with

fork_turns: "all"

spawn_agent({
  agent_type: "team_worker",
  task_name: "ANALYZE-001",
  fork_turns: "all",   // Share coordinator's codebase context
  reasoning_effort: "high",
  message: "..."
})

Error Handling