sillyspec 3.19.2 → 3.20.1

package/src/run.js

@@ -113,6 +113,9 @@ import { checkTransition, runValidators } from './stage-contract.js'
 import { buildExecuteSteps } from './stages/execute.js'
 import { buildPlanSteps } from './stages/plan.js'
 import { formatExecuteSummary } from './worktree-apply.js'
+import { classifyChange } from './classify-change.js'
+import { detectRiskProfile } from './change-risk-profile.js'
+import { definition as brainstormAutoDef } from './stages/brainstorm-auto.js'
 
 /**
  * 从 _module-map.yaml 读取模块上下文索引
@@ -772,19 +775,19 @@ async function outputStep(stageName, stepIndex, steps, cwd, changeName, dbProjec
     }
   }
 
-  // Execute: 注入 currentExecuteRunId（从 runtime 标记文件读取）
+  // Execute: 注入 currentExecuteRunId（从变更专属标记文件读取）
   if (stageName === 'execute' && promptText.includes('{EXECUTE_RUN_ID}')) {
-    const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
-    const runIdFile = join(execSpecBase, '.runtime', 'current-execute-run-id')
     let runId = ''
+    const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
+    const runIdFile = join(execSpecBase, '.runtime', `current-execute-run-id-${effectiveChange}`)
     try {
       if (existsSync(runIdFile)) {
         runId = readFileSync(runIdFile, 'utf8').trim()
       }
     } catch {}
     if (!runId) {
-      const { generateExecuteRunId, getLatestExecuteRunId } = await import('./task-review.js')
- runId = getLatestExecuteRunId(join(execSpecBase, '.runtime')) || generateExecuteRunId()
+      const { generateExecuteRunId } = await import('./task-review.js')
+      runId = generateExecuteRunId()
     }
     promptText = promptText.replace(/\{EXECUTE_RUN_ID\}/g, runId)
   }
@@ -1067,6 +1070,19 @@ async function executeScanPostcheck(cwd, platformOpts, scanProfile) {
   }
 }
 
+/**
+ * Plan postcheck 的执行代理：委托给 plan-postcheck.js 模块
+ */
+async function executePlanPostcheck(cwd, platformOpts) {
+  const { executePlanPostcheck: runPostcheck } = await import('./stages/plan-postcheck.js')
+  const { resolveChangeDir } = await import('./modules.js')
+  await runPostcheck({
+    cwd,
+    specRoot: platformOpts?.specRoot,
+    resolveChangeDir
+  })
+}
+
 /**
  * sillyspec run <stage> 主命令
  */
@@ -1087,6 +1103,19 @@ export async function runCommand(args, cwd, specDir = null) {
     process.exit(1)
   }
 
+  // ── cwd 纠正：向上查找真实项目根 ──
+  // 防止多 project 工作区中 cwd 停在子目录（如 backend/）时
+  // 状态写入子目录下误建的 .sillyspec，导致状态分裂
+  if (!specDir) {
+    const resolvedRoot = resolveSpecDir(cwd)
+    if (resolvedRoot && resolvedRoot !== join(cwd, '.sillyspec')) {
+      const realRoot = dirname(resolvedRoot)
+      if (realRoot !== cwd) {
+        cwd = realRoot
+      }
+    }
+  }
+
   // 平台模式参数（供 SillyHub 等平台调用）
   // --spec-dir 是统一参数名，--spec-root 保留为向后兼容别名
   const getFlagValue = (name) => {
@@ -1257,7 +1286,7 @@ export async function runCommand(args, cwd, specDir = null) {
     '--spec-dir', '--spec-root', '--runtime-root', '--workspace-id', '--scan-run-id',
     '--files', '--allow-new', '--force-baseline', '--force-rescan',
     '--json', '--dir', '--help',
-    '--reopen', '--from-step',
+    '--reopen', '--from-step', '--mode',
   ])
   for (let i = 0; i < flags.length; i++) {
     const f = flags[i]
@@ -1314,7 +1343,7 @@ export async function runCommand(args, cwd, specDir = null) {
 
   // -- auto 模式：自动推进所有流程阶段
   if (stageName === 'auto') {
-    return await runAutoMode(pm, progress, cwd, flags, effectiveChange)
+    return await runAutoMode(pm, progress, cwd, flags, effectiveChange, platformOpts)
   }
 
   // --change 只作为变更名标识，不再拦截流程
@@ -1502,16 +1531,24 @@ async function runStage(pm, progress, stageName, cwd, changeName, skipApproval =
     }
   }
 
-  // ── execute 阶段启动时固定 executeRunId ──
+  // ── execute 阶段启动时固定 executeRunId（绑定变更名，避免跨变更复用） ──
   let currentExecuteRunId = null
   if (stageName === 'execute') {
-    const { generateExecuteRunId, getLatestExecuteRunId } = await import('./task-review.js')
+    const { generateExecuteRunId } = await import('./task-review.js')
     const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
     const runtimeRoot = join(execSpecBase, '.runtime')
-    currentExecuteRunId = getLatestExecuteRunId(runtimeRoot) || generateExecuteRunId()
-    // 写入 runtime 标记文件，确保整个 execute 生命周期内 runId 不变
+    const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
     mkdirSync(runtimeRoot, { recursive: true })
-    writeFileSync(join(runtimeRoot, 'current-execute-run-id'), currentExecuteRunId + '\n')
+    // 优先读取已有的变更专属标记文件
+    try {
+      if (existsSync(runIdFile)) {
+        currentExecuteRunId = readFileSync(runIdFile, 'utf8').trim()
+      }
+    } catch {}
+    if (!currentExecuteRunId) {
+      currentExecuteRunId = generateExecuteRunId()
+      writeFileSync(runIdFile, currentExecuteRunId + '\n')
+    }
   }
 
   // 自动探测 currentChange
@@ -1686,6 +1723,8 @@ async function runStage(pm, progress, stageName, cwd, changeName, skipApproval =
         await executeScanPreflight(cwd, platformOpts, scanProfile)
       } else if (cliAction === 'scanPostcheck') {
         await executeScanPostcheck(cwd, platformOpts, scanProfile)
+      } else if (cliAction === 'planPostcheck') {
+        await executePlanPostcheck(cwd, platformOpts)
       }
       stageData.steps[currentIdx].status = 'completed'
       stageData.steps[currentIdx].completedAt = new Date().toLocaleString('zh-CN', { hour12: false })
@@ -2171,29 +2210,43 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
     }
   }
 
-  // plan 阶段 "展开任务" 完成后，动态插入任务蓝图协调器步骤
-  if (stageName === 'plan' && steps[currentIdx]?.name === '展开任务并分组') {
-    const changeDir = resolveChangeDir(cwd, progress)
-    if (changeDir) {
-      const planFile = join(changeDir, 'plan.md')
-      if (existsSync(planFile)) {
-        const planContent = readFileSync(planFile, 'utf8')
-        const { buildPlanSteps, fixedPrefix, fixedSuffix } = await import('./stages/plan.js')
-        const fullSteps = buildPlanSteps(changeDir, planContent)
-        const prefixLen = fixedPrefix.length
-        const suffixLen = fixedSuffix.length
-        const coordinatorSteps = fullSteps.slice(prefixLen, suffixLen > 0 ? -suffixLen : undefined)
-        if (coordinatorSteps.length > 0) {
-          for (let i = 0; i < coordinatorSteps.length; i++) {
-            steps.splice(currentIdx + 1 + i, 0, {
-              name: coordinatorSteps[i].name,
-              status: 'pending',
-              prompt: coordinatorSteps[i].prompt,
-              outputHint: coordinatorSteps[i].outputHint,
-              optional: coordinatorSteps[i].optional
-            })
+  // plan 阶段 "generate_plan" 完成后，动态插入任务蓝图 + postcheck 步骤
+  // 使用稳定 id 匹配，不依赖中文标题
+  if (stageName === 'plan') {
+    const currentStepDef = defStepsForCurrent?.[currentIdx]
+    const currentStepEntry = steps[currentIdx]
+    const stepId = currentStepDef?.id || currentStepEntry?.id || currentStepEntry?._stepId
+    if (stepId === 'generate_plan') {
+      const changeDir = resolveChangeDir(cwd, progress)
+      if (changeDir) {
+        const planFile = join(changeDir, 'plan.md')
+        if (existsSync(planFile)) {
+          const planContent = readFileSync(planFile, 'utf8')
+          const { buildPlanSteps, fixedPrefix, fixedSuffix } = await import('./stages/plan.js')
+          const fullSteps = buildPlanSteps(changeDir, planContent)
+          const prefixLen = fixedPrefix.length
+          const suffixLen = fixedSuffix.length
+          // 新结构：[...fixedPrefix, coordinatorStep?, postcheckStep?]
+          // fixedSuffix 为空，所以 coordinator + postcheck 都在 prefix 之后
+          const coordinatorSteps = fullSteps.slice(prefixLen, suffixLen > 0 ? -suffixLen : undefined)
+          if (coordinatorSteps.length > 0) {
+            for (let i = 0; i < coordinatorSteps.length; i++) {
+              const stepDef = coordinatorSteps[i]
+              const stepEntry = {
+                id: stepDef.id,
+                name: stepDef.name,
+                status: 'pending',
+                prompt: stepDef.prompt || '',
+                outputHint: stepDef.outputHint,
+                optional: stepDef.optional
+              }
+              // 传递 noAI / _cliAction 属性
+              if (stepDef.noAI) stepEntry.noAI = true
+              if (stepDef._cliAction) stepEntry._cliAction = stepDef._cliAction
+              steps.splice(currentIdx + 1 + i, 0, stepEntry)
+            }
+            console.log(`  📝 已动态插入 ${coordinatorSteps.length} 个步骤（${coordinatorSteps.map(s => s.name).join(', ')}）`)
           }
-          console.log(`  📝 已动态插入 ${coordinatorSteps.length} 个任务蓝图步骤（${coordinatorSteps.map(s => s.name).join(', ')}）`)
         }
       }
     }
@@ -2625,7 +2678,7 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
       // ── Execute Task Review Gate：所有 task 必须有 review.json 且 verdict 通过 ──
       if (stageName === 'execute') {
         try {
-          const { validateTaskReviews, printReviewResult, writeVerifyRequiredEvidence, getLatestExecuteRunId, generateExecuteRunId } = await import('./task-review.js')
+          const { validateTaskReviews, printReviewResult, writeVerifyRequiredEvidence } = await import('./task-review.js')
           const effectiveSpecBase = platformOpts?.specRoot || specBase
           const planFile = resolveChangeDir(cwd, progress, platformOpts?.specRoot)
           const planPath = planFile ? join(planFile, 'plan.md') : null
@@ -2634,9 +2687,16 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
             const planContent = readFileSync(planPath, 'utf8')
             const runtimeRoot = join(effectiveSpecBase, '.runtime')
 
-            // 找到 execute run id：优先从 runtime 目录找最新，否则生成新的
-            let executeRunId = getLatestExecuteRunId(runtimeRoot)
+            // execute run id：从变更专属标记文件读取
+            const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
+            let executeRunId = ''
+            try {
+              if (existsSync(runIdFile)) {
+                executeRunId = readFileSync(runIdFile, 'utf8').trim()
+              }
+            } catch {}
             if (!executeRunId) {
+              const { generateExecuteRunId } = await import('./task-review.js')
               executeRunId = generateExecuteRunId()
             }
 
@@ -2974,14 +3034,28 @@ async function resetStage(pm, progress, stageName, cwd, changeName, platformOpts
 /**
  * auto 模式：自动推进 brainstorm → plan → execute → verify
  */
-async function runAutoMode(pm, progress, cwd, flags, changeName) {
-  const flowStages = ['brainstorm', 'plan', 'execute', 'verify']
+async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts = {}) {
+  const flowStages = ['brainstorm', 'plan', 'execute', 'verify', 'archive']
   const isDone = flags.includes('--done')
   const outputIdx = flags.indexOf('--output')
   const outputText = outputIdx !== -1 && flags[outputIdx + 1] ? flags[outputIdx + 1] : null
   const inputIdx = flags.indexOf('--input')
   const inputText = inputIdx !== -1 && flags[inputIdx + 1] ? flags[inputIdx + 1] : null
   const skipApproval = flags.includes('--skip-approval')
+  const explicitMode = (() => {
+    const m = flags.indexOf('--mode')
+    return m !== -1 && flags[m + 1] ? flags[m + 1] : null
+  })()
+  const specBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
+
+  // Helper: 在 auto 模式下获取步骤定义
+  const getAutoSteps = async (stage) => {
+    if (stage === 'brainstorm') {
+      return brainstormAutoDef.steps
+    }
+    return getStageSteps(stage, cwd, progress, platformOpts?.specRoot || null)
+  }
+
   const nextInFlow = (stage) => {
     const i = flowStages.indexOf(stage)
     return i >= 0 && i < flowStages.length - 1 ? flowStages[i + 1] : null
@@ -2990,6 +3064,24 @@ async function runAutoMode(pm, progress, cwd, flags, changeName) {
   const ensureAutoStage = async (stage) => {
     const stageChanged = progress.currentStage !== stage
     progress.currentStage = stage
+    // Auto 模式下 brainstorm 使用 artifact-first 步骤
+    if (stage === 'brainstorm') {
+      const existingSteps = progress.stages?.brainstorm?.steps
+      const isAutoModeSteps = existingSteps?.length === 4 && existingSteps?.[0]?.name === '状态检查与上下文加载'
+      if (!isAutoModeSteps) {
+        if (!progress.stages) progress.stages = {}
+        progress.stages.brainstorm = {
+          status: 'in-progress',
+          startedAt: new Date().toLocaleString('zh-CN', { hour12: false }),
+          completedAt: null,
+          steps: brainstormAutoDef.steps.map(s => ({ name: s.name, status: 'pending' }))
+        }
+        await pm._write(cwd, progress, changeName)
+        triggerSync(cwd, changeName, platformOpts)
+        progress = await pm.read(cwd, changeName)
+        return progress
+      }
+    }
     const changed = await ensureStageSteps(progress, stage, cwd)
     if (stageChanged || changed) {
       await pm._write(cwd, progress, changeName)
@@ -2999,6 +3091,18 @@ async function runAutoMode(pm, progress, cwd, flags, changeName) {
     return progress
   }
 
+  // ── Classify change on first entry ──
+  if (!progress.stages?.brainstorm?.status && !progress.stages?.plan?.status) {
+    const { classifyChange } = await import('./classify-change.js')
+    const classification = classifyChange({ description: inputText || '', explicitMode })
+    if (classification.mode === 'quick') {
+      console.log(`📊 auto 模式分类：${classification.mode}（${classification.reason}）`)
+      console.log(`   此变更建议使用 quick 模式，运行：sillyspec run quick "${inputText || '需求'}"`)
+      return
+    }
+    console.log(`📊 auto 模式分类：${classification.mode}（${classification.reason}）`)
+  }
+
   let currentStage = progress.currentStage
   if (!currentStage || progress.stages?.[currentStage]?.status === 'completed') {
     currentStage = firstOpenStage()
@@ -3034,7 +3138,7 @@ async function runAutoMode(pm, progress, cwd, flags, changeName) {
     }
     console.log('')
 
-    const defSteps = await getStageSteps(currentStage, cwd, progress)
+    const defSteps = await getAutoSteps(currentStage)
     const pendingIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress') ?? -1
     if (pendingIdx === -1) {
       const wsIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'waiting') ?? -1
@@ -3079,7 +3183,7 @@ async function runAutoMode(pm, progress, cwd, flags, changeName) {
 
   const nextPendingIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress') ?? -1
   if (nextPendingIdx !== -1) {
-    const defSteps = await getStageSteps(currentStage, cwd, progress)
+    const defSteps = await getAutoSteps(currentStage)
     // execute 阶段启动前检查审批
     if (currentStage === 'execute' && !skipApproval) {
       const approval = await checkApproval(cwd, changeName, platformOpts)
@@ -3104,6 +3208,31 @@ async function runAutoMode(pm, progress, cwd, flags, changeName) {
     return
   }
 
+  // ── next-action.json 驱动：brainstorm → plan 推进判断 ──
+  if (currentStage === 'brainstorm' && next === 'plan') {
+    const changeDir = resolveChangeDir(cwd, progress, platformOpts?.specRoot || null)
+    if (changeDir) {
+      const nextActionFile = join(changeDir, 'brainstorm', 'next-action.json')
+      try {
+        const nextAction = JSON.parse(readFileSync(nextActionFile, 'utf8'))
+        if (nextAction.has_blocking_questions === true) {
+          console.log(`\n⏸️  brainstorm 有阻塞问题，无法自动进入 plan：`)
+          for (const q of (nextAction.questions || [])) {
+            console.log(`   Q-${q.id}: ${q.question}`)
+            if (q.options) console.log(`      选项：${q.options.join(' / ')}`)
+            if (q.recommended) console.log(`      推荐：${q.recommended}`)
+          }
+          console.log(`\n   请回答阻塞问题后继续：sillyspec run auto --done --output "已回答"`)
+          return
+        }
+        console.log(`\n✅ next-action.json: ${nextAction.status}，自动进入 plan`)
+      } catch (e) {
+        // next-action.json 不存在或格式错误，继续推进（向后兼容）
+        console.log(`\n⚠️  next-action.json 未找到，继续进入 plan`)
+      }
+    }
+  }
+
   progress.currentStage = next
   if (!progress.stages[next]) {
     progress.stages[next] = { status: 'pending', steps: [], startedAt: null, completedAt: null }
@@ -3119,7 +3248,7 @@ async function runAutoMode(pm, progress, cwd, flags, changeName) {
   progress = await pm.read(cwd, changeName)
 
   console.log(`\n${currentStage} complete. Auto advanced to ${next}.`)
-  const nextSteps = await getStageSteps(next, cwd, progress)
+  const nextSteps = await getAutoSteps(next)
   const firstPending = progress.stages[next]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress') ?? -1
   if (firstPending !== -1) {
     // execute 阶段启动前检查审批

package/src/stage-contract.js

@@ -67,7 +67,12 @@ function buildDecisionRecord(id, body) {
   const priorityMissing = priorityValue.length === 0
   const fallbackPriority = (['unresolved', 'blocking'].includes(status) || blocker) ? 'P1' : 'P2'
   const priority = (priorityValue.match(/P[0-2]/i)?.[0] || fallbackPriority).toUpperCase()
-  return { id: id.toUpperCase(), body, status, priority, blocker, priorityMissing }
+  // 解析 supersedes 字段：记录本条决策取代了哪个旧版本
+  const supersedesRaw = readDecisionField(body, 'supersedes', '')
+  const supersedes = supersedesRaw
+    ? supersedesRaw.split(',').map(s => s.trim().toUpperCase().replace(/['"]/g, '')).filter(Boolean)
+    : []
+  return { id: id.toUpperCase(), body, status, priority, blocker, priorityMissing, supersedes }
 }
 
 function findNextDecisionBoundary(content, startIndex) {
@@ -114,8 +119,16 @@ function parseDecisionRecords(content) {
 function extractCurrentDecisionIds(content) {
   const records = parseDecisionRecords(content)
   if (records.length === 0) return extractIds(content, 'D')
+  // 收集所有被 supersedes 声明取代的旧版本 ID
+  const supersededIds = new Set()
+  for (const r of records) {
+    for (const oldId of r.supersedes) {
+      supersededIds.add(oldId)
+    }
+  }
   return records
     .filter(r => !['superseded', 'rejected'].includes(r.status))
+    .filter(r => !supersededIds.has(r.id)) // 被新版本显式取代的旧版本不再校验
     .map(r => r.id)
     .sort()
 }

package/src/stages/brainstorm-auto.js

@@ -0,0 +1,229 @@
+/**
+ * brainstorm-auto.js — auto/full 模式使用的 brainstorm 步骤定义
+ *
+ * 与 brainstorm.js 的区别：
+ * 1. artifact-first：直接写文件，对话只输出摘要
+ * 2. 自动决策：基于 AC-001~AC-010 checklist，不频繁请示
+ * 3. next-action.json：结构化产物，驱动下游推进
+ * 4. 只有 blocking questions 才 wait 用户
+ * 5. 步骤从 ~13 步精简为 4 步
+ */
+
+export const definition = {
+  name: 'brainstorm',
+  title: '头脑风暴（自动模式）',
+  description: '探索需求、分析技术方案、识别风险 — artifact-first，自动决策优先',
+
+  steps: [
+    {
+      name: '状态检查与上下文加载',
+      prompt: `检查状态、加载项目上下文、匹配模块。
+
+### 操作
+1. 运行 \`sillyspec progress show\`，确认 currentStage 为 "brainstorm"
+2. 如果未初始化，提示先运行 sillyspec init
+3. **检查变更名称**：如果当前变更名是自动生成的（如 \`2026-06-02-new-change\`），直接重命名为有意义名称，然后运行 \`sillyspec change-rename <旧名> <新名>\`
+
+### 加载上下文
+4. 读取 CODEBASE-OVERVIEW.md + 共享规范 + 子项目上下文
+5. 加载项目信息：\`cat .sillyspec/projects/*.yaml 2>/dev/null\`
+6. 加载本地配置：\`cat .sillyspec/local.yaml 2>/dev/null\`
+7. 棕地项目：读取 scan 下的 STRUCTURE.md、CONVENTIONS.md、ARCHITECTURE.md
+8. 加载模块索引：读取 \`.sillyspec/docs/<project>/modules/_module-map.yaml\`（如存在）
+9. 查看进行中的变更：\`ls .sillyspec/changes/ | grep -v archive\`
+10. 检查同名变更或可复用模板
+
+### 模块匹配
+根据用户描述的需求关键词，匹配相关模块（用 _module-map.yaml 的 tags/aliases/paths）。
+
+### 子项目判定
+- 单项目：直接确认
+- 多项目且用户已指定：直接确认
+- 多项目且用户未指定：列出项目列表，需要用户确认
+
+### 如果有用户提供的原型/截图
+分析提取：页面结构、表单字段、交互流程、业务规则。
+
+### 输出
+状态摘要 + 项目现状理解（3-5 句）+ 涉及模块列表 + 子项目 + 原型分析（如有）
+
+### 注意
+- 以 CLI 返回为准，不要自行推断阶段
+- 不要用 mv 命令重命名变更目录，必须用 \`sillyspec change-rename\``,
+      outputHint: '状态摘要 + 上下文 + 模块匹配',
+      optional: false
+    },
+    {
+      name: '需求分析与方案设计',
+      requiresWait: true,
+      repeatableWait: true,
+      maxWaitRounds: 5,
+      waitReason: '等待用户回答需求问题',
+      waitOptions: ['回答见--answer', '信息够了，进入设计'],
+      prompt: `分析需求，必要时追问，然后设计方案。
+
+### 操作
+
+#### A. 需求评估
+1. 汇总上一步加载的上下文和用户需求
+2. 判断需求是否清晰：
+   - 目标明确、范围清楚、无歧义 → 跳过追问，直接进入方案设计
+   - 有歧义或不清楚 → 挑**一个最关键的**问题追问
+
+#### B. 追问规则（只在需要时）
+- 一次只问一个问题，不要一次性列出多个问题
+- 能从代码/文档确认的不要问用户
+- 多选题优于开放式问题
+- YAGNI — 砍掉不需要的功能
+- 2-3 轮问答就应进入方案设计
+- 优先追问影响架构/数据/接口的问题，实现细节不要问
+
+**如果需要追问：**调用 \`sillyspec run brainstorm --wait --reason "等待用户回答需求问题" --options "回答见--answer,信息够了,进入设计" --output "你的单个问题"\`
+
+#### C. 复杂度评估（追问结束后或不需要追问时）
+1. 判断是否需要拆分或走批量模式：
+   - 3+ 个可独立交付的功能模块 → 建议拆分
+   - 任务 > 10 且有重复模式 → 建议批量模式
+   - 简单 CRUD → 不拆
+2. 如果需要拆分/批量模式：暂停等用户确认
+   - 调用：\`sillyspec run brainstorm --wait --reason "等待用户确认拆分方案" --options "同意拆分,不需要拆分,走批量模式" --output "拆分方案摘要"\`
+3. 不需要拆分 → 继续
+
+#### D. 方案设计（自动决策优先）
+1. 基于需求理解和上下文，提出 1-3 种实现方案
+2. **使用自动决策 checklist（AC-001~AC-010）判断是否需要用户选择：**
+
+\`\`\`
+AC-001: 未修改公共 API
+AC-002: 未修改数据库 schema
+AC-003: 未涉及鉴权/权限
+AC-004: 未扩大 allowed_paths
+AC-005: 未引入新外部依赖
+AC-006: 未修改核心模块（workflow/daemon/session/lifecycle）
+AC-007: 已有项目约定可复用
+AC-008: 不影响向后兼容
+AC-009: 不涉及数据迁移
+AC-010: 单模块范围内可完成
+\`\`\`
+
+3. **自动决策判定：**
+   - 只有一个明显合理方案 + checklist 全部 ✅ → **自动选择，标记 AUTO_DECIDED**
+   - 有多个方案但影响不大（checklist 全部 ✅）→ **自动选推荐方案，标记 AUTO_DECIDED**
+   - 有多个方案且 checklist 有 ❌（影响架构/数据/接口/权限/兼容性）→ **只有这一种情况才暂停等用户选择**
+
+4. 如果需要用户选择方案：
+   - 调用：\`sillyspec run brainstorm --wait --reason "等待用户选择方案" --options "方案A,方案B,方案C" --output "方案对比摘要"\`
+
+#### E. Design Grill（轻量交叉审查）
+对方案做快速交叉审查：
+- 检查方案与 ARCHITECTURE.md / CONVENTIONS.md 的一致性
+- 检查是否有术语歧义、边界遗漏
+- 能自动解决的直接修正，只有需要业务判断的才问用户
+- 跳过条件：单模块、无状态流转、< 3 个文件变更
+
+### 输出
+需求理解摘要 + 复杂度评估 + 方案决策（AUTO_DECIDED 或用户选择）
+
+### 注意
+- **不要自问自答。** 不要在自己输出中模拟用户回答然后说"需求已明确"
+- checklist 判定结果必须在 decisions.md 中记录依据`,
+      outputHint: '需求理解 + 方案决策',
+      optional: false
+    },
+    {
+      name: '生成设计产物',
+      prompt: `将设计方案写入文件（artifact-first），不回显正文。
+
+### 操作
+1. 确保变更目录存在：\`mkdir -p .sillyspec/changes/<change-name>/brainstorm\`
+2. **直接将设计方案写入文件，不要先在对话中输出完整内容再写文件。**
+
+### 产物文件
+
+#### design.md（必填，写入 \`brainstorm/design.md\`）
+包含：背景、设计目标、非目标、总体方案、文件变更清单、接口定义、数据模型（如涉及）、兼容策略（brownfield）、风险登记、决策追踪。
+
+#### decisions.md（必填，写入 \`brainstorm/decisions.md\`）
+记录所有决策：
+\`\`\`markdown
+## D-001@v1: 决策短标题
+- type: architecture | boundary | compatibility | ...
+- priority: P0 | P1 | P2
+- status: AUTO_DECIDED | NEEDS_REVIEW | USER_DECIDED
+- source: user | code | docs
+- question: 被解决的问题
+- answer: 选择或结论
+- checklist: AC-001 ✅, AC-007 ✅（AUTO_DECIDED 时必须列出）
+- normalized_requirement: 可测试约束
+- impacts: [FR-01, task-01]
+- evidence: 代码/文档路径或用户回答轮次
+\`\`\`
+
+#### gaps.md（必填，写入 \`brainstorm/gaps.md\`）
+记录已识别的缺口。status=BLOCKER 的缺口会在 plan-postcheck 中触发回退。
+
+#### assumptions.md（必填，写入 \`brainstorm/assumptions.md\`）
+记录隐含假设和验证方法。
+
+#### next-action.json（必填，写入 \`brainstorm/next-action.json\`）
+\`\`\`json
+{
+  "status": "ready_for_plan" | "waiting_for_user",
+  "decision_level": "high" | "medium" | "low",
+  "has_blocking_questions": true | false,
+  "blocking_reasons": [],
+  "questions": [],
+  "auto_decisions": [
+    { "id": "D-001", "decision": "方案描述", "reason": "AC-007 ✅" }
+  ]
+}
+\`\`\`
+
+### 自审
+对 design.md 执行自审（需求覆盖、文件变更清单具体性、验收标准可测试、非目标清晰、兼容策略）。发现问题直接修改文件。
+
+### 如果有 blocking questions
+将问题写入 next-action.json.questions，在对话中输出问题列表和推荐选项，然后 --wait。
+
+### 输出（artifact-first）
+只输出摘要：
+\`\`\`
+已生成设计产物（5 个文件）：
+- brainstorm/design.md — 采用 xxx 方案，涉及 N 个文件变更
+- brainstorm/decisions.md — M 个决策，K 个 AUTO_DECIDED
+- brainstorm/gaps.md — J 个缺口，0 个 BLOCKER
+- brainstorm/assumptions.md — L 个假设
+- brainstorm/next-action.json — ready_for_plan / waiting_for_user
+\`\`\``,
+      outputHint: '产物摘要',
+      optional: false
+    },
+    {
+      name: '生成规范文件',
+      requiresWait: true,
+      waitReason: '等待用户最终确认',
+      waitOptions: ['确认', '需要修改', '推翻重来'],
+      prompt: `生成 proposal.md / requirements.md / tasks.md，让用户确认。
+
+### 操作
+1. 基于 brainstorm/ 下的设计产物，生成规范文件（直接写文件）：
+   - **proposal.md**：动机、关键问题、变更范围、不在范围内、成功标准
+   - **requirements.md**：角色表 + FR 编号需求 + Given/When/Then + 非功能需求
+   - **tasks.md**：任务列表（只列名称，细节在 plan 阶段展开）
+2. 如果 brainstorm/decisions.md 有 AUTO_DECIDED 决策，在变更根目录也写一份 decisions.md
+3. 所有规范文件头部包含 YAML frontmatter
+4. \`git add .sillyspec/\` — 暂存规范文件（不要 commit）
+
+### 输出（摘要）
+规范文件路径列表（各一句话说明）
+
+### 铁律
+- **直接写文件，不在对话中输出完整内容**
+- 暂停等待用户确认：\`sillyspec run brainstorm --wait --reason "等待用户最终确认" --options "确认,需要修改,推翻重来" --output "规范文件摘要"\`
+- 禁止自动 commit
+- 禁止在确认前推进到后续阶段`,
+      outputHint: '规范文件摘要',
+      optional: false
+    }
+  ]
+}