24d - Agent 间通信

┌─────────────┐     ┌──────────────────┐     ┌─────────────┐
│  Agent A    │────▶│  shared/         │◀────│  Agent B    │
│  (研究员)    │     │  MEMORY.md       │     │  (写作者)    │
│             │────▶│  FINDINGS.md     │◀────│             │
└─────────────┘     │  STATUS.md       │     └─────────────┘
                    └──────────────────┘
                           ▲
                    ┌──────┴──────┐
                    │  Agent C    │
                    │  (审核员)    │
                    └─────────────┘

# 创建共享目录
mkdir -p /path/to/openclaw/shared-memory
 
# 在 Agent A 的工作空间中创建符号链接
ln -s /path/to/openclaw/shared-memory/SHARED_MEMORY.md \
  /path/to/openclaw/agents/agent-a/SHARED_MEMORY.md
 
# 在 Agent B 的工作空间中创建同样的符号链接
ln -s /path/to/openclaw/shared-memory/SHARED_MEMORY.md \
  /path/to/openclaw/agents/agent-b/SHARED_MEMORY.md

# agents.yaml 中配置 MemOS 插件
agents:
  research-agent:
    plugins:
      - name: memos-memory
        config:
          pool: "team-alpha"        # 共享内存池名称
          access: read-write
          namespace: research       # Agent 专属命名空间
 
  writer-agent:
    plugins:
      - name: memos-memory
        config:
          pool: "team-alpha"        # 同一内存池
          access: read-write
          namespace: writing

<!-- Agent A 的 SOUL.md -->
## 协作规则
 
- 你是研究团队的一员
- 将研究发现写入 `../shared/FINDINGS.md`
- 在开始新任务前，先读取 `../shared/STATUS.md` 了解团队进度
- 完成任务后更新 `../shared/STATUS.md` 中你的状态

┌──────────┐    内部消息     ┌──────────┐    路由到队列    ┌──────────┐
│ Agent A  │───────────────▶│ Gateway  │───────────────▶│ Agent B  │
│ (研究员)  │               │ (路由器)  │               │ (写作者)  │
└──────────┘               └──────────┘               └──────────┘
                                │
                                │ 路由到队列
                                ▼
                           ┌──────────┐
                           │ Agent C  │
                           │ (审核员)  │
                           └──────────┘

┌─────────────────────────────────────────────────┐
│                  父 Agent（编排者）                │
│                                                   │
│  "请分别研究这三个竞品"                             │
│       │            │            │                  │
│  spawn ▼       spawn ▼      spawn ▼               │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐           │
│ │ 子Agent1 │ │ 子Agent2 │ │ 子Agent3 │           │
│ │ 竞品A研究 │ │ 竞品B研究 │ │ 竞品C研究 │           │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘           │
│      │            │            │                  │
│      └────────────┼────────────┘                  │
│                   ▼                               │
│           结果汇总到父 Agent                        │
└─────────────────────────────────────────────────┘

# 查看所有运行中的子 Agent
/subagents list
 
# 查看特定子 Agent 的详细信息
/subagents info <subagent-id>
 
# 向运行中的子 Agent 发送补充指令
/subagents send <subagent-id> "请重点关注定价策略"
 
# 查看子 Agent 的完整对话日志
/subagents log <subagent-id>
 
# 终止不再需要的子 Agent
/subagents stop <subagent-id>

# agents.yaml - 权限隔离配置
agents:
  orchestrator:
    model: claude-sonnet-4-20250514    # 高能力模型用于编排
    tools:
      - sessions_spawn
      - sessions_send
    auth_profiles:
      - github-admin
      - slack-admin
 
  research-worker:
    model: claude-haiku               # 低成本模型用于执行
    tools:
      - web_search
      - file_read
    auth_profiles:
      - github-readonly               # 只读权限
    # 注意：worker 没有 sessions_spawn 权限，不能创建子 Agent

┌─────────────────────────────────────────────────────────┐
│                    Gateway 事件总线                       │
│                                                          │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────┐  │
│  │ 用户消息  │  │ 心跳/Cron │  │ Webhook  │  │ Hook   │  │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └───┬────┘  │
│       │             │             │             │        │
│       └─────────────┼─────────────┼─────────────┘        │
│                     ▼                                    │
│              ┌──────────────┐                            │
│              │   事件队列    │                            │
│              └──────┬───────┘                            │
│                     │                                    │
│          ┌──────────┼──────────┐                         │
│          ▼          ▼          ▼                         │
│    ┌──────────┐┌──────────┐┌──────────┐                 │
│    │ Agent A  ││ Agent B  ││ Agent C  │                 │
│    └──────────┘└──────────┘└──────────┘                 │
└─────────────────────────────────────────────────────────┘

# Agent A 的 hooks 配置 - 发布事件
hooks:
  on_task_complete:
    trigger: "agent_action_end"
    action: |
      将任务结果写入 ../shared/EVENTS.md，格式：
      ## [时间戳] research-complete
      - agent: research-agent
      - topic: {{topic}}
      - status: done
      - output: ../shared/findings/{{topic}}.md
 
# Agent B 的 hooks 配置 - 订阅事件
hooks:
  on_startup:
    trigger: "gateway_start"
    action: "读取 ../shared/EVENTS.md，检查是否有未处理的 research-complete 事件"
 
  on_heartbeat:
    trigger: "heartbeat"
    action: "检查 ../shared/EVENTS.md 是否有新的 research-complete 事件，如有则开始写作任务"

// 外部系统通过 Webhook 触发 Agent
// POST /webhook/agent-b
{
  "event": "research_complete",
  "source": "agent-a",
  "payload": {
    "topic": "竞品分析",
    "findings_path": "/shared/findings/competitor-analysis.md"
  }
}

时间线 ──────────────────────────────────────────────────▶

[Cron 触发]          [Hook 触发]           [Hook 触发]
    │                    │                     │
    ▼                    ▼                     ▼
┌──────────┐      ┌──────────┐          ┌──────────┐
│ 调研Agent │─────▶│ 写作Agent │─────────▶│ 审核Agent │
│           │ 写入  │           │ 写入     │           │
│ 每日9am   │ 共享  │ 检测到新   │ 共享     │ 检测到新   │
│ 执行调研   │ 内存  │ 调研结果   │ 内存     │ 草稿完成   │
└──────────┘      └──────────┘          └──────────┘
     │                  │                     │
     ▼                  ▼                     ▼
 FINDINGS.md        DRAFT.md            REVIEW.md

                    ┌──────────────┐
                    │   主持人Agent  │
                    │  (Moderator)  │
                    └──────┬───────┘
                           │
              ┌────────────┼────────────┐
              │            │            │
              ▼            ▼            ▼
        ┌──────────┐ ┌──────────┐ ┌──────────┐
        │ 安全专家  │ │ 架构师   │ │ 产品经理  │
        │  Agent   │ │  Agent   │ │  Agent   │
        └────┬─────┘ └────┬─────┘ └────┬─────┘
             │            │            │
             └────────────┼────────────┘
                          ▼
                   ┌──────────────┐
                   │  共识决策输出  │
                   └──────────────┘

# agents.yaml
agents:
  moderator:
    model: claude-sonnet-4-20250514
    soul: |
      你是圆桌讨论的主持人。你的职责是：
      1. 将议题分发给所有专家
      2. 收集每位专家的独立意见
      3. 识别分歧点并引导深入讨论
      4. 在 3 轮讨论后发起投票
      5. 综合所有意见形成最终决策
    tools:
      - sessions_spawn
      - sessions_send
      - file_write
 
  security-expert:
    model: claude-sonnet-4-20250514
    soul: |
      你是一位资深安全工程师。在圆桌讨论中，你从安全角度评估方案：
      - 攻击面分析
      - 数据泄露风险
      - 合规性要求
      - 安全最佳实践
      始终优先考虑安全性，即使这意味着增加复杂度。
 
  architect:
    model: claude-sonnet-4-20250514
    soul: |
      你是一位系统架构师。在圆桌讨论中，你从架构角度评估方案：
      - 可扩展性
      - 性能影响
      - 技术债务
      - 维护成本
      追求简洁优雅的设计，避免过度工程。
 
  product-manager:
    model: claude-sonnet-4-20250514
    soul: |
      你是一位产品经理。在圆桌讨论中，你从产品角度评估方案：
      - 用户体验影响
      - 上线时间
      - 商业价值
      - 竞品对比
      始终以用户价值为导向。

<!-- skills/roundtable-discussion.md -->
# 圆桌讨论 Skill
 
## 触发条件
当用户说"发起圆桌讨论"或"让团队讨论一下"时激活。
 
## 执行流程
 
### 第一轮：独立分析
1. 将议题同时发送给所有专家 Agent（使用 sessions_spawn 并行）
2. 每位专家独立分析，输出结构化意见：
   - 立场（支持/反对/有条件支持）
   - 关键论点（3-5 条）
   - 风险评估（高/中/低）
   - 建议行动
 
### 第二轮：交叉审查
3. 收集所有专家意见后，将汇总发送给每位专家
4. 每位专家针对其他人的意见提出质疑或补充
 
### 第三轮：共识形成
5. 收集第二轮反馈，识别共识点和分歧点
6. 对分歧点发起加权投票
7. 生成最终决策报告
 
## 输出格式
将讨论结果写入 `ROUNDTABLE_RESULT.md`，包含：
- 议题摘要
- 各专家立场汇总
- 共识点
- 分歧点及投票结果
- 最终建议
- 风险提示

专家A: 方案1 ✓    专家B: 方案2 ✓    专家C: 方案1 ✓
                    │
                    ▼
            最终决策: 方案1（2:1）

# 伪代码：置信度加权投票
votes = {
    "security_expert": {"choice": "方案A", "confidence": 0.9},
    "architect":       {"choice": "方案B", "confidence": 0.6},
    "product_manager": {"choice": "方案A", "confidence": 0.8},
}
 
# 加权计算
scores = {}
for agent, vote in votes.items():
    choice = vote["choice"]
    scores[choice] = scores.get(choice, 0) + vote["confidence"]
 
# 结果: 方案A = 1.7, 方案B = 0.6 → 选择方案A

第1轮: A=方案1, B=方案2, C=方案2  (分歧度: 高)
第2轮: A=方案2(修改版), B=方案2, C=方案2(修改版)  (分歧度: 低)
第3轮: 所有人同意方案2(修改版)  (达成共识)

你需要 Agent 间通信吗？
│
├─ 只需要共享数据/知识 ──────────▶ 共享内存（MEMORY.md）
│
├─ 需要任务委派和结果回传
│   │
│   ├─ 任务可并行 ──────────────▶ sessions_spawn（父子模式）
│   │
│   └─ 任务需顺序执行 ──────────▶ sessions_send（直接消息）
│
├─ 需要松耦合的工作流触发
│   │
│   ├─ 仅限 OpenClaw 内部 ──────▶ Hook 事件
│   │
│   └─ 涉及外部系统 ────────────▶ Webhook 事件
│
└─ 需要多视角决策/评审 ──────────▶ 圆桌模式
    │
    ├─ 简单投票 ────────────────▶ 多数投票策略
    ├─ 领域专家权重不同 ─────────▶ 置信度加权投票
    └─ 安全/合规一票否决 ────────▶ 否决权机制

┌─────────────────────────────────────────────────────────────┐
│                    产品开发 Agent 团队                         │
│                                                              │
│  ┌──────────┐    消息传递     ┌──────────┐                   │
│  │ PM Agent │──────────────▶│ 开发Agent │                   │
│  │ (产品经理) │               │ (全栈开发) │                   │
│  └────┬─────┘               └────┬─────┘                   │
│       │                          │                          │
│       │ 共享内存                   │ spawn                   │
│       ▼                          ▼                          │
│  ┌──────────┐              ┌──────────┐                    │
│  │ shared/  │              │ 测试Agent │                    │
│  │ PRD.md   │◀─────────────│ (QA工程师) │                    │
│  │ SPEC.md  │              └──────────┘                    │
│  │ STATUS.md│                                              │
│  └──────────┘    事件广播                                    │
│       ▲          ┌──────────┐                              │
│       └──────────│ 审核Agent │ ◀── 圆桌模式（代码审查）        │
│                  │ (Tech Lead)│                              │
│                  └──────────┘                              │
└─────────────────────────────────────────────────────────────┘

# agents.yaml - 产品开发团队
agents:
  pm-agent:
    model: claude-sonnet-4-20250514
    agentDir: ./agents/pm
    soul: |
      你是产品经理。职责：
      1. 将用户需求转化为 PRD，写入 ../shared/PRD.md
      2. 更新 ../shared/STATUS.md 中的项目进度
      3. 需求确认后通知开发 Agent 开始工作
    tools:
      - sessions_send
      - file_read
      - file_write
    hooks:
      morning_standup:
        trigger: "cron"
        schedule: "0 9 * * 1-5"    # 工作日早上 9 点
        action: "读取 STATUS.md，生成每日站会摘要"
 
  dev-agent:
    model: claude-sonnet-4-20250514
    agentDir: ./agents/dev
    soul: |
      你是全栈开发者。职责：
      1. 读取 ../shared/PRD.md 了解需求
      2. 编写代码并提交
      3. 完成后 spawn 测试 Agent 进行验证
      4. 代码审查通过后更新 ../shared/STATUS.md
    tools:
      - sessions_spawn
      - file_read
      - file_write
      - shell_exec
    auth_profiles:
      - github-push
 
  test-agent:
    model: claude-haiku
    agentDir: ./agents/test
    soul: |
      你是 QA 工程师。职责：
      1. 接收开发 Agent 的测试请求
      2. 运行测试套件
      3. 将测试结果写入 ../shared/TEST_RESULTS.md
      4. 如有失败，通知开发 Agent
    tools:
      - file_read
      - shell_exec
 
  review-agent:
    model: claude-sonnet-4-20250514
    agentDir: ./agents/review
    soul: |
      你是 Tech Lead。职责：
      1. 监控 ../shared/STATUS.md 中的"待审查"状态
      2. 发起圆桌讨论进行代码审查（安全、性能、可维护性）
      3. 审查通过后更新状态为"已完成"
    tools:
      - sessions_spawn
      - sessions_send
      - file_read
      - file_write
    hooks:
      check_reviews:
        trigger: "heartbeat"
        action: "检查 STATUS.md 是否有待审查的任务"

1. 用户向 PM Agent 描述需求
   │
2. PM Agent 编写 PRD → 写入 shared/PRD.md
   │                    更新 shared/STATUS.md = "需求已确认"
   │
3. PM Agent 通过 sessions_send 通知 Dev Agent
   │
4. Dev Agent 读取 PRD.md → 编写代码 → 提交
   │
5. Dev Agent 通过 sessions_spawn 创建 Test Agent
   │  （并行：Dev Agent 继续下一个任务）
   │
6. Test Agent 运行测试 → 结果写入 shared/TEST_RESULTS.md
   │                      更新 STATUS.md = "待审查"
   │
7. Review Agent 心跳检测到"待审查" → 发起圆桌讨论
   │  - 安全视角审查
   │  - 性能视角审查
   │  - 可维护性视角审查
   │
8. 圆桌讨论结果写入 shared/REVIEW.md
   │  更新 STATUS.md = "已完成" 或 "需修改"
   │
9. 如需修改 → 通知 Dev Agent → 回到步骤 4