name: swarm-coordination description: 用于OpenCode群集工作流程的多智能体协调模式。当处理受益于并行化的复杂任务、协调多个智能体或管理任务分解时使用。不要用于简单的单智能体任务。 tags:
- 群集
- 多智能体
- 协调 tools:
- swarm_plan_prompt
- swarm_decompose
- swarm_validate_decomposition
- swarm_spawn_subtask
- swarm_complete
- swarm_status
- swarm_progress
- swarm_review
- swarm_review_feedback
- hive_create_epic
- hive_query
- swarmmail_init
- swarmmail_send
- swarmmail_inbox
- swarmmail_read_message
- swarmmail_reserve
- swarmmail_release
- swarmmail_health
- hivemind_find
- hivemind_store
- hivemind_validate
- pdf-brain_search
- skills_list references:
- references/strategies.md
- references/coordinator-patterns.md
群集协调
用于并行任务执行的多智能体编排。协调器将工作分解为子任务，生成工作智能体，监控进度并汇总结果。
强制要求：群集邮件
所有协调必须使用swarmmail_*工具。 这是不可协商的。
群集邮件是嵌入式的（无需外部服务器），提供：
- 文件预留以防止冲突
- 智能体之间的消息传递
- 与单元格绑定的基于线程的协调
何时使用群集
应使用群集当：
- 任务涉及3个以上文件
- 存在自然并行边界（前端/后端/测试）
- 需要不同专业化
- 完成时间重要
不应使用群集当：
- 任务涉及1-2个文件
- 有重度顺序依赖
- 协调开销大于收益
- 需要紧密反馈循环
启发式： 如果可以用一句话描述任务而不使用“和”，则不要使用群集。
工作智能体生存清单（强制）
每个群集工作智能体必须遵循以下9个步骤。无例外。
// 1. 初始化 - 向群集邮件注册
swarmmail_init({
project_path: "/abs/path/to/project",
task_description: "bead-id: 任务描述"
});
// 2. 查询学习 - 检查过去智能体学到了什么
hivemind_find({
query: "任务关键词 领域",
limit: 5
});
// 3. 加载技能 - 获取领域专业知识
skills_list();
skills_use({ name: "相关技能" });
// 4. 预留文件 - 声明独占所有权
swarmmail_reserve({
paths: ["src/assigned/**"],
reason: "bead-id: 我正在做什么",
ttl_seconds: 3600
});
// 5. 执行工作
// ... 实施更改 ...
// 6. 报告进度 - 每30分钟或在里程碑时
swarm_progress({
project_key: "/abs/path/to/project",
agent_name: "工作智能体名称",
bead_id: "bd-123.4",
status: "进行中",
message: "认证服务80%完成，测试剩余",
progress_percent: 80
});
// 7. 检查点 - 在风险操作前
swarm_checkpoint({
bead_id: "bd-123.4",
checkpoint_name: "重构前",
reason: "即将重构认证流程"
});
// 8. 存储学习 - 捕获你发现的内容
hivemind_store({
information: "OAuth刷新令牌需要5分钟缓冲...",
metadata: "认证, oauth, 令牌"
});
// 9. 完成 - 自动释放，记录结果
swarm_complete({
project_key: "/abs/path/to/project",
agent_name: "工作智能体名称",
bead_id: "bd-123.4",
summary: "使用JWT实现的认证服务",
files_touched: ["src/auth/service.ts", "src/auth/schema.ts"]
});
这些步骤的重要性：
| 步骤 | 目的 | 跳过的后果 |
|---|---|---|
| 1. 初始化 | 注册身份，启用协调 | 无法发送消息，预留失败 |
| 2. 查询 | 从过去错误中学习 | 重复已解决的问题，浪费时间 |
| 3. 技能 | 加载领域专业知识 | 错过已知模式，质量降低 |
| 4. 预留 | 防止编辑冲突 | 合并冲突，工作丢失 |
| 5. 工作 | 实际执行任务 | N/A |
| 6. 进度 | 让协调器知情 | 协调器假定卡住，可能重新分配 |
| 7. 检查点 | 安全回滚点 | 无法从失败中恢复 |
| 8. 存储 | 帮助未来智能体 | 相同错误重现，无学习 |
| 9. 完成 | 清理释放，学习信号 | 预留泄漏，无结果跟踪 |
如果你的子任务提示不包括这些步骤，协调器有问题。
任务清晰度检查（分解前）
分解前询问：这个任务是否足够清晰以并行化？
模糊任务信号（先提问）
| 信号 | 示例 | 问题 |
|---|---|---|
| 未提及文件 | “提高性能” | 哪里？哪些文件？ |
| 模糊动词 | “修复”、“更新”、“改善” | 具体是什么？ |
| 大未定义范围 | “重构代码库” | 哪些部分？什么模式？ |
| 缺少成功标准 | “添加认证” | OAuth？JWT？会话？什么流程？ |
| 模糊边界 | “处理错误” | 哪些错误？哪里？如何？ |
如何澄清
任务“<任务>”在分解前需要澄清。
**问题：** [关于范围/文件/方法的具体问题]
选项：
a) [选项A] - [权衡]
b) [选项B] - [权衡]
c) [选项C] - [权衡]
我推荐(a)因为[原因]。哪种方法？
规则：
- 一次一个问题（不要压倒）
- 可能时提供2-3个具体选项
- 以你的推荐和原因为先导
- 在问下一个问题前等待答案
清晰任务信号（继续分解）
| 信号 | 示例 | 为什么清晰 |
|---|---|---|
| 具体文件 | “更新src/auth/*.ts” | 范围定义 |
| 具体动词 | “从X迁移到Y” | 动作定义 |
| 定义范围 | “支付模块” | 边界清晰 |
| 可衡量结果 | “测试通过”、“无类型错误” | 成功标准 |
如有疑问，提问。 30秒的澄清胜过30分钟的错误分解。
协调器工作流程
阶段0：苏格拉底式规划（新 - 交互式）
分解前，与用户交互以澄清任务。
群集支持三种交互模式：
| 模式 | 标志 | 行为 |
|---|---|---|
| 完全苏格拉底式 | (默认) | 提问，提供推荐，协作规划 |
| 快速 | --fast |
跳过问题，使用合理默认 |
| 自动 | --auto |
最小交互，使用启发式决策 |
| 仅确认 | --confirm-only |
静默生成计划，显示CellTree，仅获取是/否 |
默认流程（完全苏格拉底式）：
// 1. 分析任务清晰度
const signals = analyzeTaskClarity(task);
if (signals.needsClarification) {
// 2. 一次问一个问题
const question = generateClarifyingQuestion(signals);
// 3. 提供2-3个具体选项
const options = generateOptions(signals);
// 4. 以推荐为先导
const recommendation = selectRecommendation(options);
// 5. 呈现给用户
console.log(`
任务“${task}”在分解前需要澄清。
**问题：** ${question}
选项：
a) ${options[0].description} - ${options[0].tradeoff}
b) ${options[1].description} - ${options[1].tradeoff}
c) ${options[2].description} - ${options[2].tradeoff}
我推荐(${recommendation.letter})因为${recommendation.reason}。哪种方法？
`);
// 6. 等待答案，如需则迭代
const answer = await getUserResponse();
// 7. 如需要，问下一个问题（一次一个）
if (needsMoreClarification(answer)) {
// 重复下一个问题
}
}
// 8. 一旦清晰，继续分解
快速模式(--fast):
- 跳过所有问题
- 基于任务类型使用合理默认
- 直接继续分解
自动模式(--auto):
- 零交互
- 所有选择基于启发式决策
- 用于批处理或CI
仅确认模式(--confirm-only):
- 静默生成计划
- 显示最终CellTree
- 仅获取是/否
苏格拉底式模式规则：
- 一次一个问题 - 不要压倒
- 提供具体选项 - 非开放式
- 以推荐为先导 - 节省用户认知负荷
- 等待答案 - 不要基于假设继续
阶段1：初始化群集邮件（首先）
// 总是先初始化 - 注册你为协调器
await swarmmail_init({
project_path: "$PWD",
task_description: "群集: <任务总结>",
});
阶段2：知识收集（强制）
分解前，查询所有知识源：
// 1. 这个项目的过去学习
hivemind_find({ query: "<任务关键词>", limit: 5 });
// 2. 过去如何解决类似任务
hivemind_find({ query: "<任务描述>", limit: 5, collection: "sessions" });
// 3. 设计模式和先前艺术
pdf_brain_search({ query: "<领域概念>", limit: 5 });
// 4. 可用的技能注入工作智能体
skills_list();
将发现综合为工作智能体的shared_context。
阶段3：分解（委托给子智能体）
⚠️ 关键：上下文保存模式
永远不要在协调器线程中进行内联规划。 分解工作（文件读取、Hivemind会话搜索、关于任务分解的推理）消耗大量上下文，并会在长群集中耗尽你的令牌预算。
总是将规划委托给
swarm-planner子智能体，并仅接收结构化的CellTree JSON结果。
❌ 反模式（上下文密集）：
// 不要这样做 - 污染主线程上下文
const plan = await swarm_plan_prompt({ task, ... });
// ... 智能体内联推理分解 ...
// ... 上下文充满文件内容、分析 ...
const validation = await swarm_validate_decomposition({ ... });
✅ 正确模式（上下文轻量）：
// 1. 创建具有完整上下文的规划珠子
await hive_create({
title: `规划: ${taskTitle}`,
type: "task",
description: `分解为子任务。上下文: ${synthesizedContext}`,
});
// 2. 委托给swarm-planner子智能体
const planningResult = await Task({
subagent_type: "swarm-planner",
description: `分解任务: ${taskTitle}`,
prompt: `
你是一个群集规划器。为此任务生成一个CellTree。
## 任务
${taskDescription}
## 综合上下文
${synthesizedContext}
## 指令
1. 使用swarm_plan_prompt(task="...", max_subtasks=5)
2. 推理分解策略
3. 生成CellTree JSON
4. 使用swarm_validate_decomposition验证
5. 仅返回验证后的CellTree JSON（无分析、无文件内容）
输出格式：仅有效的CellTree JSON。
`,
});
// 3. 解析结果（子智能体已验证）
const beadTree = JSON.parse(planningResult);
// 4. 原子性地创建史诗+子任务
await hive_create_epic({
epic_title: beadTree.epic.title,
epic_description: beadTree.epic.description,
subtasks: beadTree.subtasks,
});
为什么重要：
- 主线程上下文保持清洁 - 仅接收最终JSON，而非推理
- 子智能体上下文可丢弃 - 规划后垃圾收集
- 扩展到长群集 - 协调器可管理10+工作智能体而不耗尽
- 更快协调 - 更少上下文 = 监控工作智能体时更快响应
阶段4：文件所有权（关键规则）
⚠️ 协调器从不预留文件
这是硬规则。原因：
// ❌ 错误 - 协调器预留文件
swarmmail_reserve({
paths: ["src/auth/**"],
reason: "bd-123: 认证服务实现"
});
// 然后生成工作智能体... 谁拥有文件？
// ✅ 正确 - 工作智能体预留自己的文件
// 协调器在工作智能体提示中包含文件列表
const prompt = swarm_spawn_subtask({
bead_id: "bd-123.4",
files: ["src/auth/**"], // 文件列在这里
// ...
});
// 工作智能体接收带有文件列表的提示
// 工作智能体自己调用swarmmail_reserve
此模式原因：
| 协调器预留 | 工作智能体预留 |
|---|---|
| 所有权混淆 | 清晰所有权 |
| 谁释放？ | 工作智能体通过swarm_complete释放 |
| 协调器必须跟踪 | 工作智能体管理生命周期 |
| 死锁风险 | 干净移交 |
协调器职责：
- 规划 每个工作智能体需要的文件（无重叠）
- 包含 文件列表在工作智能体提示中
- 调解 如果工作智能体请求不同文件时的冲突
- 永不 自己调用
swarmmail_reserve
工作智能体职责：
- 读取 分配的文件从提示中
- 预留 那些文件（生存清单步骤4）
- 工作 仅在预留文件上
- 释放 通过
swarm_complete（自动）
阶段5：生成工作智能体
for (const subtask of subtasks) {
const prompt = await swarm_spawn_subtask({
bead_id: subtask.id,
epic_id: epic.id,
subtask_title: subtask.title,
subtask_description: subtask.description,
files: subtask.files,
shared_context: synthesizedContext,
});
// 通过Task工具生成
Task({
subagent_type: "swarm-worker",
prompt: prompt.worker_prompt,
});
}
阶段6：强制审查循环（不可协商）
⚠️ 每个工作智能体返回后，你必须完成此清单：
这是质量门，防止交付损坏的代码。不要跳过。
// ============================================================
// 步骤1：检查群集邮件（工作智能体可能已发送消息）
// ============================================================
const inbox = await swarmmail_inbox({ limit: 5 });
const message = await swarmmail_read_message({ message_id: N });
// ============================================================
// 步骤2：审查工作（生成带差异的审查提示）
// ============================================================
const reviewPrompt = await swarm_review({
project_key: "/abs/path/to/project",
epic_id: "epic-id",
task_id: "subtask-id",
files_touched: ["src/auth/service.ts", "src/auth/service.test.ts"]
});
// 这会生成一个审查提示，包括：
// - 史诗上下文（我们试图实现什么）
// - 子任务要求
// - 更改的Git差异
// - 依赖状态（之前是什么，之后是什么）
// ============================================================
// 步骤3：根据标准评估
// ============================================================
// 问自己：
// - 工作是否满足子任务要求？
// - 它是否服务于整体史诗目标？
// - 它是否启用下游任务？
// - 类型安全，无明显错误？
// ============================================================
// 步骤4：发送反馈（批准或请求更改）
// ============================================================
await swarm_review_feedback({
project_key: "/abs/path/to/project",
task_id: "subtask-id",
worker_id: "WorkerName",
status: "approved", // 或 "needs_changes"
summary: "LGTM - 认证服务看起来可靠",
issues: "[]" // 或 "[{file, line, issue, suggestion}]"
});
// ============================================================
// 步骤5：仅然后继续
// ============================================================
// 如果批准：
// - 关闭单元格
// - 生成下一个工作智能体（如果依赖允许）
// - 更新群集状态
//
// 如果需要更改：
// - 工作智能体获取反馈
// - 工作智能体重试（最多3次尝试）
// - 工作智能体重新提交时再次审查
//
// 如果3次失败：
// - 标记任务阻塞
// - 升级到人类（架构问题，非“更努力”）
❌ 反模式（跳过审查）：
// 工作智能体完成
swarm_complete({ ... });
// 协调器立即生成下一个工作智能体
// ⚠️ 错误 - 无质量门！
Task({ subagent_type: "swarm-worker", prompt: nextWorkerPrompt });
✅ 正确模式（在继续前审查）：
// 工作智能体完成
swarm_complete({ ... });
// 协调器首先审查
swarm_review({ ... });
// ... 评估更改 ...
swarm_review_feedback({ status: "approved" });
// 仅然后生成下一个工作智能体
Task({ subagent_type: "swarm-worker", prompt: nextWorkerPrompt });
审查工作流程（三击规则）：
- 工作智能体调用
swarm_complete→ 协调器通知 - 协调器运行
swarm_review→ 获取差异 + 史诗上下文 - 协调器根据史诗目标评估
- 如果好：
swarm_review_feedback(status="approved")→ 任务关闭 - 如果问题：
swarm_review_feedback(status="needs_changes", issues=[...])→ 工作智能体修复 - 3次拒绝后 → 任务标记阻塞（架构问题，非“更努力”）
审查标准：
- 工作是否满足子任务要求？
- 它是否服务于整体史诗目标？
- 它是否启用下游任务？
- 类型安全，无明显错误？
监控与干预：
// 检查整体群集状态
const status = await swarm_status({ epic_id, project_key });
阶段7：汇总与完成
- 验证所有子任务完成
- 运行最终验证（类型检查、测试）
- 使用总结关闭史诗
- 释放任何剩余预留
- 记录结果供学习
await swarm_complete({
project_key: "$PWD",
agent_name: "coordinator",
bead_id: epic_id,
summary: "所有子任务完成",
files_touched: [...],
});
await swarmmail_release(); // 释放任何剩余预留
await hive_sync();
上下文生存模式（关键）
长运行群集耗尽上下文窗口。这些模式让你保持存活。
模式1：开始前查询内存
问题： 重复已解决的问题浪费令牌于重新发现。
解决方案： 首先查询集体心智。
// 在群集开始时（协调器）
const learnings = await hivemind_find({
query: "认证 oauth 令牌",
limit: 5
});
// 包括在工作智能体的shared_context中
const shared_context = `
## 过去学习
${learnings.map(l => `- ${l.information}`).join('
')}
`;
// 在工作智能体开始时（生存清单步骤2）
const relevantLearnings = await hivemind_find({
query: "任务特定关键词",
limit: 3
});
原因： 5个学习（约2k令牌）防止重新发现解决方案（约20k令牌的试错）。
模式2：风险操作前检查点
问题： 失败实验消耗上下文而不产生价值。
解决方案： 在风险更改前检查点。
// 重构前
await swarm_checkpoint({
bead_id: "bd-123.4",
checkpoint_name: "重构前",
reason: "即将更改认证流程结构"
});
// 尝试风险更改...
// 如果失败，恢复并尝试不同方法
await swarm_restore_checkpoint({
bead_id: "bd-123.4",
checkpoint_name: "重构前"
});
何时检查点：
| 操作 | 风险 | 检查点？ |
|---|---|---|
| 添加新文件 | 低 | 否 |
| 跨文件重构 | 高 | 是 |
| 更改API合同 | 高 | 是 |
| 更新依赖 | 中 | 是 |
| 修复拼写错误 | 低 | 否 |
| 重写算法 | 高 | 是 |
模式3：立即存储学习
问题： 发现在上下文波动中丢失。
解决方案： 一发现就存储学习。
// ❌ 错误 - 等到结束
// ... 调试30分钟 ...
// ... 找到根本原因 ...
// ... 继续工作 ...
// ... 忘记存储学习 ...
// ✅ 正确 - 发现时立即存储
// ... 调试30分钟 ...
// ... 找到根本原因 ...
await hivemind_store({
information: "OAuth刷新令牌需要5分钟缓冲以避免竞争条件。没有缓冲，如果到期发生在检查和使用之间，令牌刷新可能在请求中失败。",
metadata: "认证, oauth, 令牌, 竞争条件"
});
// ... 安心继续工作 ...
触发： 每当你说“啊哈！”或“这就是为什么！”时存储学习。
模式4：进度报告触发自动检查点
问题： 工作智能体忘记手动检查点。
解决方案： swarm_progress 在里程碑自动检查点。
// 在25%、50%、75%报告进度
await swarm_progress({
project_key: "/abs/path",
agent_name: "工作智能体名称",
bead_id: "bd-123.4",
status: "进行中",
progress_percent: 50, // 自动检查点触发
message: "认证服务一半完成"
});
自动检查点阈值： 25%、50%、75%、100%（完成）。
模式5：将重度研究委托给子智能体
问题： 读取10+文件或深度集体心智搜索污染主线程。
解决方案： 子智能体研究，仅返回总结。
// ❌ 错误 - 协调器内联读取文件
const file1 = await read("src/a.ts"); // 500行
const file2 = await read("src/b.ts"); // 600行
const file3 = await read("src/c.ts"); // 400行
// ... 上下文现在+1500行 ...
// ✅ 正确 - 子智能体读取，总结
const summary = await Task({
subagent_type: "探索",
prompt: "读取src/a.ts, src/b.ts, src/c.ts。在3个要点中总结认证流程。"
});
// ... 上下文+3个要点，子智能体上下文丢弃 ...
何时委托：
- 读取>3个文件
- 多个集体心智搜索
- 深度文件树探索
- 分析大日志
模式6：使用总结而非原始数据
问题： 完整收件箱、文件内容、搜索结果耗尽令牌。
解决方案： 仅总结和预览。
// ❌ 错误 - 获取所有消息体
const inbox = await swarmmail_inbox({ include_bodies: true });
// ✅ 正确 - 仅头，读取特定消息
const inbox = await swarmmail_inbox({ limit: 5 }); // 仅头
if (inbox.urgent.length > 0) {
const msg = await swarmmail_read_message({ message_id: inbox.urgent[0].id });
}
// ✅ 更好 - 总结线程
const summary = await swarmmail_summarize_thread({ thread_id: "bd-123" });
令牌预算：
| 方法 | 令牌 |
|---|---|
| 10个完整消息 | ~5k |
| 10个消息头 | ~500 |
| 线程总结 | ~200 |
上下文生存清单
- [ ] 在开始时查询集体心智
- [ ] 风险操作前检查点
- [ ] 发现时立即存储学习
- [ ] 使用
swarm_progress进行自动检查点 - [ ] 将重度研究委托给子智能体
- [ ] 使用总结而非原始数据
- [ ] 监控令牌使用（保持在150k以下）
如果你超过150k令牌，你已经失败。这些模式让你存活。
分解策略
四种策略，按任务关键词自动选择：
| 策略 | 最适合 | 关键词 |
|---|---|---|
| 基于文件 | 重构、迁移 | 重构、迁移、重命名、更新所有 |
| 基于功能 | 新功能、垂直切片 | 添加、实现、构建、创建 |
| 基于风险 | 错误修复、安全 | 修复、错误、安全、关键 |
| 基于研究 | 调查、发现 | 研究、调查、探索 |
详情见references/strategies.md。
通信协议
工作智能体通过群集邮件通信，史诗ID作为线程：
// 进度更新
swarmmail_send({
to: ["coordinator"],
subject: "认证API完成",
body: "端点准备在/api/auth/*",
thread_id: epic_id,
});
// 阻塞
swarmmail_send({
to: ["coordinator"],
subject: "阻塞：需要DB模式",
body: "没有用户表无法继续",
thread_id: epic_id,
importance: "紧急",
});
协调器定期检查收件箱 - 不要让工作智能体旋转。
干预模式
| 信号 | 行动 |
|---|---|
| 工作智能体阻塞>5分钟 | 检查收件箱，提供指导 |
| 文件冲突 | 调解，重新分配文件 |
| 工作智能体提问 | 直接回答 |
| 范围蔓延 | 重定向，为额外创建新珠子 |
| 重复失败 | 接管或重新分配 |
失败恢复
不兼容输出
两个工作智能体产生冲突结果。
修复： 选择一个方法，使用约束重新运行另一个。
工作智能体漂移
工作智能体实现与要求不同的内容。
修复： 恢复，使用明确指令重新运行。
级联失败
一个阻塞影响多个子任务。
修复： 手动解除阻塞，重新分配依赖工作，接受部分完成。
反模式
| 反模式 | 症状 | 修复 |
|---|---|---|
| 分解模糊任务 | 错误子任务，浪费智能体周期 | 首先问澄清问题 |
| 超大协调器 | 协调器编辑文件 | 协调器仅编排 |
| 静默群集 | 无通信，晚期冲突 | 要求更新，检查收件箱 |
| 过度分解 | 10个子任务用于20行 | 最多2-5个子任务 |
| 不足指定 | “实现后端” | 清晰目标、文件、标准 |
| 内联规划 ⚠️ | 上下文污染，长运行中耗尽 | 将规划委托给子智能体 |
| 重度文件读取 | 协调器读取10+文件 | 子智能体读取，仅返回总结 |
| 深度集体心智钻探 | 多个hivemind_find调用内联 | 子智能体搜索，总结 |
| 手动分解 | 无验证手工艺品子任务 | 使用swarm_plan_prompt + 验证 |
共享上下文模板
## 项目上下文
- 仓库: {repo}
- 栈: {技术栈}
- 模式: {来自pdf-brain}
## 任务上下文
- 史诗: {标题}
- 目标: {成功标准}
- 约束: {范围, 时间}
## 先前艺术
- 类似任务: {来自集体心智会话}
- 学习: {来自集体心智}
## 协调
- 活跃子任务: {列表}
- 预留文件: {列表}
- 线程: {epic_id}
群集邮件快速参考
| 工具 | 目的 |
|---|---|
swarmmail_init |
初始化会话（必须先） |
swarmmail_send |
发送消息到智能体 |
swarmmail_inbox |
检查收件箱（最多5个，无体） |
swarmmail_read_message |
读取特定消息体 |
swarmmail_reserve |
预留文件供独占编辑 |
swarmmail_release |
释放文件预留 |
swarmmail_ack |
确认消息 |
swarmmail_health |
检查数据库健康 |
群集审查快速参考
| 工具 | 目的 |
|---|---|
swarm_review |
生成带史诗上下文 + 差异的审查提示 |
swarm_review_feedback |
发送批准/拒绝到工作智能体（三击规则） |
完整群集流程
// 1. 首先初始化群集邮件
swarmmail_init({ project_path: "$PWD", task_description: "..." });
// 2. 收集知识
hivemind_find({ query });
hivemind_find({ query, collection: "sessions" });
pdf_brain_search({ query });
skills_list();
// 3. 分解
swarm_plan_prompt({ task });
swarm_validate_decomposition();
hive_create_epic();
// 4. 预留文件
swarmmail_reserve({ paths, reason, ttl_seconds });
// 5. 生成工作智能体（循环）
swarm_spawn_subtask();
// 6. 监控
swarm_status();
swarmmail_inbox();
swarmmail_read_message({ message_id });
// 7. 完成
swarm_complete();
swarmmail_release();
hive_sync();
详情见references/coordinator-patterns.md。
ASCII艺术、奇想与图表（强制）
我们他妈的爱视觉风格。 每个群集会话应包括：
会话总结
完成群集时，输出一个美丽的总结，包含：
- ASCII艺术横幅（figlet风格或自定义）
- 用于结构的盒子绘制字符
- 显示构建内容的架构图
- 统计（修改文件、完成子任务等）
- 一个难忘的引用或牛说“发货”
协调期间
- 使用表格进行状态更新
- 用盒子字符绘制依赖树
- 用视觉指示器显示进度
示例
会话完成横幅：
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ 🐝 群集完成 🐝 ┃
┃ ┃
┃ 史诗: 添加认证 ┃
┃ 子任务: 4/4 ✓ ┃
┃ 文件: 12 修改 ┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
架构图：
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 输入 │────▶│ 处理 │────▶│ 输出 │
└─────────────┘ └─────────────┘ └─────────────┘
依赖树：
epic-123
├── epic-123.1 ✓ 认证服务
├── epic-123.2 ✓ 数据库模式
├── epic-123.3 ◐ API路由（进行中）
└── epic-123.4 ○ 测试（待定）
发货：
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
哞. 发货.
这不是可选的。 PR在Twitter上分享。会话总结被截图。让它们难忘。让它们美丽。让它们有趣。
盒子绘制字符: ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ━ ┃ ┏ ┓ ┗ ┛
进度指示器: ✓ ✗ ◐ ○ ● ▶ ▷ ★ ☆ 🐝