决策记录格式：

> **Decision**: [决策描述]
> - **Context**: [触发此决策的背景]
> - **Options considered**: [评估过的替代方案]
> - **Chosen**: [选择的方法] — **Reason**: [理由]
> - **Rejected**: [为什么其他选项被放弃]
> - **Impact**: [对分析方向/结论的影响]

关键发现记录格式：

> **Finding**: [内容]
> - **Confidence**: [高/中/低] — **Why**: [证据依据]
> - **Hypothesis Impact**: [确认/反驳/修改] 假设 "[名称]"
> - **Scope**: [影响哪些领域]

记录原则：

• 即时性：决策发生时立即记录，不要等到阶段结束时
• 完整性：捕获背景、选项、选择的方法、理由和被放弃的替代方案
• 可追溯性：后续阶段必须能够追溯决策的原因
• 深度：捕获推理过程和假设影响，而不仅仅是结果

自动模式

当使用 --yes 或 -y 时：自动确认探索决策，使用推荐的分析角度，跳过交互式范围界定。

快速开始

# 基本用法
/codex:analyze-with-file TOPIC="如何优化此项目的认证架构"

# 选择深度
/codex:analyze-with-file TOPIC="性能瓶颈分析" --depth=deep

# 继续现有会话
/codex:analyze-with-file TOPIC="认证架构" --continue

# 自动模式（跳过确认）
/codex:analyze-with-file -y TOPIC="缓存策略分析"

目标主题

$TOPIC

分析流程

Step 0: 会话设置
   ├─ 解析主题、标志（--depth、--continue、-y）
   ├─ 生成会话 ID：ANL-{slug}-{date}
   └─ 创建会话文件夹（或检测现有 → 继续模式）

Step 1: 主题理解
   ├─ 解析主题，识别分析维度
   ├─ 与用户进行初始范围界定（重点领域、视角、深度）
   └─ 初始化 discussion.md

Step 2: 探索（内联，无代理）
   ├─ 检测代码库 → 搜索相关模块、模式
   │   ├─ 运行 `ccw spec load --category exploration`（如果规范系统可用）
   │   └─ 使用 Grep、Glob、Read、mcp__ace-tool__search_context
   ├─ 多视角分析（如果选择，串行）
   │   ├─ 单一：综合分析
   │   └─ 多视角（≤4）：串行逐视角分析并综合
   ├─ 汇总发现 → explorations.json / perspectives.json
   ├─ 使用第 1 轮结果更新 discussion.md
   │   ├─ 用初始发现替换 ## Current Understanding
   │   └─ 更新 ## Table of Contents
   └─ 初始意图覆盖检查（早期漂移检测）

Step 3: 交互式讨论（多轮，最多 5 轮）
   ├─ 当前理解摘要（第 ≥2 轮，在发现之前）
   ├─ 呈现探索发现
   ├─ 收集用户反馈
   ├─ 处理响应：
   │   ├─ 深化 → 上下文驱动 + 启发式选项 → 更深层的内联分析
   │   ├─ 同意并建议 → 用户指导的探索
   │   ├─ 调整 → 调整重点后的新内联分析
   │   ├─ 提问 → 提供有证据的直接答案
   │   └─ 完成 → 退出循环进行综合
   ├─ 更新 discussion.md：
   │   ├─ 追加轮次详情 + 叙事综合
   │   ├─ 用最新状态替换 ## Current Understanding
   │   └─ 更新 ## Table of Contents
   ├─ 意图漂移检查（第 ≥2 轮，基于第 2 阶段的初始检查）
   └─ 重复直到用户选择完成或达到最大轮次

Step 4: 综合与结论
   ├─ 意图覆盖验证（强制关卡）
   ├─ 整合所有见解 → conclusions.json（每个推荐包含 steps[]）
   ├─ 使用最终综合更新 discussion.md
   ├─ 交互式推荐审查（逐推荐确认/修改/拒绝）
   └─ 提供选项：快速执行 / 创建问题 / 生成任务 / 导出 / 完成

Step 5: 执行（可选 - 用户选择，按复杂度路由）
   ├─ 简单（≤2 个推荐）：直接内联执行 → 在 discussion.md 中总结
   └─ 复杂（≥3 个推荐）：EXECUTE.md 管道
      ├─ 丰富推荐 → 生成 .task/TASK-*.json
      ├─ 执行前分析（依赖关系、文件冲突、执行顺序）
      ├─ 用户确认
      ├─ 直接内联执行（Read/Edit/Write/Grep/Glob/Bash）
      ├─ 记录事件 → execution-events.md，更新 execution.md
      └─ 报告完成摘要

配置

会话 ID 格式：ANL-{slug}-{YYYY-MM-DD}

• slug：小写，字母数字 + CJK 字符，最多 40 个字符
• date：YYYY-MM-DD (UTC+8)
• 自动检测继续：会话文件夹 + discussion.md 存在 → 继续模式

实现细节

会话初始化

Step 0: 初始化会话

const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()

// 解析标志
const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
const continueMode = $ARGUMENTS.includes('--continue')
const depthMatch = $ARGUMENTS.match(/--depth[=\s](quick|standard|deep)/)
const analysisDepth = depthMatch ? depthMatch[1] : 'standard'

// 提取主题
const topic = $ARGUMENTS.replace(/--yes|-y|--continue|--depth[=\s]\w+|TOPIC=/g, '').replace(/^["']|["']$/g, '').trim()

// 确定项目根目录
const projectRoot = Bash('git rev-parse --show-toplevel 2>/dev/null || pwd').trim()

const slug = topic.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-').substring(0, 40)
const dateStr = getUtc8ISOString().substring(0, 10)
const sessionId = `ANL-${slug}-${dateStr}`
const sessionFolder = `${projectRoot}/.workflow/.analysis/${sessionId}`

// 自动检测继续：会话文件夹 + discussion.md 存在 → 继续模式
// 如果继续 → 加载 discussion.md + explorations，从上一轮恢复
Bash(`mkdir -p ${sessionFolder}`)

阶段 1：主题理解

目标：解析主题，识别相关分析维度，与用户输入一起界定分析范围，并初始化讨论文档。

Step 1.1: 解析主题并识别维度

将主题关键词与分析维度匹配：

const ANALYSIS_DIMENSIONS = {
  architecture:    ['架构', 'architecture', 'design', 'structure', '设计', 'pattern'],
  implementation:  ['实现', 'implement', 'code', 'coding', '代码', 'logic'],
  performance:     ['性能', 'performance', 'optimize', 'bottleneck', '优化', 'speed'],
  security:        ['安全', 'security', 'auth', 'permission', '权限', 'vulnerability'],
  concept:         ['概念', 'concept', 'theory', 'principle', '原理', 'understand'],
  comparison:      ['比较', 'compare', 'vs', 'difference', '区别', 'versus'],
  decision:        ['决策', 'decision', 'choice', 'tradeoff', '选择', 'trade-off']
}

// 将主题文本与关键词列表匹配
// 如果匹配多个维度，则包含所有
// 如果没有匹配，默认为 "architecture" 和 "implementation"
const dimensions = identifyDimensions(topic, ANALYSIS_DIMENSIONS)

Step 1.2: 初始范围界定（仅新会话）

对于新会话，收集用户偏好（自动模式或继续模式中跳过）：

if (!autoYes && !continueMode) {
  // 1. 重点领域（多选）
  // 根据检测到的维度动态生成方向（参见维度-方向映射）
  const focusAreas = AskUserQuestion({
    questions: [{
      question: "选择分析重点领域：",
      header: "Focus",
      multiSelect: true,
      options: generateFocusOptions(dimensions) // 基于维度动态生成
    }]
  })

  // 2. 分析视角（多选，最多 4 个）
  const perspectives = AskUserQuestion({
    questions: [{
      question: "选择分析视角（单一 = 专注，多视角 = 更广覆盖）：",
      header: "Perspectives",
      multiSelect: true,
      options: [
        { label: "Technical", description: "实现模式、代码结构、技术可行性" },
        { label: "Architectural", description: "系统设计、可扩展性、组件交互" },
        { label: "Security", description: "漏洞、认证、访问控制" },
        { label: "Performance", description: "瓶颈、优化、资源利用" }
      ]
    }]
  })

  // 3. 分析深度（单选，除非已设置 --depth）
  // Quick：表层 | Standard：中等深度 | Deep：全面
}

Step 1.3: 初始化 discussion.md

const discussionMd = `# Analysis Discussion

**Session ID**: ${sessionId}
**Topic**: ${topic}
**Started**: ${getUtc8ISOString()}
**Dimensions**: ${dimensions.join(', ')}
**Depth**: ${analysisDepth}

## Table of Contents
<!-- TOC: 每轮/阶段后自动更新。链接到主要章节。 -->
- [Analysis Context](#analysis-context)
- [Current Understanding](#current-understanding)
- [Discussion Timeline](#discussion-timeline)
- [Decision Trail](#decision-trail)

## Current Understanding
<!-- REPLACEABLE BLOCK: 每轮后用最新整合理解覆盖（非追加）。
     遵循整合规则：提升已确认的见解，跟踪更正，专注于当前状态。 -->

> 探索后填充。

## Analysis Context
- Focus areas: ${focusAreas.join(', ')}
- Perspectives: ${selectedPerspectives.map(p => p.name).join(', ')}
- Depth: ${analysisDepth}

## Initial Questions
${generateInitialQuestions(topic, dimensions).map(q => `- ${q}`).join('\n')}

## Initial Decisions
> 记录为什么选择这些维度和重点领域。

---

## Discussion Timeline

> 随着分析进展，轮次将追加在下方。
> 每轮必须包含一个 Decision Log 部分，用于记录所做的任何决策。

---

## Decision Trail

> 整合所有轮次的关键决策（在第 4 阶段填充）。
`
Write(`${sessionFolder}/discussion.md`, discussionMd)

成功标准：

• 创建会话文件夹并初始化 discussion.md
• 识别分析维度
• 捕获用户偏好（重点、视角、深度）
• 记录初始决策：维度选择理由、排除维度的原因、用户偏好意图

阶段 2：探索

目标：收集代码库上下文并执行分析以建立理解。所有探索均内联完成——无代理委托。

Step 2.1: 检测代码库并探索

使用可用工具直接搜索代码库：

const hasCodebase = Bash(`
  test -f package.json && echo "nodejs" ||
  test -f go.mod && echo "golang" ||
  test -f Cargo.toml && echo "rust" ||
  test -f pyproject.toml && echo "python" ||
  test -f pom.xml && echo "java" ||
  test -d src && echo "generic" ||
  echo "none"
`).trim()

if (hasCodebase !== 'none') {
  // 1. 读取项目元数据（如果存在）
  //    - 运行 `ccw spec load --category exploration`（加载项目规范）
  //    - .workflow/specs/*.md（项目约定）

  // 2. 搜索代码库中的相关内容
  //    使用：Grep、Glob、Read 或 mcp__ace-tool__search_context
  //    基于主题关键词和识别的维度进行搜索
  //    重点关注：
  //      - 与主题相关的模块/组件
  //      - 现有模式和代码结构
  //      - 集成点和约束
  //      - 相关配置和依赖

  // 3. 写入发现
  Write(`${sessionFolder}/exploration-codebase.json`, JSON.stringify({
    project_type: hasCodebase,
    relevant_files: [...],    // [{path, relevance, summary}]
    patterns: [...],          // [{pattern, files, description}]
    constraints: [...],       // 发现的架构约束
    integration_points: [...], // [{location, description}]
    key_findings: [...],      // 代码搜索的主要见解
    _metadata: { timestamp: getUtc8ISOString(), exploration_scope: '...' }
  }, null, 2))
}

Step 2.2: 多视角分析（如果选择）

从每个选定的视角分析主题。所有分析均由 AI 内联完成。

单一视角（默认）：

// 跨所有识别的维度进行综合分析
// 使用 exploration-codebase.json 作为上下文
// 重点关注：模式、反模式、潜在问题、机会

const findings = {
  session_id: sessionId,
  timestamp: getUtc8ISOString(),
  topic: topic,
  dimensions: dimensions,
  sources: [...],            // [{type, file, summary}]
  key_findings: [...],       // 主要见解
  discussion_points: [...],  // 用于用户参与的问题
  open_questions: [...]      // 未解决的问题
}
Write(`${sessionFolder}/explorations.json`, JSON.stringify(findings, null, 2))

多视角（2-4 个视角，串行）：

// 串行分析每个视角
// 对于每个视角：
//   1. 将搜索/分析重点放在该视角的关注领域
//   2. 生成特定视角的见解
//   3. 写入单独的发现

selectedPerspectives.forEach(perspective => {
  // 从该视角的角度分析
  // 使用 exploration-codebase.json + 维度重点
  // 写入到 explorations/{perspective.name}.json
  Write(`${sessionFolder}/explorations/${perspective.name}.json`, JSON.stringify({
    perspective: perspective.name,
    relevant_files: [...],
    patterns: [...],
    key_findings: [...],
    perspective_insights: [...],
    open_questions: [...],
    _metadata: { timestamp: getUtc8ISOString() }
  }, null, 2))
})

Step 2.3: 汇总发现

// 单一视角 → explorations.json 已写入
// 多视角 → 综合到 perspectives.json

if (selectedPerspectives.length > 1) {
  const synthesis = {
    session_id: sessionId,
    timestamp: getUtc8ISOString(),
    topic: topic,
    dimensions: dimensions,

    // 各视角的发现
    perspectives: selectedPerspectives.map(p => ({
      name: p.name,
      findings: readJson(`${sessionFolder}/explorations/${p.name}.json`).key_findings,
      insights: readJson(`${sessionFolder}/explorations/${p.name}.json`).perspective_insights,
      questions: readJson(`${sessionFolder}/explorations/${p.name}.json`).open_questions
    })),

    // 跨视角综合
    synthesis: {
      convergent_themes: [...],   // 所有视角一致同意的内容
      conflicting_views: [...],   // 视角不同的地方
      unique_contributions: [...]  // 特定视角的独特见解
    },

    aggregated_findings: [...],   // 跨所有视角的主要见解
    discussion_points: [...],     // 用于用户参与的问题
    open_questions: [...]         // 未解决的问题
  }
  Write(`${sessionFolder}/perspectives.json`, JSON.stringify(synthesis, null, 2))
}

Step 2.4: 更新 discussion.md

使用探索结果追加第 1 轮：

单一视角第 1 轮：

• 分析的来源（文件、模式）
• 带有关键发现和证据
• 供用户讨论的要点
• 开放性问题

多视角第 1 轮：

• 各视角摘要（简要）
• 综合部分：
  • 趋同主题（所有视角一致同意的内容）
  • 冲突观点（视角不同的地方）
  • 独特贡献（来自特定视角的见解）
• 讨论要点
• 开放性问题

Step 2.5: 初始意图覆盖检查

在进入第 3 阶段之前执行第一次意图覆盖检查：

// 从 discussion.md 头部重新读取原始用户意图/分析上下文
// 将每个意图项与第 1 轮发现进行比对
// 追加到 discussion.md：

appendToDiscussion(`
#### Initial Intent Coverage Check (Post-Exploration)
${originalIntents.map((intent, i) => {
  const status = assessCoverage(intent, explorationFindings)
  return `- ${status.icon} Intent ${i+1}: ${intent} — ${status.detail}`
}).join('\n')}

> 接下来的讨论将重点关注未覆盖 (❌) 和进行中 (🔄) 的意图。
`)

// 在第 3 阶段开始时呈现给用户，以便早期纠正方向

成功标准：

• 创建包含代码库上下文的 exploration-codebase.json（如果代码库存在）
• 创建包含发现的 explorations.json（单一）或 perspectives.json（多视角）
• 使用第 1 轮结果更新 discussion.md
• 完成初始意图覆盖检查——在交互轮次之前进行早期漂移检测
• 准备好进行交互式讨论
• 记录关键发现，包含证据引用和置信度
• 记录探索决策（为什么选择某些视角/搜索策略）

阶段 3：交互式讨论

目标：通过多轮用户指导的讨论循环迭代地完善理解。

最大轮次：5 轮讨论（如果用户表示分析完成，可以提前退出）

Step 3.1: 当前理解摘要并呈现发现

当前理解摘要（第 ≥2 轮，在呈现新发现之前）：

• 生成 1-2 句话的已建立共识和上一轮方向的回顾
• 示例："到目前为止，我们已确认 [established facts]。上一轮 [key action/direction]。现在，这是新一轮的发现："
• 目的：重置上下文，防止认知过载，使增量进展可见

显示当前理解并收集用户方向：

// 第 ≥2 轮：首先显示当前理解摘要
if (round >= 2) {
  // 从上一轮的叙事综合中生成 1-2 句话的回顾
  // 在呈现新发现之前显示
}

// 显示来自 explorations.json 或 perspectives.json 的当前发现摘要
// 显示要点、讨论点、开放性问题

if (!autoYes) {
  const feedback = AskUserQuestion({
    questions: [{
      question: `Analysis round ${round}: Feedback on current findings?`,
      header: "Direction",
      multiSelect: false,
      options: [
        { label: "Deepen", description: "分析方向正确，进行更深入调查" },
        { label: "Agree & Suggest", description: "同意方向，但有特定的下一步想法" },
        { label: "Adjust Direction", description: "需要不同的理解或重点" },
        { label: "Specific Questions", description: "有具体问题要问" },
        { label: "Analysis Complete", description: "已获得足够信息，进行综合" }
      ]
    }]
  })
}

Step 3.2: 处理用户响应

记录检查点：无论用户选择哪个选项，以下内容必须记录到 discussion.md：

• 用户的原始选择和表达
• 此选择对分析方向的影响
• 如果方向改变，记录完整的决策记录

深化——在当前方向继续分析：

// 动态生成深化方向选项：
// - 2-3 个上下文驱动的选项，来自：未解决的问题、低置信度的发现、未探索的维度
// - 1-2 个打破当前框架的启发式选项：
//   例如，"compare with best practices in [related domain]",
//   "analyze under extreme load scenarios",
//   "review from security audit perspective",
//   "explore simpler architectural alternatives"
// 使用生成的选项询问用户（单选）
// 通过内联搜索工具执行选定的方向
// 将新发现合并到 explorations.json
// 记录：哪些假设被确认，用于深入探索的具体角度

同意并建议——用户提供具体的下一步：

// 询问用户的具体方向（自由文本输入）
const userSuggestion = AskUserQuestion({
  questions: [{
    question: "请描述您希望下一步深入的方向:",
    header: "Your Direction",
    multiSelect: false,
    options: [/* user will select "Other" to type free text */]
  }]
})
// 通过内联搜索工具执行用户的具体方向
// 记录：用户驱动的探索理由和发现

调整方向——新的重点领域：

// 询问用户调整后的重点
const adjustedFocus = AskUserQuestion({
  questions: [{
    question: "What should the new analysis focus be?",
    header: "New Focus",
    multiSelect: false,
    options: [
      { label: "Code Details", description: "更深入地了解实现细节" },
      { label: "Architecture", description: "更广泛的结构分析" },
      { label: "Best Practices", description: "行业标准和推荐" }
    ]
  }]
})

// 使用内联搜索从调整后的视角进行分析
// 将新见解与先前的分析进行比较
// 识别遗漏了什么以及原因
// 使用调整后的发现更新 explorations.json
// 记录决策：方向调整的触发原因、旧方向 vs 新方向、预期影响

具体问题——直接回答：

// 通过 AskUserQuestion 捕获用户问题（文本输入）
// 基于代码库搜索和分析回答每个问题
// 提供证据和文件引用
// 为每个答案评定置信度（高/中/低）
// 在 discussion.md 中记录问答
// 记录：问题揭示的知识差距、答案带来的新理解

分析完成——退出循环，进入第 4 阶段。

// 记录：为什么在此轮结束（信息足够 / 范围完全聚焦 / 用户满意）

Step 3.3: 记录每一轮

使用每轮讨论的结果更新 discussion.md：

追加到讨论时间线：

替换（非追加）以下章节：

轮次叙事综合（每轮更新后追加）：

### Round N: Narrative Synthesis
**起点**: 基于上一轮的 [conclusions/questions]，本轮从 [starting point] 切入。
**关键进展**: [New findings] [confirmed/refuted/modified] 了之前关于 [hypothesis] 的理解。
**决策影响**: 用户选择 [feedback type]，导致分析方向 [adjusted/deepened/maintained]。
**当前理解**: 经过本轮，核心认知更新为 [updated understanding]。
**遗留问题**: [remaining questions driving next round]

文档标准：

• 每轮有清晰的时间戳
• 基于证据的发现，包含文件引用和置信度
• 明确跟踪假设更正
• 按分析维度组织
• 叙事综合将各轮连接成连贯的理解演变过程

Step 3.4: 意图漂移检查（每轮 ≥2，基于第 2 阶段的初始检查）

从 discussion.md 头部重新读取"用户意图"/"分析上下文"。与第 2 阶段的初始意图覆盖检查进行比较。对于每个原始意图项，检查更新后的覆盖状态：

#### Intent Coverage Check
- ✅ Intent 1: [addressed in Round N]
- 🔄 Intent 2: [in-progress, current focus]
- ⚠️ Intent 3: [implicitly absorbed by X — needs explicit confirmation]
- ❌ Intent 4: [not yet discussed]

• 如果任何项是"隐式吸收"（⚠️），在 discussion.md 中明确注明——吸收 ≠ 已解决
• 如果存在 ❌ 或 ⚠️ 项 → 主动呈现给用户，在下一轮开始时："以下原始意图尚未充分覆盖：[list]。是否需要调整优先级？"

成功标准：

• 每轮处理用户反馈
• 使用所有讨论轮次更新 discussion.md
• 记录并更正假设
• 达到退出条件（用户选择完成或达到最大轮次）
• 使用决策记录格式记录所有决策点
• 记录方向变更，包含前后对比和理由

阶段 4：综合与结论

目标：整合所有讨论轮次的见解，生成结论和推荐。

Step 4.0: 意图覆盖验证（综合前的强制关卡）

从 discussion.md 头部重新读取所有原始用户意图/分析上下文项。对于每个项，确定覆盖状态：

• ✅ 已解决：明确讨论并以清晰的设计/推荐结束
• 🔀 已转化：原始意图演变为不同的解决方案——记录转化链
• ⚠️ 已吸收：被更广泛的解决方案隐式覆盖——标记为需要明确确认
• ❌ 遗漏：未讨论——必须现在解决或明确列为超出范围并说明原因

将"意图覆盖矩阵"写入 discussion.md：

### Intent Coverage Matrix
| # | Original Intent | Status | Where Addressed | Notes |
|---|----------------|--------|-----------------|-------|
| 1 | [intent text] | ✅ Addressed | Round N, Conclusion #M | |
| 2 | [intent text] | 🔀 Transformed | Round N → Round M | Original: X → Final: Y |
| 3 | [intent text] | ❌ Missed | — | Reason for omission |

关卡：如果任何项是 ❌ 遗漏，必须：

• (a) 在继续之前添加专门的讨论轮次来解决它，或
• (b) 明确与用户确认它被有意推迟

Step 4.1: 整合见解

const conclusions = {
  session_id: sessionId,
  topic: topic,
  completed: getUtc8ISOString(),
  total_rounds: roundCount,
  summary: '...',                    // 执行摘要
  key_conclusions: [                 // 主要结论
    { point: '...', evidence: '...', confidence: 'high|medium|low' }
  ],
  recommendations: [                 // 可操作的推荐
    {
      action: '...',                    // 做什么（祈使动词 + 目标）
      rationale: '...',                 // 为什么这很重要
      priority: 'high|medium|low',
      evidence_refs: ['file:line', ...], // 支持证据位置
      steps: [                          // 用于执行的细分子步骤
        { description: '...', target: 'file/module', verification: 'how to verify done' }
      ],
      review_status: 'accepted|modified|rejected|pending' // 在第 4 阶段审查期间设置
    }
  ],
  open_questions: [...],             // 未解决的问题
  follow_up_suggestions: [           // 后续步骤
    { type: 'issue|task|research', summary: '...' }
  ],
  decision_trail: [                  // 所有阶段整合的决策
    { round: 1, decision: '...', context: '...', options_considered: [...], chosen: '...', rejected_reasons: '...', reason: '...', impact: '...' }
  ],
  narrative_trail: [                 // 来自 Step 3.3 叙事综合
    { round: 1, starting_point: '...', key_progress: '...', hypothesis_impact: '...', updated_understanding: '...', remaining_questions: '...' }
  ],
  intent_coverage: [                 // 来自 Step 4.0
    { intent: '...', status: 'addressed|transformed|absorbed|missed', where_addressed: '...', notes: '...' }
  ]
}
Write(`${sessionFolder}/conclusions.json`, JSON.stringify(conclusions, null, 2))

Step 4.2: 最终 discussion.md 更新

追加结论部分并完成：

综合与结论部分：

• 执行摘要：分析发现的概述
• 关键结论：按置信度排序，包含支持证据
• 推荐：优先排序的可操作项，包含理由
• 剩余开放性问题：未来工作的未解决项

当前理解（最终）部分：

决策轨迹部分：

会话统计：总讨论轮次、关键发现数量、覆盖的维度、生成的工件、决策数量。

Step 4.3: 交互式推荐审查（自动模式中跳过）

在继续之前，逐一审查每个推荐以获取用户确认：

// 按优先级排序推荐：高 → 中 → 低
const sortedRecs = conclusions.recommendations.sort(byPriority)

for (const [index, rec] of sortedRecs.entries()) {
  // 1. 呈现推荐详情
  // 显示：action、rationale、priority、steps[]（带目标和验证的编号子步骤）

  // 2. 收集用户审查
  const review = AskUserQuestion({
    questions: [{
      question: `Recommendation #${index + 1}: "${rec.action}" (${rec.priority} priority, ${rec.steps.length} steps). Your decision:`,
      header: `Rec #${index + 1}`,
      multiSelect: false,
      options: [
        { label: "Accept", description: "按原样接受此推荐" },
        { label: "Modify", description: "调整范围、步骤或优先级" },
        { label: "Reject", description: "移除此推荐" },
        { label: "Accept All Remaining", description: "跳过剩余推荐的审查" }
      ]
    }]
  })

  // 3. 处理审查决策
  // Accept → rec.review_status = "accepted"
  // Modify → 通过自由文本收集修改 → 更新 rec → rec.review_status = "modified"
  // Reject → 收集原因 → rec.review_status = "rejected"
  // Accept All Remaining → 将所有剩余标记为 "accepted"，中断循环

  // 4. 将审查决策记录到 discussion.md 的 Decision Log
  // 5. 更新 conclusions.json
}

// 显示审查摘要：
// Accepted: N | Modified: N | Rejected: N
// 只有已接受/修改的推荐进入下一步

审查摘要格式（追加到 discussion.md）：

### Recommendation Review Summary
| # | Action | Priority | Steps | Review Status | Notes |
|---|--------|----------|-------|---------------|-------|
| 1 | [action] | high | 3 | ✅ Accepted | |
| 2 | [action] | medium | 2 | ✏️ Modified | [modification notes] |
| 3 | [action] | low | 1 | ❌ Rejected | [reason] |

Step 4.4: 完成后选项

复杂度评估——确定是否值得生成 .task/*.json：

// 评估推荐复杂度以决定可用选项
const recs = conclusions.recommendations || []
const complexity = assessComplexity(recs)

function assessComplexity(recs) {
  if (recs.length === 0) return 'none'
  if (recs.length <= 2 && recs.every(r => r.priority === 'low')) return 'simple'
  if (recs.length >= 3 || recs.some(r => r.priority === 'high')) return 'complex'
  return 'moderate'  // 1-2 个中等优先