┌─────────────────────────────────────────────────────────┐
│  Skill(skill="team-ultra-analyze", args="--role=xxx")    │
└──────────────────────┬──────────────────────────────────┘
                       │ Role Router
    ┌──────────┬───────┼───────────┬───────────┐
    ↓          ↓       ↓           ↓           ↓
┌────────┐┌────────┐┌────────┐┌──────────┐┌───────────┐
│coordi- ││explorer││analyst ││discussant││synthesizer│
│nator   ││EXPLORE-││ANALYZE-││DISCUSS-* ││SYNTH-*    │
│ roles/ ││* roles/││* roles/││ roles/   ││ roles/    │
└────────┘└────────┘└────────┘└──────────┘└───────────┘

roles/
├── coordinator/
│   ├── role.md              # 编排：话题澄清、管道选择、讨论循环、结果汇报
│   └── commands/
│       ├── dispatch.md      # 任务链创建与依赖管理
│       └── monitor.md       # 进度监控 + 讨论循环
├── explorer/
│   ├── role.md              # 代码库探索
│   └── commands/
│       └── explore.md       # cli-explore-agent 并行探索
├── analyst/
│   ├── role.md              # 深度分析
│   └── commands/
│       └── analyze.md       # CLI 多视角分析
├── discussant/
│   ├── role.md              # 讨论处理 + 方向调整
│   └── commands/
│       └── deepen.md        # 深入探索
└── synthesizer/
    ├── role.md              # 综合结论
    └── commands/
        └── synthesize.md    # 跨视角整合

const args = "$ARGUMENTS"
const roleMatch = args.match(/--role[=\s]+(\w+)/)

if (!roleMatch) {
  throw new Error("Missing --role argument. Available roles: coordinator, explorer, analyst, discussant, synthesizer")
}

const role = roleMatch[1]
const teamName = args.match(/--team[=\s]+([\w-]+)/)?.[1] || "ultra-analyze"

const VALID_ROLES = {
  "coordinator":  { file: "roles/coordinator/role.md",  prefix: null },
  "explorer":     { file: "roles/explorer/role.md",     prefix: "EXPLORE" },
  "analyst":      { file: "roles/analyst/role.md",       prefix: "ANALYZE" },
  "discussant":   { file: "roles/discussant/role.md",    prefix: "DISCUSS" },
  "synthesizer":  { file: "roles/synthesizer/role.md",   prefix: "SYNTH" }
}

if (!VALID_ROLES[role]) {
  throw new Error(`Unknown role: ${role}. Available: ${Object.keys(VALID_ROLES).join(', ')}`)
}

// Read and execute role-specific logic
Read(VALID_ROLES[role].file)
// → Execute the 5-phase process defined in that file

SendMessage({ content: `## [${role}] ...`, summary: `[${role}] ...` })
mcp__ccw-tools__team_msg({ summary: `[${role}] ...` })

const TEAM_CONFIG = {
  name: "ultra-analyze",
  sessionDir: ".workflow/.team/UAN-{slug}-{date}/",
  msgDir: ".workflow/.team-msg/ultra-analyze/",
  sharedMemory: "shared-memory.json",
  analysisDimensions: ["architecture", "implementation", "performance", "security", "concept", "comparison", "decision"],
  maxDiscussionRounds: 5
}

// 各角色读取共享记忆
const memoryPath = `${sessionFolder}/shared-memory.json`
let sharedMemory = {}
try { sharedMemory = JSON.parse(Read(memoryPath)) } catch {}

// 各角色写入自己负责的字段：
// explorer    → sharedMemory.explorations
// analyst     → sharedMemory.analyses
// discussant  → sharedMemory.discussions
// synthesizer → sharedMemory.synthesis
// coordinator → sharedMemory.decision_trail + current_understanding
Write(memoryPath, JSON.stringify(sharedMemory, null, 2))

mcp__ccw-tools__team_msg({
  operation: "log",
  team: teamName,
  from: role,
  to: "coordinator",
  type: "<type>",
  summary: `[${role}] <summary>`,
  ref: "<file_path>"
})

Bash(`ccw team log --team "${teamName}" --from "${role}" --to "coordinator" --type "<type>" --summary "<摘要>" --json`)

const tasks = TaskList()
const myTasks = tasks.filter(t =>
  t.subject.startsWith(`${VALID_ROLES[role].prefix}-`) &&
  t.owner === role &&
  t.status === 'pending' &&
  t.blockedBy.length === 0
)
if (myTasks.length === 0) return
const task = TaskGet({ taskId: myTasks[0].id })
TaskUpdate({ taskId: task.id, status: 'in_progress' })

// Phase 2-4: Role-specific
// Phase 5: Report + Loop
mcp__ccw-tools__team_msg({ operation: "log", team: teamName, from: role, to: "coordinator", type: "...", summary: `[${role}] ...` })
SendMessage({ type: "message", recipient: "coordinator", content: `## [${role}] ...`, summary: `[${role}] ...` })
TaskUpdate({ taskId: task.id, status: 'completed' })

Quick:    EXPLORE-001 → ANALYZE-001 → SYNTH-001
Standard: [EXPLORE-001..N](parallel) → [ANALYZE-001..N](parallel) → DISCUSS-001 → SYNTH-001
Deep:     [EXPLORE-001..N] → [ANALYZE-001..N] → DISCUSS-001 → ANALYZE-fix → DISCUSS-002 → ... → SYNTH-001

function detectPipelineMode(args, taskDescription) {
  const modeMatch = args.match(/--mode[=\s]+(quick|standard|deep)/)
  if (modeMatch) return modeMatch[1]
  // 自动检测
  if (/快速|quick|overview|概览/.test(taskDescription)) return 'quick'
  if (/深入|deep|thorough|详细|全面/.test(taskDescription)) return 'deep'
  return 'standard'
}

coordinator(AskUser) → DISCUSS-N(deepen) → [optional ANALYZE-fix] → coordinator(AskUser) → ... → SYNTH

.workflow/.team/UAN-{slug}-{YYYY-MM-DD}/
├── shared-memory.json          # 探索/分析/讨论/综合 共享记忆
├── discussion.md               # ⭐ 理解演进 & 讨论时间线
├── explorations/               # Explorer output
│   ├── exploration-001.json
│   └── exploration-002.json
├── analyses/                   # Analyst output
│   ├── analysis-001.json
│   └── analysis-002.json
├── discussions/                # Discussant output
│   └── discussion-round-001.json
└── conclusions.json            # Synthesizer output

TeamCreate({ team_name: teamName })

// Explorer
Task({
  subagent_type: "general-purpose",
  team_name: teamName,
  name: "explorer",
  prompt: `你是 team "${teamName}" 的 EXPLORER。

当你收到 EXPLORE-* 任务时，调用 Skill(skill="team-ultra-analyze", args="--role=explorer") 执行。

当前需求: ${taskDescription}
约束: ${constraints}

undefined