名称: 文件辅助头脑风暴描述: 通过并行子代理协作、想法扩展和文档化思想演进进行交互式头脑风暴。为 Codex 提供并行多视角分析。参数提示: “TOPIC="<想法或主题>" [–perspectives=创意,实用,系统化] [–max-ideas=<n>]”

Codex 文件辅助头脑风暴工作流

快速开始

交互式头脑风暴工作流，带有 文档化思想演进。通过提问、并行子代理分析 和迭代优化扩展初始想法。

核心工作流: 种子想法 → 扩展 → 并行子代理探索 → 综合 → 优化 → 结晶

关键特性:

brainstorm.md: 完整的思想演进时间线
并行多视角: 创意 + 实用 + 系统化（并发子代理）
想法扩展: 渐进式提问和探索
发散-收敛循环: 生成选项后聚焦最佳路径

Codex 特定特性:

通过 spawn_agent + 批量 wait({ ids: [...] }) 实现并行子代理执行
通过路径加载角色（代理自行读取 ~/.codex/agents/*.md）
通过 send_input 进行深度交互以在单个代理内进行多轮优化
使用 close_agent 进行显式生命周期管理

概述

该工作流通过并行能力阶段实现想法的迭代探索和优化：

种子理解 - 解析初始想法并识别探索向量
发散探索 - 收集代码库上下文并执行并行多视角分析
交互式优化 - 通过 send_input 进行多轮想法选择、深度挖掘和优化
收敛与结晶 - 综合最终想法并生成推荐

关键创新是 文档化思想演进，捕捉想法如何发展、视角差异以及所有阶段的见解涌现。

输出结构

{项目根目录}/.workflow/.brainstorm/BS-{简短标识}-{日期}/
├── brainstorm.md                  # ⭐ 完整思想演进时间线
├── exploration-codebase.json      # 阶段2: 代码库上下文
├── perspectives/                  # 阶段2: 个体视角输出
│   ├── creative.json
│   ├── pragmatic.json
│   └── systematic.json
├── perspectives.json              # 阶段2: 聚合并行发现与综合
├── synthesis.json                 # 阶段4: 最终综合
└── ideas/                         # 阶段3: 个体想法深度挖掘
    ├── idea-1.md
    ├── idea-2.md
    └── merged-idea-1.md

输出工件

阶段1: 种子理解

工件	目的
`brainstorm.md`	使用会话元数据、种子扩展和探索向量初始化
会话变量	主题简短标识、头脑风暴模式、维度、探索向量

阶段2: 发散探索

工件	目的
`exploration-codebase.json`	代码库上下文：相关文件、模式、架构约束
`perspectives/*.json`	并行子代理的个体视角输出
`perspectives.json`	聚合并行发现与综合（收敛/冲突主题）
更新 `brainstorm.md`	第2轮: 探索结果和多视角分析

阶段3: 交互式优化

工件	目的
`ideas/{想法简短标识}.md`	选定想法的深度挖掘分析
更新 `brainstorm.md`	第3-6轮: 用户反馈、想法选择、优化循环

阶段4: 收敛与结晶

工件	目的
`synthesis.json`	最终综合：顶级想法、推荐、见解
最终 `brainstorm.md`	带有结论的完整思想演进

实现细节

会话初始化

步骤0: 确定项目根目录

检测项目根目录，确保 .workflow/ 产物位置正确：

PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)

优先通过 git 获取仓库根目录；非 git 项目回退到 pwd 取当前绝对路径。存储为 {项目根目录}，后续所有 .workflow/ 路径必须以此为前缀。

工作流自动基于主题和当前日期（UTC+8）生成唯一会话标识符和目录结构。

会话ID格式: BS-{简短标识}-{日期}

简短标识: 小写字母数字 + 中文字符，最大40字符
日期: YYYY-MM-DD 格式（UTC+8）

会话目录: {项目根目录}/.workflow/.brainstorm/{会话ID}/

自动检测: 如果会话文件夹存在且包含 brainstorm.md，则自动进入继续模式。否则，创建新会话。

头脑风暴模式:

创意: 强调新颖性和创新，放松约束
结构化: 平衡创意与可行性，现实范围
平衡: 默认，适度创新与实用考虑

阶段1: 种子理解

目标: 解析初始想法，识别探索向量、范围偏好，并初始化头脑风暴文档。

步骤1.1: 解析种子并识别维度

工作流根据预定义头脑风暴维度分析主题文本。

头脑风暴维度:

维度	关键词
技术	技术, technical, implementation, code, 实现, architecture
用户体验	用户, user, experience, UX, UI, 体验, interaction
业务	业务, business, value, ROI, 价值, market
创新	创新, innovation, novel, creative, 新颖
可行性	可行, feasible, practical, realistic, 实际
可扩展性	扩展, scale, growth, performance, 性能
安全	安全, security, risk, protection, 风险

匹配逻辑: 比较主题文本与关键词列表以识别相关维度。

步骤1.2: 角色选择

基于主题关键词推荐角色，然后让用户确认或覆盖。

专业角色（基于主题关键词推荐）:

角色	视角代理焦点	关键词
系统架构师	架构、模式	架构, architecture, system, 系统, design pattern
产品经理	业务价值、路线图	产品, product, feature, 功能, roadmap
UI设计师	视觉设计、交互	UI, 界面, interface, visual, 视觉
UX专家	用户研究、可用性	UX, 体验, experience, user, 用户
数据架构师	数据建模、存储	数据, data, database, 存储, storage
测试策略师	质量、测试	测试, test, quality, 质量, QA
领域专家	领域知识	领域, domain, industry, 行业, expert

简单视角（后备 - 始终可用）:

视角	焦点	最佳适用
创意	创新、跨领域	生成新颖想法
实用	实现、可行性	现实检查想法
系统化	架构、结构	组织解决方案

选择策略:

自动模式: 基于关键词匹配选择前3个推荐专业角色
手动模式: 展示推荐角色 + “使用简单视角” 选项
继续模式: 使用之前会话的角色

步骤1.3: 初始范围界定（仅新会话）

对于新头脑风暴会话，在探索前收集用户偏好。

头脑风暴模式（单选）:

创意模式 (创意模式 - 15-20分钟, 1个子代理)
平衡模式 (平衡模式 - 30-60分钟, 3个并行子代理)
深度模式 (深度模式 - 1-2+小时, 3个并行子代理 + 深度优化)

重点领域（多选）:

技术方案 (技术解决方案)
用户体验 (用户体验)
创新突破 (创新突破)
可行性评估 (可行性评估)

约束（多选）:

现有架构 (现有架构约束)
时间限制 (时间约束)
资源限制 (资源约束)
无约束 (无约束)

步骤1.4: 将种子扩展为探索向量

生成指导头脑风暴探索的关键问题。使用子代理进行向量生成。

探索向量:

核心问题: 根本问题/机会是什么？
用户视角: 谁受益以及如何受益？
技术角度: 技术上是什么使这成为可能？
替代方法: 还有哪些其他方式可以解决这个问题？
挑战: 什么可能出错或阻碍成功？
创新角度: 什么会让这变得10倍更好？
集成: 这如何与现有系统/流程契合？

向量生成子代理:

const vectorAgent = spawn_agent({
  message: `
## 任务分配

### 强制第一步（代理执行）
1. **读取角色定义**: ~/.codex/agents/cli-explore-agent.md（必须先读）

---

## 上下文
主题: ${想法或主题}
用户重点领域: ${用户重点领域.join(', ')}
约束: ${约束.join(', ')}

## 任务
生成5-7个探索向量（问题/方向）以扩展这个想法：
1. 核心问题: 根本问题/机会是什么？
2. 用户视角: 谁受益以及如何受益？
3. 技术角度: 技术上是什么使这成为可能？
4. 替代方法: 还有哪些其他方式可以解决这个问题？
5. 挑战: 什么可能出错或阻碍成功？
6. 创新角度: 什么会让这变得10倍更好？
7. 集成: 这如何与现有系统/流程契合？

## 交付物
返回结构化探索向量以进行多视角分析。
`
})

const result = wait({ ids: [vectorAgent], timeout_ms: 120000 })
close_agent({ id: vectorAgent })

目的: 这些向量指导每个视角子代理的分析并确保全面探索。

步骤1.5: 初始化 brainstorm.md

使用会话元数据和扩展内容创建主要头脑风暴文档。

brainstorm.md 结构:

头部: 会话ID、主题、开始时间、头脑风暴模式、维度
初始上下文: 重点领域、深度级别、约束
角色: 选定角色（专业或简单视角）
种子扩展: 原始想法 + 探索向量
思想演进时间线: 逐轮发现
当前想法: 探索后填充

成功标准:

会话文件夹成功创建
brainstorm.md 初始化包含所有元数据
选择1-3个角色（专业或简单视角）
头脑风暴模式和维度识别
探索向量生成
用户偏好捕获

阶段2: 发散探索

目标: 收集代码库上下文并通过并行子代理执行多视角分析以生成多样化观点。

执行模型: 并行子代理执行 - 同时生成3个视角代理，批量等待所有结果，然后聚合。

关键API模式:

spawn_agent × 3 → wait({ ids: [...] }) → 聚合 → close_agent × 3

步骤2.1: 代码库上下文收集

在生成视角代理前使用内置工具理解代码库结构。

上下文收集活动:

获取项目结构 - 执行 ccw tool exec get_modules_by_depth '{}'
搜索相关代码 - 使用 Grep/Glob 查找匹配主题关键词的文件
读取项目技术上下文 - 如果可用，加载 {项目根目录}/.workflow/project-tech.json
分析模式 - 识别常见代码模式和架构决策

exploration-codebase.json 结构:

相关文件[]: 与主题相关的文件，带有相关性指标
现有模式[]: 常见代码模式和架构风格
架构约束[]: 项目级约束
集成点[]: 模块间关键集成模式
_元数据: 时间戳和上下文信息

步骤2.2: 并行多视角分析

⚠️ 重要: 角色文件不由主进程读取。在消息中传递路径，代理自行读取。

并行生成3个视角代理: 创意 + 实用 + 系统化。

视角定义:

视角	角色文件	焦点
创意	`~/.codex/agents/cli-explore-agent.md`	创新、跨领域灵感、挑战假设
实用	`~/.codex/agents/cli-explore-agent.md`	实现可行性、工作量估计、阻碍
系统化	`~/.codex/agents/cli-explore-agent.md`	问题分解、模式、可扩展性

并行子代理执行:

// 从代码库探索构建共享上下文
const explorationContext = `
代码库上下文：
- 关键文件: ${探索结果.相关文件.slice(0,5).map(f => f.路径).join(', ')}
- 现有模式: ${探索结果.现有模式.slice(0,3).join(', ')}
- 架构约束: ${探索结果.架构约束.slice(0,3).join(', ')}`

// 定义视角
const perspectives = [
  {
    name: 'creative',
    focus: '创新和新颖性',
    tasks: [
      '超越明显解决方案思考 - 什么会令人惊喜/愉悦？',
      '探索跨领域灵感',
      '挑战假设 - 如果相反是真的呢？',
      '生成远射想法与实用想法'
    ]
  },
  {
    name: 'pragmatic',
    focus: '实现现实',
    tasks: [
      '评估核心概念的技术可行性',
      '识别可能帮助的现有模式/库',
      '估计实现复杂度',
      '突出潜在技术阻碍'
    ]
  },
  {
    name: 'systematic',
    focus: '架构思维',
    tasks: [
      '将问题分解为子问题',
      '识别适用的架构模式',
      '映射依赖和交互',
      '考虑可扩展性影响'
    ]
  }
]

// 并行生成 - 所有代理立即开始
const agentIds = perspectives.map(perspective => {
  return spawn_agent({
    message: `
## 任务分配

### 强制第一步（代理执行）
1. **读取角色定义**: ~/.codex/agents/cli-explore-agent.md（必须先读）
2. 读取: ${项目根目录}/.workflow/project-tech.json
3. 读取: ${项目根目录}/.workflow/project-guidelines.json

---

## 头脑风暴上下文
主题: ${想法或主题}
视角: ${perspective.name} - ${perspective.focus}
会话: ${会话文件夹}

${explorationContext}

## ${perspective.name.toUpperCase()} 视角任务
${perspective.tasks.map(t => `• ${t}`).join('
')}

## 交付物
写入发现到: ${会话文件夹}/perspectives/${perspective.name}.json

模式: {
  perspective: "${perspective.name}",
  ideas: [{ title, description, novelty, feasibility, rationale }],
  key_findings: [],
  challenged_assumptions: [],
  open_questions: [],
  _metadata: { perspective, timestamp }
}

## 成功标准
- [ ] 角色定义已读
- [ ] 生成3-5个想法，带有评级
- [ ] 关键发现文档化
- [ ] JSON输出遵循模式
`
  })
})

// 批量等待 - 真正的并行性（关键 Codex 优势）
const results = wait({
  ids: agentIds,
  timeout_ms: 600000  // 所有代理10分钟
})

// 处理超时
if (results.timed_out) {
  // 一些代理可能仍在运行
  // 选项: 继续等待或使用已完成结果
}

// 收集所有视角的结果
const completedFindings = {}
agentIds.forEach((agentId, index) => {
  const perspective = perspectives[index]
  if (results.status[agentId].completed) {
    completedFindings[perspective.name] = results.status[agentId].completed
  }
})

// 批量清理
agentIds.forEach(id => close_agent({ id }))

步骤2.3: 聚合多视角发现

整合所有三个并行视角代理的结果。

perspectives.json 结构:

session_id: 头脑风暴会话引用
timestamp: 完成时间
topic: 原始想法/主题
creative: 创意视角发现（带有新颖性评级的想法）
pragmatic: 实用视角发现（带有工作量评级的方案）
systematic: 系统化视角发现（架构选项）
synthesis: {convergent_themes, conflicting_views, unique_contributions}
aggregated_ideas[]: 所有视角合并的想法
key_findings[]: 所有视角的主要见解

聚合活动:

从每个视角输出中提取想法和发现
识别所有视角同意的主题（收敛）
注意冲突观点和权衡
提取每个视角的独特贡献
合并并去重类似想法

const synthesis = {
  session_id: sessionId,
  timestamp: new Date().toISOString(),
  topic: idea_or_topic,

  // 个体视角发现
  creative: completedFindings.creative || {},
  pragmatic: completedFindings.pragmatic || {},
  systematic: completedFindings.systematic || {},

  // 跨视角综合
  synthesis: {
    convergent_themes: extractConvergentThemes(completedFindings),
    conflicting_views: extractConflicts(completedFindings),
    unique_contributions: extractUniqueInsights(completedFindings)
  },

  // 聚合用于优化
  aggregated_ideas: mergeAllIdeas(completedFindings),
  key_findings: mergeKeyFindings(completedFindings)
}

步骤2.4: 更新 brainstorm.md

将探索结果附加到头脑风暴时间线。

第2轮部分（多视角探索）:

创意视角: 带有新颖性/影响评级的创新想法
实用视角: 带有工作量/风险评级的实用方案
系统化视角: 带有权衡分析的架构选项
视角综合: 收敛主题、冲突、独特贡献

文档标准:

包含来自代码库探索的证据
按视角组织发现
突出共识和分歧领域
注意关键假设和推理

成功标准:

所有3个子代理生成并完成（或超时处理）
exploration-codebase.json 创建，包含全面上下文
perspectives/*.json 为每个视角创建
perspectives.json 创建，包含聚合发现和综合
brainstorm.md 更新为第2轮结果
所有代理正确关闭
准备交互式优化阶段

阶段3: 交互式优化

目标: 通过多轮用户引导探索循环迭代优化想法，进行深度挖掘、挑战测试和想法合并。

最大轮数: 6轮优化（如果用户指示完成，可以提前退出）

执行模型: 在同一代理上下文中使用 send_input 进行深度交互，或为显著不同的探索角度生成新代理。

步骤3.1: 展示发现并收集用户方向

向用户展示当前想法和视角。

展示内容:

每个视角的顶级想法，带有评级
收敛主题和共识领域
冲突观点和权衡
用于进一步探索的开放问题

用户反馈选项（单选）:

选项	目的	下一步行动
深入探索	详细探索选定想法	`send_input` 到活动代理或生成深度挖掘代理
继续发散	生成更多想法	生成具有不同角度的新代理
挑战验证	批判性测试想法	生成挑战代理（魔鬼代言人）
合并综合	合并多个想法	生成合并代理以综合
准备收敛	开始收敛	退出优化循环进行综合

步骤3.2: 选定想法的深度挖掘（通过 send_input 或新代理）

当用户选择“深入挖掘”，提供全面分析。

选项A: send_input 到现有代理（如果代理仍然活动，优先）

// 继续使用现有代理上下文
send_input({
  id: perspectiveAgent,  // 如果未关闭，重用阶段2的代理
  message: `
## 延续: 深度挖掘分析

基于您的初始探索，用户希望对以下想法进行更深层次调查：
${selectedIdeas.map((idea, i) => `${i+1}. ${idea.标题}`).join('
')}

## 深度挖掘任务
• 详细阐述每个概念
• 识别实现需求和依赖项
• 分析潜在挑战并提出缓解措施
• 建议概念验证方法
• 定义成功指标

## 交付物
写入: ${会话文件夹}/ideas/{想法简短标识}.md 为每个选定想法

## 成功标准
- [ ] 每个想法有详细分解
- [ ] 技术需求文档化
- [ ] 风险分析带缓解措施
`
})

const deepDiveResult = wait({ ids: [perspectiveAgent], timeout_ms: 600000 })

选项B: 生成新深度挖掘代理（如果先前代理关闭）

const deepDiveAgent = spawn_agent({
  message: `
## 任务分配

### 强制第一步（代理执行）
1. **读取角色定义**: ~/.codex/agents/cli-explore-agent.md（必须先读）
2. 读取: ${会话文件夹}/perspectives.json（先前发现）
3. 读取: ${项目根目录}/.workflow/project-tech.json

---

## 深度挖掘上下文
主题: ${想法或主题}
选定想法: ${selectedIdeas.map(i => i.标题).join(', ')}

## 深度挖掘任务
${selectedIdeas.map(idea => `
### ${idea.标题}
• 详细阐述核心概念
• 识别实现需求
• 列出潜在挑战和缓解措施
• 建议概念验证方法
• 定义成功指标
`).join('
')}

## 交付物
写入: ${会话文件夹}/ideas/{想法简短标识}.md 为每个想法

为每个包括：
- 详细概念描述
- 技术需求列表
- 风险/挑战矩阵
- 最小可行产品定义
- 成功标准
`
})

const result = wait({ ids: [deepDiveAgent], timeout_ms: 600000 })
close_agent({ id: deepDiveAgent })

步骤3.3: 魔鬼代言人挑战（生成新代理）

当用户选择“挑战”，生成一个专门的挑战代理。

const challengeAgent = spawn_agent({
  message: `
## 任务分配

### 强制第一步（代理执行）
1. **读取角色定义**: ~/.codex/agents/cli-explore-agent.md（必须先读）
2. 读取: ${会话文件夹}/perspectives.json（要挑战的想法）

---

## 挑战上下文
主题: ${想法或主题}
要挑战的想法：
${selectedIdeas.map((idea, i) => `${i+1}. ${idea.标题}: ${idea.描述}`).join('
')}

## 魔鬼代言人任务
• 为每个想法识别3个最强反对意见
• 挑战核心假设
• 识别此想法失败的场景
• 考虑竞争/替代解决方案
• 评估这是否解决了正确的问题
• 评估挑战后的生存能力评级（1-5）

## 交付物
返回结构化挑战结果：
{
  challenges: [{
    idea: "...",
    objections: [],
    challenged_assumptions: [],
    failure_scenarios: [],
    alternatives: [],
    survivability_rating: 1-5,
    strengthened_version: "..."
  }]
}

## 成功标准
- [ ] 每个想法3+反对意见
- [ ] 假设明确挑战
- [ ] 分配生存能力评级
`
})

const result = wait({ ids: [challengeAgent], timeout_ms: 300000 })
close_agent({ id: challengeAgent })

步骤3.4: 合并多个想法（生成合并代理）

当用户选择“合并”，综合互补想法。

const mergeAgent = spawn_agent({
  message: `
## 任务分配

### 强制第一步（代理执行）
1. **读取角色定义**: ~/.codex/agents/cli-explore-agent.md（必须先读）
2. 读取: ${会话文件夹}/perspectives.json（来源想法）

---

## 合并上下文
主题: ${想法或主题}
要合并的想法：
${selectedIdeas.map((idea, i) => `
${i+1}. ${idea.标题} (${idea.source_perspective})
   ${idea.描述}
   优点: ${idea.strengths?.join(', ') || '不适用'}
`).join('
')}

## 合并任务
• 识别互补元素
• 解决矛盾
• 创建统一概念
• 保留每个的关键优点
• 描述合并方案
• 评估合并想法的可行性

## 交付物
写入: ${会话文件夹}/ideas/merged-idea-{n}.md

包括：
- 合并概念描述
- 取自每个来源想法的元素
- 解决的矛盾（或作为权衡注意）
- 新的综合优点
- 实现考虑

## 成功标准
- [ ] 连贯合并概念
- [ ] 来源归属明确
- [ ] 矛盾处理
`
})

const result = wait({ ids: [mergeAgent], timeout_ms: 300000 })
close_agent({ id: mergeAgent })

步骤3.5: 记录每轮

将每轮优化结果更新 brainstorm.md。

第N轮部分（第3-6轮）:

部分	内容
用户方向	采取的行动和选定想法
发现	新发现和澄清
想法更新	想法评分和状态变化
见解	关键学习和认识
下一步方向	建议的后续调查

文档标准:

清晰时间戳和采取的行动
基于证据的发现，带有代码引用
更新的想法排名和状态变化
假设变化的显式追踪
按探索向量组织

成功标准:

每轮处理用户反馈
brainstorm.md 更新所有优化轮
ideas/ 文件夹中的选定深度挖掘想法
所有生成的代理正确关闭
达到退出条件（用户选择收敛或最大轮数）

阶段4: 收敛与结晶

目标: 综合最终想法，生成结论和推荐，并提供下一步。

步骤4.1: 整合见解

从所有优化轮提取并综合发现到最终结论。

整合活动:

审查所有优化轮和累积发现
按评分、可行性和影响排名想法
识别前5个可行想法
提取关键学习和见解
生成带有理由的推荐

synthesis.json 结构:

session_id: 会话标识符
topic: 原始想法/主题
completed: 完成时间戳
total_rounds: 优化轮数
top_ideas[]: 前5个排名想法，带有评分和下一步
parked_ideas[]: 保留用于未来考虑的想法
key_insights[]: 头脑风暴过程中的关键学习
recommendations: 主要推荐和替代方案
follow_up[]: 建议下一步（实现、研究、验证）

想法格式:

title: 清晰描述性标题
description: 完整概念描述
source_perspective: 哪些视角贡献
score: 最终可行性评分（1-10）
novelty: 新颖性/创新评级（1-5）
feasibility: 实现可行性（1-5）
key_strengths: 主要优势和收益
main_challenges: 关键挑战和限制
next_steps: 推荐的后续行动

步骤4.2: 最终 brainstorm.md 更新

附加结论部分并最终化思考文档。

综合与结论部分:

执行摘要: 头脑风暴结果的高级概述
顶级想法: 带有描述和优点/挑战的排名列表
主要推荐: 最佳前进路径，带有清晰理由
替代方案: 其他可行选项，带有权衡分析
保留想法: 未来考虑，带有潜在触发因素
关键见解: 过程的重要学习

会话统计:

完成的总优化轮数
生成和评估的想法数
幸存挑战的想法数
使用的视角（创意、实用、系统化）
生成的工件

步骤4.3: 完成后的选项

基于头脑风暴结果向用户提供后续行动。

可用选项:

选项	目的	行动
创建实施计划	规划顶级想法的实现	启动 `workflow:lite-plan`
创建Issue	跟踪顶级想法以备后用	启动 `issue:new` 带想法
深入分析	详细分析顶级想法	启动 `workflow:analyze-with-file`
导出分享	生成可分享报告	创建格式化报告文档
完成	无进一步行动	结束工作流

成功标准:

synthesis.json 创建，包含完整综合
brainstorm.md 最终化，包含所有结论
向用户提供有意义的下一步选项
会话完成且所有工件可用

配置

头脑风暴维度参考

维度指导头脑风暴范围和焦点:

维度	关键词	最佳适用
技术	技术, technical, implementation, code	实现方法
用户体验	用户, user, experience, UI	面向用户的设计想法
业务	业务, business, value	业务模型创新
创新	创新, innovation, novel	突破性想法
可行性	可行, feasible, practical	现实方案
可扩展性	扩展, scale, growth	大规模解决方案
安全	安全, security, risk	安全考虑

头脑风暴模式

模式	时长	强度	子代理
创意	15-20分钟	高新颖性	1代理, 短超时
平衡	30-60分钟	混合	3并行代理
深度	1-2+小时	全面	3并行代理 + 深度优化

协作模式

模式	使用场景	描述
并行发散	新主题	所有视角通过并行子代理同时探索
顺序深度挖掘	有前景想法	`send_input` 到一个代理进行阐述，其他通过新代理批评
辩论模式	有争议方案	生成对立代理以支持/反对
综合模式	准备决定	生成综合代理整合所有视角的见解

上下文溢出保护

每代理限制:

主要分析输出: < 3000词
子文档（如果有）: < 2000词每个
最大子文档: 每视角5个

综合保护:

如果总分析 > 100KB，综合只读取主要分析文件（非子文档）
大想法自动拆分到 ideas/ 文件夹中的单独想法文档

恢复步骤:

检查代理输出是否截断或溢出
减少范围: 较少视角或更简单主题
使用结构化头脑风暴模式以获得更集中输出
将复杂主题拆分为多个会话

错误处理与恢复

情况	行动	恢复
子代理超时	检查 `results.timed_out`, 继续 `wait()` 或使用部分结果	减少范围, 使用2个视角而非3
代理过早关闭	无法恢复关闭代理	生成新代理，带先前上下文从 perspectives.json
并行代理部分失败	一些视角完成，一些失败	使用已完成结果，在综合中注明空白
send_input 到关闭代理	错误: 代理未找到	生成新代理，带先前发现作为上下文
无好想法	重新定义问题或调整约束	尝试新探索角度
用户失去兴趣	总结进展并提供休息	保存状态，保持代理活动以供恢复
视角冲突	呈现为权衡选项	让用户选择偏好方向
达到最大轮数	强制综合阶段	突出未解决问题
会话文件夹冲突	添加时间戳后缀	创建唯一文件夹

Codex 特定错误模式

// 安全并行执行带错误处理
try {
  const agentIds = perspectives.map(p => spawn_agent({ message: buildPrompt(p) }))

  const results = wait({ ids: agentIds, timeout_ms: 600000 })

  if (results.timed_out) {
    // 处理部分完成
    const completed = agentIds.filter(id => results.status[id].completed)
    const pending = agentIds.filter(id => !results.status[id].completed)

    // 选项1: 继续等待待处理代理
    // const moreResults = wait({ ids: pending, timeout_ms: 300000 })

    // 选项2: 使用部分结果
    // processPartialResults(completed, results)
  }

  // 处理所有结果
  processResults(agentIds, results)

} finally {
  // 即使错误，也总是清理
  agentIds.forEach(id => {
    try { close_agent({ id }) } catch (e) { /* 忽略 */ }
  })
}

迭代模式

第一次头脑风暴会话（并行模式）

用户发起: TOPIC="想法或主题"
   ├─ 无会话存在 → 新会话模式
   ├─ 解析主题并识别维度
   ├─ 与用户界定范围（焦点、深度、模式）
   ├─ 创建 brainstorm.md
   ├─ 将种子扩展为向量
   ├─ 收集代码库上下文
   │
   ├─ 执行并行视角探索：
   │   ├─ spawn_agent × 3（创意 + 实用 + 系统化）
   │   ├─ wait({ ids: [...] })  ← 真正的并行性
   │   └─ close_agent × 3
   │
   ├─ 聚合发现带综合
   └─ 进入多轮优化循环

继续现有会话

用户恢复: TOPIC="相同主题"
   ├─ 会话存在 → 继续模式
   ├─ 加载先前 brainstorm.md
   ├─ 加载 perspectives.json
   └─ 从最后优化轮恢复

优化循环（第3-6轮）

每轮：
   ├─ 展示当前发现和顶级想法
   ├─ 收集用户反馈（深度挖掘/发散/挑战/合并/收敛）
   ├─ 处理响应：
   │   ├─ 深度挖掘 → send_input 到活动代理或生成深度挖掘代理
   │   ├─ 发散 → 生成新代理带不同角度
   │   ├─ 挑战 → 生成挑战代理（魔鬼代言人）
   │   ├─ 合并 → 生成合并代理以综合
   │   └─ 收敛 → 退出循环进行综合
   ├─ wait({ ids: [...] }) 等待结果
   ├─ 更新 brainstorm.md
   └─ 重复直到用户选择收敛或达到最大轮数

代理生命周期管理

子代理生命周期：
   ├─ spawn_agent({ message }) → 创建带角色路径 + 任务
   ├─ wait({ ids, timeout_ms }) → 获取结果（获取输出的唯一方式）
   ├─ send_input({ id, message }) → 继续交互（如果未关闭）
   └─ close_agent({ id }) → 清理（必须做，无法恢复）

关键规则：
   ├─ 在完成代理前绝不关闭
   ├─ 总是使用 wait() 获取结果，而非 close_agent()
   ├─ 为并行代理批量等待：wait({ ids: [a, b, c] })
   └─ 考虑在优化期间保持代理活动以使用 send_input

完成流程

最终综合：
   ├─ 将所有发现整合为顶级想法
   ├─ 生成 synthesis.json
   ├─ 更新 brainstorm.md 带最终结论
   ├─ 关闭任何剩余活动代理
   ├─ 提供后续选项
   └─ 存档会话工件

最佳实践

开始头脑风暴前

清晰主题定义: 详细主题导致更好的维度识别
用户上下文: 理解偏好有助于引导头脑风暴强度
范围理解: 明确时间/范围期望设置正确探索级别

头脑风暴期间

审查视角: 在优化轮前检查所有三个视角
文档假设: 追踪您认为正确的以便后续纠正
使用继续模式: 恢复会话以基于先前探索构建
拥抱冲突: 视角冲突常揭示重要权衡
迭代深思: 每轮优化应显著推进想法

Codex 子代理最佳实践

角色路径，非内容: 在消息中传递 ~/.codex/agents/*.md 路径，让代理自行读取
并行视角: 为3个视角代理使用批量生成 + 等待
延迟 close_agent 用于优化: 保持视角代理活动以供 send_input 重用
批量等待: 为并行代理使用 wait({ ids: [a, b, c] })，而非顺序等待
处理超时: 检查 results.timed_out 并决定：继续等待或使用部分结果
显式清理: 完成时总是 close_agent，即使错误（使用 try/finally 模式）
send_input vs spawn: 同一上下文深度挖掘优先 send_input，新探索角度使用 spawn

文档实践

基于证据: 每个想法应引用代码库模式或可行性分析
视角多样性: 捕获所有三个视角的观点
时间线清晰性: 使用清晰时间戳以便追溯
演进追踪: 文档想法如何变化和演进
行动项: 生成具体、可实施的推荐
综合质量: 确保收敛/冲突主题清晰文档化

现在为主题执行文件辅助头脑风暴工作流: $TOPIC

名称: 文件辅助头脑风暴 描述: 通过并行子代理协作、想法扩展和文档化思想演进进行交互式头脑风暴。为 Codex 提供并行多视角分析。 参数提示: “TOPIC="<想法或主题>" [–perspectives=创意,实用,系统化] [–max-ideas=<n>]”

Codex 文件辅助头脑风暴工作流

快速开始

概述

输出结构

输出工件

阶段1: 种子理解

阶段2: 发散探索

阶段3: 交互式优化

阶段4: 收敛与结晶

实现细节

会话初始化

步骤0: 确定项目根目录

阶段1: 种子理解

步骤1.1: 解析种子并识别维度

步骤1.2: 角色选择

步骤1.3: 初始范围界定（仅新会话）

步骤1.4: 将种子扩展为探索向量

步骤1.5: 初始化 brainstorm.md

阶段2: 发散探索

步骤2.1: 代码库上下文收集

步骤2.2: 并行多视角分析

步骤2.3: 聚合多视角发现

步骤2.4: 更新 brainstorm.md

阶段3: 交互式优化

步骤3.1: 展示发现并收集用户方向

步骤3.2: 选定想法的深度挖掘（通过 send_input 或新代理）

步骤3.3: 魔鬼代言人挑战（生成新代理）

步骤3.4: 合并多个想法（生成合并代理）

步骤3.5: 记录每轮

阶段4: 收敛与结晶

步骤4.1: 整合见解

步骤4.2: 最终 brainstorm.md 更新

步骤4.3: 完成后的选项

配置

头脑风暴维度参考

头脑风暴模式

协作模式

上下文溢出保护

错误处理与恢复

Codex 特定错误模式

迭代模式

第一次头脑风暴会话（并行模式）

继续现有会话

优化循环（第3-6轮）

代理生命周期管理

完成流程

最佳实践

开始头脑风暴前

头脑风暴期间

Codex 子代理最佳实践

文档实践

名称: 文件辅助头脑风暴描述: 通过并行子代理协作、想法扩展和文档化思想演进进行交互式头脑风暴。为 Codex 提供并行多视角分析。参数提示: “TOPIC="<想法或主题>" [–perspectives=创意,实用,系统化] [–max-ideas=<n>]”