back
loading skill details...
Multi-agent deep discussion with intelligent Orchestrator coordination. Uses agenda checklist to track progress. Each agenda item goes through 3 rounds (Dive...
---
name: deep-discussion
displayName: 🗣️ 深度专家讨论
description: |
Multi-agent deep discussion with intelligent Orchestrator coordination.
Uses agenda checklist to track progress. Each agenda item goes through
3 rounds (Diverge → Discuss → Converge). Use for complex problems requiring
diverse perspectives. Triggers on "深入讨论", "深度讨论", "专家讨论".
license: MIT
version: 3.3
metadata:
{"openclaw":{"emoji":"🗣️","category":"collaboration"}}
---
# Deep Discussion Skill
Multi-agent deep discussion through **intelligent Orchestrator coordination** with **agenda checklist tracking**.
---
## Quick Start
```
User: "深入讨论预制菜行业现状，使用 5 个专家"
Assistant:
1. Check maxSpawnDepth
2. Align topic (自然对话式)
3. Confirm experts
4. Spawn Orchestrator subagent (thinking: "high")
```
**Result**: Agenda items × 3 rounds = 根据议程数量而定
---
## 输出文件
每个讨论会生成以下文件（保存到 `workspace/deep-discussion/{topic-slug}/`）：
| 文件 | 内容 |
|------|------|
| `agenda.md` | **议程清单（checklist 格式）**，追踪讨论进度 |
| `discussion-log.md` | **完整讨论记录**，包含所有专家的原始输出（必须！） |
| `report.md` | 结构化报告，提炼关键决策和行动计划 |
| `action-plan.md` | 详细行动计划，包含时间线和负责人 |
**⚠️ 讨论完成后不要创建其他文件（如 discussion.md），避免与 discussion-log.md 重复。**
## ⚠️ agenda.md 规范
**议程清单采用 checklist 格式，追踪讨论进度：**
```markdown
# 议程清单 - {topic}
## Phase 1: 价值定位
- [ ] 1. 讨论是否要修改议程
- [ ] 2. 学习规划功能的价值主张是什么？
- [ ] 3. 与自适应引擎如何协同？
## Phase 2: 实现方式
- [ ] 4. 时长预测技术路径？
- [ ] 5. 数据需求与特征工程？
...
## 讨论进度
- 总议题数：{N}
- 已完成：{M}
- 进行中：{K}
```
**Orchestrator 职责**：
- 讨论前创建 `agenda.md`
- 议程第 1 项：讨论是否要修改议程
- 根据专家反馈**更新议程**（考虑依赖关系）
- 每完成一项 → 打勾 ✅
- 实时更新讨论进度
## ⚠️ discussion-log.md 规范
**必须包含所有专家的原始输出！**
```markdown
# 完整讨论记录 - {topic}
## Phase 1: 价值定位
### 议题 2: 学习规划功能的价值主张是什么？
#### Round 1: 发表观点
##### 专家 1: {角色名}
{专家 1 的完整原始输出}
---
##### 专家 2: {角色名}
{专家 2 的完整原始输出}
---
...
#### Round 2: 互相讨论
##### 专家 3 回应专家 1 的问题
{专家 3 的完整原始输出}
---
...
#### Round 3: 收敛共识
##### Orchestrator 总结
{共识总结}
---
### 议题 3: 与自适应引擎如何协同？
...
```
**Orchestrator 职责**：
- 每次 spawn 专家后，**立即**将专家输出追加到 discussion-log.md
- 不要只保存到单独文件，必须汇总到一个文件
- 按 Phase → 议题 → Round → Expert 组织
---
## ⚠️ Pre-flight Checks
### Check 1: maxSpawnDepth
```bash
openclaw config get agents.defaults.subagents.maxSpawnDepth
```
| Value | Orchestrator 运行位置 | 说明 |
|-------|----------------------|------|
| `≥2` | **Orchestrator: Subagent** ⭐ | 启动独立 Orchestrator subagent 协调专家 |
| `=1` | **Orchestrator: Main** | 主 Session 直接作为 Orchestrator 管理专家 |
| `0` | ❌ Blocked | 需要先更新配置 |
> 💡 不管什么模式都需要 Orchestrator 角色，区别只是运行位置。
### Check 2: Topic Alignment
**⚠️ 重要：话题对齐不是固定问题，而是自然对话式理解。**
根据讨论主题灵活调整问题，目标是理解：
- 讨论目标是什么？
- 需要哪些视角/专业知识？
- 期望产出是什么？
**示例：**
| 主题 | 话题对齐问题 |
|------|-------------|
| 预制菜行业 | "是做投资研究、产品规划、还是市场调研？" |
| 技术选型 | "是要做架构决策，还是技术调研报告？" |
| 产品功能 | "是解决具体问题，还是探索新方向？" |
**避免机械地问 5 个固定问题！**
### Check 3: Expert Confirmation + Final Go
基于话题对齐，推荐专家角色供用户确认：
```
🎯 推荐专家（{N} 位）：
1. {角色 1} - {职责说明}
2. {角色 2} - {职责说明}
3. {角色 3} - {职责说明}
...
调整或确认？[y/N 或修改]
```
**用户确认后 → 直接 spawn Orchestrator，不再追问！**
**示例：**
```
🎯 推荐专家（5 位）：
1. 行业分析师 - 市场规模、趋势分析
2. 供应链专家 - 成本结构、效率优化
3. 消费研究员 - 用户需求、行为分析
4. 政策顾问 - 法规风险、合规建议
5. 投资专家 - 估值逻辑、投资回报
调整或确认？[y/N 或修改]
```
用户回复 "确认" 或 "y" → 立即启动 Orchestrator
---
## Core Concepts
### 议程清单（Agenda Checklist）
**议程清单是讨论的核心追踪工具：**
```markdown
# 议程清单 - {topic}
## Phase 1: 价值定位
- [ ] 1. 讨论是否要修改议程
- [ ] 2. 学习规划功能的价值主张是什么？
- [ ] 3. 与自适应引擎如何协同？
## Phase 2: 实现方式
- [ ] 4. 时长预测技术路径？
...
```
**关键规则：**
1. **第一项必须是"讨论是否要修改议程"**
2. **Phase 是议程的逻辑分组**（不是独立阶段）
3. **每完成一项 → 打勾 ✅**
4. **Orchestrator 根据依赖关系编排议程顺序**
### 三轮讨论机制（每个议题）
每个议题都经历三轮讨论：
| Round | 目标 | 方式 | 结束条件 |
|-------|------|------|---------|
| **Round 1: Diverge** | 发表观点 | 并行 spawn 所有专家 | 全部完成 |
| **Round 2: Discuss** | 互相讨论 | 依次 spawn（动态轮数） | 无争议点 AND 无未回答问题 |
| **Round 3: Converge** | 收敛共识 | Orchestrator 总结 | 达成共识 → 打勾 ✅ |
**议题完成后 → 进入下一议题**
### 议程依赖关系
**Orchestrator 在修改议程时需要考虑依赖关系：**
```
正确的议程顺序：
1. 问题定义 → 2. 技术方案 → 3. 实施计划
错误的议程顺序：
1. 实施计划 → 2. 问题定义 → 3. 技术方案
（实施依赖于问题定义和技术方案）
```
**依赖关系示例：**
- "技术方案" 依赖于 "问题定义"
- "实施计划" 依赖于 "技术方案" 和 "资源评估"
- "测试策略" 依赖于 "技术方案"
---
## Orchestrator 工作流程
### 架构
```
主 Session（深度 0）
│
└─→ Orchestrator（深度 1）[运行在 Subagent 或 Main]
│
├─→ 1. 创建 agenda.md（议程清单）
│
├─→ 2. 议程第 1 项：讨论是否要修改议程
│ ├─ 并行 spawn 所有专家发表看法
│ ├─ 根据反馈更新议程（考虑依赖关系）
│ └─ 打勾 ✅
│
└─→ 3. 按议程逐项讨论：
├─ Round 1: 并行 spawn 所有专家发表观点
├─ Round 2: 依次 spawn 专家讨论（动态轮数）
├─ Round 3: 收敛共识
└─ 打勾 ✅ → 下一议题
```
### 议程第 1 项：讨论是否要修改议程
```
议程第 1 项：
├── 1. 并行 spawn 所有专家
│ task: "请审视议程草案，提出修改建议"
├── 2. 收集专家反馈
├── 3. 根据反馈更新议程
│ - 考虑依赖关系编排顺序
│ - 合并相似议题
│ - 拆分复杂议题
│ - 添加遗漏议题
├── 4. 更新 agenda.md
└── 5. 打勾 ✅
```
### 每个议题的讨论流程
```
议题 N：
├── Round 1: 发表观点（并行 spawn）
│ 所有专家同时发表对议题 N 的看法
│ 追加到 discussion-log.md
│
├── Round 2: 互相讨论（依次 spawn）
│ 检测争议点和未回答问题
│ 依次 spawn 专家回应
│ 直到无争议点 AND 无未回答问题
│
├── Round 3: 收敛共识
│ Orchestrator 总结共识
│ 记录未解决争议
│
└── 打勾 ✅ → 更新 agenda.md → 进入议题 N+1
```
### Round 1: 发表观点（并行 spawn）
```javascript
// 并行 spawn 所有专家（必须启用 thinking: "high"）
const experts = [1, 2, 3, 4, 5];
experts.forEach(id => sessions_spawn({
label: `expert-${id}`,
mode: "run",
runtime: "subagent",
thinking: "high", // ⚠️ 必须启用
task: `针对议题 {current_topic}，发表你的观点。`
}));
// 等待所有专家完成
// 追加到 discussion-log.md
```
### Round 2: 互相讨论（依次 spawn）
```javascript
// 检测争议点和未回答问题
while (hasUnansweredQuestions() || hasControversies()) {
// 选择下一个发言的专家
const { expertId } = selectNextExpert();
// 依次 spawn 该专家（必须启用 thinking: "high"）
sessions_spawn({
label: `expert-${expertId}-round2`,
mode: "run",
runtime: "subagent",
thinking: "high", // ⚠️ 必须启用
task: `请回应以下讨论：
- 专家 A 问了你：xxx
- 专家 B 和 C 对 xxx 有分歧
- 讨论历史：{context}`
});
// ⚠️ 等待该专家完成后再 spawn 下一位
// 追加到 discussion-log.md
// 更新讨论状态
}
```
### Round 3: 收敛共识
```
├── 总结共识点
├── 记录未解决争议点
├── 判断是否达成共识
└── 打勾 ✅ → 更新 agenda.md → 进入下一议题
```
### 状态追踪
Orchestrator 需要维护讨论状态：
```json
{
"current_phase": "Phase 1: 价值定位",
"current_topic": "议题 2: 学习规划功能的价值主张",
"current_round": 2,
"agenda_status": {
"议题 1": "completed",
"议题 2": "in_progress",
"议题 3": "pending"
},
"questions": [{asker, target, question, answered}],
"controversies": [{topic, experts, positions}],
"consensus": [{topic, agreedBy}],
"statistics": {
"topic_durations": {
"议题 1": {"start": "10:00", "end": "10:15", "duration_min": 15},
"议题 2": {"start": "10:15", "end": null, "duration_min": null}
},
"expert_speeches": {
"专家 1": {"total": 5, "by_topic": {"议题 1": 2, "议题 2": 3}},
"专家 2": {"total": 4, "by_topic": {"议题 1": 2, "议题 2": 2}},
...
}
}
}
```
### 智能专家选择（Round 2）
```
优先级：未回答问题 → 争议调解 → 未发言专家 → 轮换
```
---
## Orchestrator 运行模式
| 方面 | Subagent ⭐ | Main |
|------|------------|------|
| 运行位置 | 独立 subagent | 主 Session |
| 专家 spawn | Round 1 并行，Round 2 依次 | 同左 |
| 状态管理 | Orchestrator 内部维护 | 主 Session 维护 |
| 启动命令 | sessions_spawn(...) | 主 Session 直接执行 |
| 适用条件 | maxSpawnDepth ≥ 2 | maxSpawnDepth = 1 |
### Orchestrator: Subagent 启动命令
**⚠️ 重要：Orchestrator 必须使用 `mode: "session"`，而非 `mode: "run"`！**
| mode | 行为 | 适用场景 |
|------|------|----------|
| `"run"` | 一次性执行，spawn 子任务后立即返回 | 简单任务，不需要协调 |
| `"session"` ⭐ | 持久会话，持续追踪子任务，可等待/轮询结果 | 多轮协调、需要收集结果 |
**为什么 Orchestrator 需要 `mode: "session"`？**
- Orchestrator 需要 spawn 多个专家，并等待他们完成
- 需要收集专家输出，写入 discussion-log.md
- 需要持续追踪讨论进度（哪个议题、哪个 Round）
- `mode: "run"` 会立即返回，无法等待子任务结果
**⚠️ 平台限制**：`mode: "session"` 需要 `thread: true`，但飞书插件暂不支持 thread 模式。
**替代方案**：在 `mode: "run"` 模式下，Orchestrator spawn 专家后调用 `sessions_yield()` 等待子任务完成，系统会在所有子任务完成后通知继续。
```javascript
sessions_spawn({
label: "orchestrator-{topic-slug}",
runtime: "subagent",
model: "bailian/qwen3.5-plus",
thinking: "high", // ⚠️ 必须启用
mode: "run", // 飞书不支持 session 模式，用 run + yield 替代
runTimeoutSeconds: 14400, // 4 小时超时
task: `...
## ⚠️ 关键：如何等待子任务完成
当你 spawn 专家后，必须等待他们完成：
1. spawn 专家
2. 调用 sessions_yield({ message: "等待专家完成..." })
3. 系统会在所有子任务完成后通知你
4. 继续处理结果
...`
});
task: `你是 Deep Discussion Orchestrator。
## 基本信息
- 主题：{topic}
- 用户背景：{user_context}
- 专家列表：{experts}
- 输出目录：workspace/deep-discussion/{topic-slug}/
## ⚠️ 核心流程
### 1. 创建议程清单
创建 agenda.md，初始议程包含：
- 第一项：讨论是否要修改议程
- 后续议题：根据讨论主题设计
### 2. 议程第 1 项：讨论是否要修改议程
- 并行 spawn 所有专家收集反馈
- 根据反馈更新议程（考虑依赖关系）
- 打勾 ✅
### 3. 按议程逐项讨论
每个议题经历三轮：
- Round 1: 并行 spawn 发表观点
- Round 2: 依次 spawn 互相讨论
- Round 3: 收敛共识 → 打勾 ✅
### 4. 生成报告
所有议题完成后生成 report.md
## ⚠️ 专家 Spawn 规范
所有专家 spawn 时必须：
- runtime: "subagent"
- thinking: "high"
- mode: "run"
## ⚠️ 议程依赖关系
修改议程时需要考虑：
- 问题定义 → 技术方案 → 实施计划（依赖链）
- 技术方案依赖于问题定义
- 实施计划依赖于技术方案和资源评估
## ⚠️ discussion-log.md 强制规范
每次 spawn 专家后，必须立即追加到 discussion-log.md！
### 格式要求：
```markdown
## Phase {N}: {Phase 名称}
### Round {M}: {Round 类型}
#### 专家 {id}: {角色名}
{专家的完整原始输出，不要总结，不要省略}
---
#### 专家 {id+1}: {角色名}
{专家的完整原始输出}
---
```
### ⚠️ 严格禁止：
1. ❌ 不要只保存到单独文件，必须汇总到 discussion-log.md
2. ❌ 不要总结专家输出，必须保留完整原始内容
3. ❌ 不要省略任何专家的输出
4. ❌ 不要在讨论结束后才写入，必须在 spawn 后立即追加
### 执行流程：
```
每次 spawn 专家：
1. 等待专家完成
2. 读取专家输出
3. 立即追加到 discussion-log.md（格式：Phase → Round → Expert）
4. 继续下一个专家
```
## 完成后汇报
1. Phase 结构说明
2. 讨论摘要
3. 关键共识
4. 未解决问题
5. 最终产出`
})
```
### Orchestrator: Main 运行方式
主 Session 直接执行 Orchestrator 工作流程，状态保存在主 Session 中。
---
## Model Policy
**Default**: `bailian/qwen3.5-plus` (strong conversation ability)
**If unavailable:**
```
⚠️ Model unavailable: bailian/qwen3.5-plus
Options:
A. Wait for recovery
B. Use alternative model (user-specified)
C. Cancel
```
---
## Key Points
1. **议程清单追踪**：agenda.md 维护讨论进度，每完成一项打勾 ✅
2. **第一项必是议程修改**：讨论是否要修改议程
3. **Phase = 议程分组**：逻辑分组，不是独立阶段
4. **三轮讨论机制**：Round 1 并行 → Round 2 依次 → Round 3 收敛
5. **thinking: "high"**：所有专家和 Orchestrator 必须启用深度思考
6. **议程依赖关系**：修改议程时考虑依赖关系编排顺序
7. **并行/依次规则**：Round 1 可并行，Round 2 必须依次
8. **统计追踪**：记录每个议题讨论时间 + 每个专家发言次数
9. **Orchestrator: Subagent** - maxSpawnDepth ≥ 2 时推荐
10. **Model: qwen3.5-plus** - 对话能力强
11. **⚠️ Orchestrator 必须用 `mode: "session"`** - 持续追踪子任务，等待专家完成后再继续
12. **⚠️ 断点续传机制** - Orchestrator 每完成一步更新状态文件，Main Session 检查并继续
13. **⚠️ sessions_yield 循环模式** - Orchestrator 必须在 task 中写好循环结构
---
## ⚠️ sessions_yield 循环模式（核心）
### 问题分析
`sessions_yield` 的正确用法：
- 结束当前 turn
- 携带 hidden payload 到下一个 turn
- 系统会在子任务完成后唤醒下一个 turn
**关键问题**：当所有子任务完成后，如果 Orchestrator 的代码没有更多要执行的，它就会返回。
**解决方案**：在 Orchestrator 的 task 中写好**循环结构**，让它知道还有更多工作要做。
### 正确的循环模式
```markdown
你是 Deep Discussion Orchestrator。
## ⚠️ 核心要求：完成所有议题
你必须完成所有议题，不能提前停止。
## 执行循环
```
while (还有未完成的议题) {
// 1. 执行当前议题的当前轮次
spawn 专家
// 2. yield 等待专家完成
sessions_yield({ message: "等待专家完成..." })
// 3. 系统唤醒后，收集结果
收集专家输出
// 4. 写入 discussion-log.md
// 5. 检查议题是否完成
if (议题完成) {
打勾 ✅
更新状态文件
进入下一议题
}
}
```
## ⚠️ 每次 yield 后，系统会唤醒你继续
你的 task 必须包含完整的循环逻辑，让系统知道唤醒后要做什么。
## 任务模板
从 orchestrator-state.json 读取当前状态，执行以下循环：
1. 如果 `status === "completed"` → 直接返回"讨论已完成"
2. 如果 `status === "in_progress"` → 从 `next_action` 继续
3. 执行当前议题的当前轮次
4. spawn 专家 → yield → 收集结果 → 写 log
5. 更新状态文件
6. 如果还有议题，设置 `next_action` 并继续
7. 如果所有议题完成，设置 `status: "completed"` 并返回最终报告
```
### 错误示范
```markdown
# ❌ 错误：没有循环结构
spawn 专家 A, B, C
sessions_yield({ message: "等待..." })
# yield 后直接返回，没有更多代码
```
### 正确示范
```markdown
# ✅ 正确：有明确的循环结构
读取状态文件
while (pending_topics.length > 0) {
执行当前议题
spawn 专家
sessions_yield({ message: "等待..." })
收集结果
更新状态文件
if (议题完成) {
pending_topics.shift()
}
}
返回最终报告
```
---
## ⚠️ 断点续传机制（解决 Orchestrator 中断问题）
### 问题背景
`sessions_yield` 的设计让 Orchestrator 可以暂停等待子任务，但当所有子任务完成后，Orchestrator 会返回（认为任务完成）。这导致多议题讨论无法在一次 spawn 中完成。
### 解决方案：状态持久化 + Main Session 协调
**核心思路**：
1. Orchestrator 每完成一步，更新 `orchestrator-state.json` 状态文件
2. Main Session 检查状态文件
3. 如果未完成，spawn 新的 Orchestrator 从断点继续
### 状态文件格式
**文件位置**：`workspace/deep-discussion/{topic-slug}/orchestrator-state.json`
```json
{
"status": "in_progress",
"current_phase": "Phase 2",
"current_topic": 7,
"current_round": 2,
"completed_topics": [1, 2, 3, 4, 5, 6],
"pending_topics": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27],
"last_update": "2026-03-14T17:30:00Z",
"next_action": "spawn_expert_round2",
"next_action_detail": {
"expert": "创业/投资视角",
"round": 2,
"topic": 7
}
}
```
### Main Session 协调流程
```javascript
// Main Session 启动讨论
async function runDeepDiscussion(topic, experts, totalTopics) {
// 1. 初始 spawn Orchestrator
let result = await sessions_spawn({
label: `orchestrator-${topic}`,
runtime: "subagent",
model: "bailian/qwen3.5-plus",
thinking: "high",
mode: "run",
runTimeoutSeconds: 1800, // 30 分钟
task: `...`
});
// 2. 检查状态文件
while (true) {
const state = readStateFile(topic);
if (state.status === "completed") {
console.log("讨论完成！");
break;
}
if (state.status === "in_progress") {
// 3. 继续未完成的工作
result = await sessions_spawn({
label: `orchestrator-${topic}-continue`,
runtime: "subagent",
model: "bailian/qwen3.5-plus",
thinking: "high",
mode: "run",
runTimeoutSeconds: 1800,
task: `从断点继续：
- 当前议题: ${state.current_topic}
- 当前轮次: ${state.current_round}
- 下一步: ${state.next_action}
...`
});
}
// 4. 等待一段时间再检查
await sleep(60000); // 1 分钟
}
}
```
### Orchestrator 任务模板（支持断点续传）
```markdown
你是 Deep Discussion Orchestrator。
## 基本信息
- 主题：{topic}
- Topic Slug: {topic-slug}
- 输出目录：workspace/deep-discussion/{topic-slug}/
## ⚠️ 断点续传要求
### 每完成一步，必须更新状态文件：
```json
// workspace/deep-discussion/{topic-slug}/orchestrator-state.json
{
"status": "in_progress",
"current_phase": "Phase X",
"current_topic": N,
"current_round": M,
"completed_topics": [...],
"pending_topics": [...],
"last_update": "ISO时间戳",
"next_action": "具体下一步操作"
}
```
### 完成所有议题后，设置：
```json
{
"status": "completed",
"completed_topics": [1, 2, 3, ...],
"last_update": "..."
}
```
## 执行流程
1. **读取状态文件**（如果存在）
- 如果 `status === "completed"`，直接返回
- 如果 `status === "in_progress"`，从 `next_action` 继续
2. **执行当前议题的当前轮次**
- spawn 专家
- 收集结果
- 更新状态文件
3. **如果还有未完成的议题**
- 更新状态文件，设置 `next_action`
- yield 等待
4. **如果所有议题完成**
- 设置 `status: "completed"`
- 生成最终报告
## 状态更新时机
- 议题开始 → 更新 `current_topic`, `current_round`
- Round 完成 → 更新 `current_round`
- 议题完成 → 更新 `completed_topics`, `pending_topics`
- 所有完成 → 更新 `status: "completed"`
```
### Main Session 检查间隔
| 议题数 | 检查间隔 | 原因 |
|--------|---------|------|
| ≤5 | 2 分钟 | 短讨论，快速检查 |
| 6-15 | 5 分钟 | 中等讨论 |
| >15 | 10 分钟 | 长讨论，减少检查开销 |
---
## 统计追踪功能
Orchestrator 需要实时记录讨论统计：
### 议题讨论时间
```python
# 议题开始时
topic_start_time = current_time()
statistics["topic_durations"]["议题 N"] = {"start": topic_start_time}
# 议题完成时
topic_end_time = current_time()
duration = topic_end_time - topic_start_time
statistics["topic_durations"]["议题 N"]["end"] = topic_end_time
statistics["topic_durations"]["议题 N"]["duration_min"] = duration / 60
```
### 专家发言次数
```python
# 每次 spawn 专家后
expert_id = expert.id
statistics["expert_speeches"][expert_id]["total"] += 1
statistics["expert_speeches"][expert_id]["by_topic"][current_topic] += 1
```
### 最终报告中的统计
```markdown
## 议题讨论时间
| 议题 | 开始时间 | 结束时间 | 时长 |
|------|---------|---------|------|
| 议题 1 | 10:00 | 10:15 | 15 min |
| 议题 2 | 10:15 | 10:35 | 20 min |
...
## 专家发言统计
| 专家 | 总发言次数 | 各议题发言次数 |
|------|-----------|---------------|
| 专家 1 | 8 | 议题 1: 2, 议题 2: 3, 议题 3: 3 |
| 专家 2 | 6 | 议题 1: 2, 议题 2: 2, 议题 3: 2 |
...
```
---
## References
- [expert-roles.md](references/expert-roles.md) - 专家角色库
- [orchestrator-logic.md](references/orchestrator-logic.md) - 详细逻辑
- [discussion-protocol.md](references/discussion-protocol.md) - 讨论协议don't have the plugin yet? install it then click "run inline in claude" again.