sillyspec 3.20.0 → 3.20.2

package/src/run.js

@@ -27,6 +27,52 @@ export function sanitizeProjectName(name) {
   return clean
 }
 
+/**
+ * 校验从 step 2 解析出的项目列表。
+ * 不通过则不落盘 projects/*.yaml、不展开 perProject 步骤。
+ *
+ * @param {Array<{id: string, path?: string}>} projects - 项目列表（含可选 path）
+ * @param {string} sourceRoot - 源码根目录，用于 path 安全校验
+ */
+export function validateParsedProjects(projects, sourceRoot) {
+  const errors = []
+  if (!projects || projects.length === 0) {
+    return { ok: false, errors: ['项目列表为空'] }
+  }
+  if (projects.length > 10) {
+    return { ok: false, errors: [`项目数量 ${projects.length} 超过上限 10，疑似误解析`] }
+  }
+  const safeRoot = resolve(sourceRoot)
+  const seen = new Set()
+  for (const proj of projects) {
+    const id = proj.id || proj
+    if (seen.has(id)) {
+      errors.push(`重复项目名: ${id}`)
+    }
+    seen.add(id)
+    // slug 合法性：只允许 a-z 0-9 _ - .，长度 2-64
+    if (!/^[a-zA-Z][\w\-.]{1,63}$/.test(id)) {
+      errors.push(`项目名 "${id}" 不合法（需 slug 格式：字母开头，只含 a-zA-Z0-9_-., 长度 2-64）`)
+    }
+    // path 安全校验（如果提供了 path）
+    if (proj.path) {
+      if (proj.path.includes('..')) {
+        errors.push(`项目 "${id}" 的 path 包含 .. ，拒绝越界`)
+      } else {
+        const absPath = resolve(safeRoot, proj.path)
+        if (!absPath.startsWith(safeRoot + '/') && absPath !== safeRoot) {
+          errors.push(`项目 "${id}" 的 path "${proj.path}" 解析后超出 source_root`)
+        }
+        if (!existsSync(absPath)) {
+          errors.push(`项目 "${id}" 的 path "${proj.path}" 不存在`)
+        }
+      }
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors }
+  return { ok: true, errors: [] }
+}
+
 /**
  * 在容器/Docker 环境下，git 可能因目录所有权不匹配报 dubious ownership。
  * 使用 -c safe.directory= 临时参数，不污染全局 git config。
@@ -113,6 +159,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 +821,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)
   }
@@ -1283,7 +1332,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]
@@ -1340,7 +1389,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 只作为变更名标识，不再拦截流程
@@ -1528,16 +1577,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
@@ -2202,7 +2259,7 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
   // plan 阶段 "generate_plan" 完成后，动态插入任务蓝图 + postcheck 步骤
   // 使用稳定 id 匹配，不依赖中文标题
   if (stageName === 'plan') {
-    const currentStepDef = defSteps?.[currentIdx]
+    const currentStepDef = defStepsForCurrent?.[currentIdx]
     const currentStepEntry = steps[currentIdx]
     const stepId = currentStepDef?.id || currentStepEntry?.id || currentStepEntry?._stepId
     if (stepId === 'generate_plan') {
@@ -2243,91 +2300,132 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
 
   // scan 阶段 step 2 "构建扫描项目列表" 完成后，按项目展开 perProject 步骤
   if (stageName === 'scan' && steps[currentIdx]?.name === '构建扫描项目列表') {
-    // 解析项目列表：从 step 2 输出提取，或回退读取 projects/*.yaml
-    let projectNames = []
-    // sanitizeProjectName 已提取到模块顶层（含字母校验 + 长度≥2）
+    // 解析项目列表：只接受结构化输出（YAML block 或 BEGIN_PROJECT_LIST 标记）
+    // 不再从自由文本猜测项目名——自由文本列表的误解析会导致垃圾项目落盘
+    let parsedProjects = [] // Array<{id, path?}>
+    let parsedFromStructuredOutput = false
     if (outputText) {
-      // 匹配方式 1: "1. project-name" 编号列表
-      // 正则收紧：token 必须以字母开头，避免误捕获纯数字 "0"/"7" 和步骤说明中英文行
-      const numbered = outputText.match(/^\s*\d+\.\s+([a-zA-Z][\w\-.]*)/gm)
-      if (numbered) {
-        // task-05 B2 延伸修正：原 /[—\-:].*$/ 会把 ASCII 连字符当后缀分隔符，
-        // 把 order-service 切成 order。现只针对中文长破折号 `—`（LLM 输出列表时常作分隔符）。
-        const raw = numbered.map(m => m.replace(/^\s*\d+\.\s+/, '').replace(/—.*$/, '').trim())
-        projectNames = raw.map(sanitizeProjectName).filter(Boolean)
-        if (projectNames.length > 0) { stageData.scanMeta = stageData.scanMeta || {}; stageData.scanMeta.projectListParsed = true; }
-      }
-      // 匹配方式 2: 括号枚举 "子项目frontend/order-service/user-service" 或 "项目: a, b, c"
-      if (projectNames.length === 0) {
-        const parenMatch = outputText.match(/(?:子项目|项目)[\s:：]*(\S+(?:[\/、,，]+\S+)*)/)
-        if (parenMatch) {
-          const raw = parenMatch[1].split(/[\/、,，]+/).map(s => s.trim()).filter(Boolean)
-          projectNames = raw.map(sanitizeProjectName).filter(Boolean)
-          if (projectNames.length > 0) { stageData.scanMeta = stageData.scanMeta || {}; stageData.scanMeta.projectListParsed = true; }
+      // 格式 A: YAML block — 匹配 scan_projects: 下所有 - id: xxx 条目（含多行属性）
+      const yamlBlock = outputText.match(/scan_projects:\s*\n([\s\S]+?)(?=$|\n[^\s])/)
+      if (yamlBlock) {
+        const entries = [...yamlBlock[1].matchAll(/-\s+id:\s*(\S+)(?:[\s\S]*?)(?=\n\s+-\s+id:|$)/g)]
+        for (const m of entries) {
+          const id = sanitizeProjectName(m[1])
+          if (!id) continue
+          // 提取可选 path 字段
+          const pathMatch = m[0].match(/path:\s*(\S+)/)
+          const entry = pathMatch ? { id, path: pathMatch[1].trim() } : { id }
+          parsedProjects.push(entry)
         }
-      }
-      // 匹配方式 3: 结构化 YAML block "scan_projects:\n  - id: name"
-      if (projectNames.length === 0) {
-        const yamlMatch = outputText.match(/scan_projects:\s*\n((?:\s+-\s+id:\s+\S+\s*\n?)+)/)
-        if (yamlMatch) {
-          const raw = [...yamlMatch[1].matchAll(/-\s+id:\s*(\S+)/g)].map(m => m[1])
-          projectNames = raw.map(sanitizeProjectName).filter(Boolean)
-          if (projectNames.length > 0) { stageData.scanMeta = stageData.scanMeta || {}; stageData.scanMeta.projectListParsed = true; }
+        parsedFromStructuredOutput = parsedProjects.length > 0
+      }
+      // 格式 B: BEGIN_PROJECT_LIST ... END_PROJECT_LIST 标记块
+      if (!parsedFromStructuredOutput) {
+        const blockMatch = outputText.match(/BEGIN_PROJECT_LIST\s*\n([\s\S]*?)\n*END_PROJECT_LIST/)
+        if (blockMatch) {
+          const raw = [...blockMatch[1].matchAll(/^-\s+(\S+)/gm)].map(m => m[1])
+          parsedProjects = raw.map(s => sanitizeProjectName(s)).filter(Boolean).map(id => ({ id }))
+          parsedFromStructuredOutput = parsedProjects.length > 0
         }
       }
     }
-    if (projectNames.length === 0) {
-      // 回退：读取所有已注册项目
-      console.warn('⚠️ 未能从 step 2 输出解析项目列表，回退扫描所有注册项目')
-      stageData.scanMeta = stageData.scanMeta || {}; stageData.scanMeta.projectListParsed = false;
+
+    const projectNames = parsedProjects.map(p => p.id)
+
+    if (parsedFromStructuredOutput) {
+      stageData.scanMeta = stageData.scanMeta || {}
+      stageData.scanMeta.projectListParsed = true
+    } else {
+      // 结构化输出未解析到 → 回退读取已有 projects/*.yaml
+      // 读取时也校验：path 不存在的 yaml 视为垃圾，直接跳过
+      console.warn('⚠️  step 2 未输出结构化项目列表，回退扫描已注册项目')
+      stageData.scanMeta = stageData.scanMeta || {}
+      stageData.scanMeta.projectListParsed = false
       const projectsDir = join(specBase, 'projects')
       if (existsSync(projectsDir)) {
-        projectNames = readdirSync(projectsDir)
-          .filter(f => f.endsWith('.yaml'))
-          .map(f => f.replace(/\.yaml$/, ''))
+        const yamlFiles = readdirSync(projectsDir).filter(f => f.endsWith('.yaml'))
+        const fallbackProjects = []
+        const fallbackSkipped = []
+        for (const yf of yamlFiles) {
+          const pName = yf.replace(/\.yaml$/, '')
+          const yamlContent = readFileSync(join(projectsDir, yf), 'utf8')
+          const pathMatch = yamlContent.match(/^path:\s*(.+)/m)
+          const pPath = pathMatch ? pathMatch[1].trim() : pName
+          // 校验 path 是否存在且在 source_root 内
+          const absPath = resolve(cwd, pPath)
+          if (pPath.includes('..') || (!absPath.startsWith(resolve(cwd)) && absPath !== resolve(cwd))) {
+            fallbackSkipped.push(`${pName} (path 越界: ${pPath})`)
+            continue
+          }
+          if (!existsSync(absPath)) {
+            fallbackSkipped.push(`${pName} (path 不存在: ${pPath})`)
+            continue
+          }
+          fallbackProjects.push({ id: pName, path: pPath })
+        }
+        if (fallbackSkipped.length > 0) {
+          console.warn(`⚠️  跳过 ${fallbackSkipped.length} 个垃圾/过期项目配置：${fallbackSkipped.join(', ')}`)
+          console.warn('   建议清理 projects/ 下的无效 yaml 文件')
+        }
+        parsedProjects = fallbackProjects
+        projectNames.length = 0
+        projectNames.push(...fallbackProjects.map(p => p.id))
+      }
+      if (parsedProjects.length === 0) {
+        // 无结构化输出 + 无合法已有项目 → step 2 失败
+        console.error('❌ step 2 未输出结构化项目列表，且 projects/ 下无合法项目配置')
+        console.error('   请在 --output 中输出 scan_projects YAML block 或 BEGIN_PROJECT_LIST 标记块')
+        steps[currentIdx].validationError = '未输出结构化项目列表且无合法 fallback'
+        // 不展开 perProject 步骤，直接跳到下一步
       }
     }
-    if (projectNames.length === 0) {
-      projectNames = ['sillyspec'] // 最终兜底
+
+    // 校验解析出的项目列表（原子守卫：不通过就不落盘）
+    const validation = validateParsedProjects(parsedProjects, cwd)
+    if (!validation.ok) {
+      console.error(`❌ 项目列表校验失败: ${validation.errors.join('; ')}`)
+      console.error('   step 2 完成，但不展开 perProject 步骤。请检查 --output 中的项目列表。')
+      steps[currentIdx].validationError = validation.errors.join('; ')
     }
 
-    // 自动注册未注册的子项目（确保 projects/*.yaml 存在，避免展开时 projectRoot 缺失）
+    // 自动注册 + 保存 runtime + 展开 perProject 步骤（仅在校验通过时）
     const projectsDir = join(specBase, 'projects')
-    for (const pName of projectNames) {
-      const projYaml = join(projectsDir, `${pName}.yaml`)
-      if (!existsSync(projYaml)) {
-        mkdirSync(projectsDir, { recursive: true })
-        // 子项目路径推测：检查 cwd 下是否有同名目录
-        const candidates = [
-          join(cwd, pName),                              // cwd/frontend
-          join(cwd, 'backend', pName),                 // cwd/backend/user-service
-          join(cwd, 'packages', pName),                // monorepo packages
-          join(cwd, 'apps', pName),                     // monorepo apps
-          join(cwd, 'services', pName),                // monorepo services
-        ]
-        const detected = candidates.find(c => existsSync(c))
-        const regPath = detected || join(cwd, pName)
-        writeFileSync(projYaml, `name: ${pName}\npath: ${regPath}\nstatus: active\n`)
-        console.log(`  📝 自动注册子项目: ${pName} → ${regPath}`)
-      }
-    }
-
-    // 保存到 runtime 供后续使用 + 防重复展开
-    const scanStatePath = join(specBase, '.runtime', 'scan-projects.json')
-    mkdirSync(join(specBase, '.runtime'), { recursive: true })
-    let scanState = { projects: projectNames, expanded: false }
-    if (existsSync(scanStatePath)) {
-      try { scanState = JSON.parse(readFileSync(scanStatePath, 'utf8')) } catch {}
-    }
-
-    // 收集当前步骤之后所有 perProject 步骤
-    const stageDef = stageRegistry[stageName]
-    const allSteps = stageDef?.steps || []
-    const perProjectSteps = allSteps.filter(s => s.perProject)
+    if (validation.ok) {
+      for (const proj of parsedProjects) {
+        const pName = proj.id
+        const projYaml = join(projectsDir, `${pName}.yaml`)
+        if (!existsSync(projYaml)) {
+          mkdirSync(projectsDir, { recursive: true })
+          const candidates = [
+            join(cwd, pName),
+            join(cwd, 'backend', pName),
+            join(cwd, 'packages', pName),
+            join(cwd, 'apps', pName),
+            join(cwd, 'services', pName),
+          ]
+          const detected = candidates.find(c => existsSync(c))
+          const regPath = detected || join(cwd, pName)
+          writeFileSync(projYaml, `name: ${pName}\npath: ${regPath}\nstatus: active\n`)
+          console.log(`  📝 自动注册子项目: ${pName} → ${regPath}`)
+        }
+      }
+
+      // 保存 runtime 状态
+      const scanStatePath = join(specBase, '.runtime', 'scan-projects.json')
+      mkdirSync(join(specBase, '.runtime'), { recursive: true })
+      let scanState = { projects: projectNames, expanded: false }
+      if (existsSync(scanStatePath)) {
+        try { scanState = JSON.parse(readFileSync(scanStatePath, 'utf8')) } catch {}
+      }
+
+      // 收集当前步骤之后所有 perProject 步骤
+      const stageDef = stageRegistry[stageName]
+      const allSteps = stageDef?.steps || []
+      const perProjectSteps = allSteps.filter(s => s.perProject)
 
-    // 防重复展开：runtime 标记 或 steps 已含项目标识
-    const alreadyExpanded = scanState.expanded || steps.some(s => s.name?.match(/\[.+\]\s*$/))
-    if (!alreadyExpanded && perProjectSteps.length > 0) {
+      // 防重复展开
+      const alreadyExpanded = scanState.expanded || steps.some(s => s.name?.match(/\[.+\]\s*$/))
+      if (!alreadyExpanded && perProjectSteps.length > 0) {
       // 找到当前步骤（step 2）在动态 steps 中的位置
       const insertBase = currentIdx + 1
       let insertPos = insertBase
@@ -2366,8 +2464,9 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
       // 标记已展开，防止 resume 重复插入
       scanState.expanded = true
       writeFileSync(scanStatePath, JSON.stringify(scanState))
-    }
-  }
+    } // end !alreadyExpanded
+    } // end validation.ok
+  } // end step 2
 
   const nextPendingIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
 
@@ -2667,7 +2766,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
@@ -2676,9 +2775,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()
             }
 
@@ -3016,14 +3122,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
@@ -3032,6 +3152,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)
@@ -3041,6 +3179,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()
@@ -3076,7 +3226,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
@@ -3121,7 +3271,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)
@@ -3146,6 +3296,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 }
@@ -3161,7 +3336,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/scan-postcheck.js

@@ -151,19 +151,22 @@ export function runScanPostCheck({ cwd, specDir, outputText = '', scanMeta = {}
     }
   }
 
-  // 5. 检查 AI 输出中的错误标记
+  // 5. 检查 AI 输出中的真实错误标记
+  // 注意：不对 agent 描述性文本做全文正则匹配，防止误报。
+  // 只检测明显是 agent 运行时失败的信号（未被捕获的错误块），
+  // 而非 agent 正常描述中提到这些词。
   if (outputText) {
-    const errorPatterns = [
-      { pattern: /tool_use_error/i, name: 'tool_use_error', detail: 'AI 输出中包含 tool_use_error' },
-      { pattern: /API Error.*529/i, name: 'api_error_529', detail: 'AI 输出中包含 API Error 529' },
-      { pattern: /rate.?limit.*exhausted/i, name: 'rate_limit_exhausted', detail: 'AI 输出中包含 rate_limit exhausted' },
-      { pattern: /fallback|retry.*failed|skipped.*validat/i, name: 'fallback_or_skip', detail: 'AI 输出中出现 fallback/retry failed/skipped validation' },
-    ]
-    for (const ep of errorPatterns) {
-      if (ep.pattern.test(outputText)) {
-        checks.push({ name: ep.name, severity: CHECK_SEVERITY.WARNING, detail: ep.detail })
-      }
+    // 5a: 检测未被恢复的 API 错误（连续多次、非描述性提及）
+    const apiErrorCount = (outputText.match(/API Error\b.*?\b529\b/gi) || []).length
+    if (apiErrorCount >= 2) {
+      checks.push({ name: 'api_error_529', severity: CHECK_SEVERITY.WARNING, detail: 'AI 输出中包含多次 API Error 529' })
+    }
+    const rateLimitCount = (outputText.match(/rate.?limit.*?exhausted/gi) || []).length
+    if (rateLimitCount >= 2) {
+      checks.push({ name: 'rate_limit_exhausted', severity: CHECK_SEVERITY.WARNING, detail: 'AI 输出中包含多次 rate_limit exhausted' })
     }
+    // tool_use_error 和 fallback 已移除：agent 描述性文本中正常提及这些词
+    // 不应触发 warning。真正的问题会通过文档缺失、manifest 失败等其他检查捕获。
   }
 
   // 6. manifest 写入状态检查
@@ -300,7 +303,7 @@ export function formatStructuredResult(result, meta = {}) {
       structured.failure_categories.bad_references.push(entry)
     }
     // AI 输出质量类
-    else if (['tool_use_error', 'api_error_529', 'rate_limit_exhausted', 'fallback_or_skip'].includes(check.name)) {
+    else if (['api_error_529', 'rate_limit_exhausted'].includes(check.name)) {
       structured.failure_categories.quality_warnings.push(entry)
     }
     // manifest/project 列表问题