sillyspec 3.9.1 → 3.10.1

package/src/run.js

@@ -10,57 +10,59 @@ import { stageRegistry, auxiliaryStages } from './stages/index.js'
 import { buildExecuteSteps } from './stages/execute.js'
 import { buildPlanSteps } from './stages/plan.js'
 
+/**
+ * 统一查找变更目录
+ */
+function resolveChangeDir(cwd, progress) {
+  const changesDir = join(cwd, '.sillyspec', 'changes')
+  if (!existsSync(changesDir)) return null
+
+  // 1. 优先用 currentChange
+  if (progress.currentChange) {
+    const target = join(changesDir, progress.currentChange)
+    if (existsSync(target)) return target
+  }
+
+  // 2. fallback：唯一非 archive 目录
+  const entries = readdirSync(changesDir, { withFileTypes: true })
+    .filter(e => e.isDirectory() && e.name !== 'archive')
+  if (entries.length === 1) return join(changesDir, entries[0].name)
+
+  return null
+}
+
+/**
+ * 自动探测并设置 currentChange（唯一变更目录时）
+ * @returns {boolean} 是否设置了 currentChange
+ */
+function autoDetectChange(progress, cwd) {
+  if (progress.currentChange) return false
+  const changesDir = join(cwd, '.sillyspec', 'changes')
+  if (!existsSync(changesDir)) return false
+  const entries = readdirSync(changesDir, { withFileTypes: true })
+    .filter(e => e.isDirectory() && e.name !== 'archive')
+  if (entries.length === 1) {
+    progress.currentChange = entries[0].name
+    return true
+  }
+  return false
+}
+
 /**
  * 获取阶段的步骤定义（execute 需要动态构建）
  */
 async function getStageSteps(stageName, cwd, progress) {
   if (stageName === 'execute') {
-    const changesDir = join(cwd, '.sillyspec', 'changes')
+    const changeDir = resolveChangeDir(cwd, progress)
     let planFile = null
-    // 优先用 currentChange 指定的变更名
-    if (progress.currentChange) {
-      const target = join(changesDir, progress.currentChange, 'plan.md')
-      if (existsSync(target)) planFile = target
-    }
-    // fallback：扫描 changes/ 非 archive 目录下的 plan.md
-    if (!planFile && existsSync(changesDir)) {
-      const candidates = []
-      for (const entry of readdirSync(changesDir, { withFileTypes: true })) {
-        if (!entry.isDirectory() || entry.name === 'archive') continue
-        const p = join(changesDir, entry.name, 'plan.md')
-        if (existsSync(p)) candidates.push({ name: entry.name, path: p })
-      }
-      if (candidates.length === 1) {
-        planFile = candidates[0].path
-      } else if (candidates.length > 1) {
-        console.log('⚠️  检测到多个变更，请选择：')
-        candidates.forEach((c, i) => console.log(`  ${i + 1}. ${c.name}`))
-        const readline = await import('readline')
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-        const answer = await new Promise(resolve => {
-          rl.question(`\n请输入编号（默认 1）：`, input => {
-            rl.close()
-            const num = parseInt(input) || 1
-            resolve(num >= 1 && num <= candidates.length ? num - 1 : 0)
-          })
-        })
-        planFile = candidates[answer].path
-        console.log(`✅ 已选择：${candidates[answer].name}\n`)
-      }
+    if (changeDir) {
+      const p = join(changeDir, 'plan.md')
+      if (existsSync(p)) planFile = p
     }
     return buildExecuteSteps(planFile)
   }
   if (stageName === 'plan') {
-    const changesDir = join(cwd, '.sillyspec', 'changes')
-    let changeDir = null
-    if (progress.currentChange) {
-      const target = join(changesDir, progress.currentChange)
-      if (existsSync(target)) changeDir = target
-    }
-    if (!changeDir && existsSync(changesDir)) {
-      const entries = readdirSync(changesDir, { withFileTypes: true }).filter(e => e.isDirectory() && e.name !== 'archive')
-      if (entries.length === 1) changeDir = join(changesDir, entries[0].name)
-    }
+    const changeDir = resolveChangeDir(cwd, progress)
     return buildPlanSteps(changeDir)
   }
   const def = stageRegistry[stageName]
@@ -119,7 +121,9 @@ function outputStep(stageName, stepIndex, steps, cwd) {
     verify: `### 🔍 你的角色：QA 专家
 你是一位吹毛求疵的 QA 专家。假设所有代码都有 bug，用最坏情况测试。关注边界、异常、并发。有问题直说，用证据说话，不写"看起来没问题"。`,
     quick: `### 💻 你的角色：全栈老兵
-你是一位实战经验丰富的全栈工程师。不纠结架构和流程，理解需求就直接干。不确定的地方先问清楚再动手，先读后写，改完就收。问题排查思路开阔，前端报错不一定是前端问题——可能是后端数据、浏览器兼容、甚至设备硬件。解决方案实用接地气，用户描述有误敢于直接指出。`
+你是一位实战经验丰富的全栈工程师。不纠结架构和流程，理解需求就直接干。不确定的地方先问清楚再动手，先读后写，改完就收。问题排查思路开阔，前端报错不一定是前端问题——可能是后端数据、浏览器兼容、甚至设备硬件。解决方案实用接地气，用户描述有误敢于直接指出。`,
+    explore: `### 🧭 你的角色：技术探索伙伴
+你帮助用户澄清问题、调查代码库、比较方案和暴露风险。探索阶段不写实现代码，不安装依赖，不把讨论强行推进成开发。`
   }
 
   console.log(`---`)
@@ -170,6 +174,7 @@ export async function runCommand(args, cwd) {
   const isSkip = flags.includes('--skip')
   const isStatus = flags.includes('--status')
   const isReset = flags.includes('--reset')
+  const isConfirm = flags.includes('--confirm')
 
   // 解析 --output
   let outputText = null
@@ -244,7 +249,7 @@ export async function runCommand(args, cwd) {
 
   // --done
   if (isDone) {
-    return await completeStep(pm, progress, stageName, cwd, outputText, inputText)
+    return await completeStep(pm, progress, stageName, cwd, outputText, inputText, { confirm: isConfirm })
   }
 
   // 默认：输出当前步骤
@@ -252,6 +257,12 @@ export async function runCommand(args, cwd) {
 }
 
 async function runStage(pm, progress, stageName, cwd) {
+  // 自动探测 currentChange
+  if (autoDetectChange(progress, cwd)) {
+    progress.lastActive = new Date().toLocaleString('zh-CN', { hour12: false })
+    pm._write(cwd, progress)
+  }
+
   const stageData = progress.stages[stageName]
   if (!stageData || !stageData.steps) {
     console.error(`❌ 阶段 ${stageName} 未初始化`)
@@ -319,7 +330,7 @@ function validateMetadata(cwd, stageName) {
 }
 
 async function completeStep(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
-  const { printNext = true } = options
+  const { printNext = true, confirm = false } = options
   const stageData = progress.stages[stageName]
   if (!stageData || !stageData.steps) {
     console.error(`❌ 阶段 ${stageName} 未初始化`)
@@ -352,25 +363,26 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
     }
   }
 
-  // plan 阶段 "展开任务" 完成后，动态插入 task 蓝图步骤
-  if (stageName === 'plan' && steps[currentIdx]?.name === '展开任务并分组' && progress.currentChange) {
-    const planFile = join(cwd, '.sillyspec', 'changes', progress.currentChange, 'plan.md')
-    if (existsSync(planFile)) {
-      const planContent = readFileSync(planFile, 'utf8')
-      const { buildPlanSteps, fixedPrefix, fixedSuffix } = await import('./stages/plan.js')
-      const fullSteps = buildPlanSteps(join(cwd, '.sillyspec', 'changes', progress.currentChange), planContent)
-      const prefixLen = fixedPrefix.length
-      const suffixLen = fixedSuffix.length
-      const taskSteps = fullSteps.slice(prefixLen, suffixLen > 0 ? -suffixLen : undefined)
-      if (taskSteps.length > 0) {
-        const oldSteps = [...steps]
-        const rebuilt = fullSteps.map(stepDef => {
-          const existing = oldSteps.find(s => s.name === stepDef.name && s.status !== 'pending')
-          if (existing) return existing
-          return { name: stepDef.name, status: 'pending' }
-        })
-        steps.splice(0, steps.length, ...rebuilt)
-        console.log(`  📝 已动态插入 ${taskSteps.length} 个任务蓝图步骤`)
+  // 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
+        // 提取协调器步骤（prefix 和 suffix 之间）
+        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' })
+          }
+          console.log(`  📝 已动态插入 ${coordinatorSteps.length} 个任务蓝图步骤（${coordinatorSteps.map(s => s.name).join(', ')}）`)
+        }
       }
     }
   }
@@ -394,9 +406,74 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
     // 验证：检查生成的文件是否包含 author 和 created_at
     validateMetadata(cwd, stageName)
 
+    // archive 阶段 Step 2（确认归档）完成时自动执行归档移动
+    if (stageName === 'archive' && steps[currentIdx]?.name === '确认归档') {
+      if (confirm) {
+        const { renameSync } = await import('fs')
+        const changeName = progress.currentChange
+        if (!changeName) {
+          console.error('❌ 归档失败：未找到当前变更名（currentChange）')
+          process.exit(1)
+        }
+        const changesDir = join(cwd, '.sillyspec', 'changes')
+        const archiveDir = join(changesDir, 'archive')
+        const srcDir = join(changesDir, changeName)
+        const date = new Date().toISOString().slice(0, 10)
+        const destDir = join(archiveDir, `${date}-${changeName}`)
+
+        if (!existsSync(srcDir)) {
+          console.error(`❌ 归档失败：源目录不存在 ${srcDir}`)
+          process.exit(1)
+        }
+        if (existsSync(destDir)) {
+          console.error(`❌ 归档失败：目标目录已存在 ${destDir}`)
+          process.exit(1)
+        }
+        mkdirSync(archiveDir, { recursive: true })
+        renameSync(srcDir, destDir)
+
+        // 校验
+        if (!existsSync(destDir) || existsSync(srcDir)) {
+          console.error('❌ 归档校验失败：移动操作异常')
+          process.exit(1)
+        }
+
+        // 清除 currentChange
+        progress.currentChange = null
+        console.log(`📦 已归档：${changeName} → archive/${date}-${changeName}/`)
+      } else {
+        console.log('⚠️  请添加 --confirm 确认归档，例如：sillyspec run archive --done --confirm --output "确认归档"')
+      }
+    }
+
+    // 辅助阶段（archive/scan/quick 等）完成后重置步骤，允许重复执行
+    const stageDef = stageRegistry[stageName]
+    if (stageDef?.auxiliary) {
+      const freshSteps = (stageDef.steps || []).map(s => ({
+        name: s.name,
+        status: 'pending',
+        output: null,
+        completedAt: null
+      }))
+      stageData.steps = freshSteps
+      stageData.status = 'pending'
+      stageData.completedAt = null
+      pm._write(cwd, progress)
+    }
+
     const total = steps.length
     console.log(`✅ ${stageName} 阶段已完成（${total}/${total} 步）`)
-    console.log(`\n下一步由你决定：sillyspec run <stage>（brainstorm/plan/execute/verify/archive 等）`)
+
+    // 阶段完成后提示下一步
+    if (stageName === 'execute') {
+      console.log('\n👉 下一步：sillyspec run verify（验证通过后才能归档）')
+    } else if (stageName === 'verify') {
+      console.log('\n👉 下一步：sillyspec run archive（验证通过，可以归档了）')
+    } else if (stageName === 'archive') {
+      console.log('\n👉 归档完成！现在可以提交了：git commit -m "..."')
+    } else {
+      console.log(`\n下一步由你决定：sillyspec run <stage>（brainstorm/plan/execute/verify/archive 等）`)
+    }
     return { stageCompleted: true, currentIdx, nextPendingIdx: -1 }
   }
 

package/src/stages/archive.js

@@ -2,19 +2,19 @@ export const definition = {
   name: 'archive',
   title: '归档变更',
   description: '规范沉淀，可追溯',
-  auxiliary: true,
   steps: [
     {
       name: '任务完成度检查',
-      prompt: `检查 tasks.md 中所有 checkbox 是否已勾选。
+      prompt: `检查 plan.md 中所有任务 checkbox 是否已勾选（plan.md 是任务完成的唯一真相源）。
 
 ### 操作
-1. 读取 \`.sillyspec/changes/<change-name>/tasks.md\`
-2. 检查所有 checkbox 是否已勾选
-3. 如有遗漏 → 询问用户是否继续归档
+1. 读取 \`.sillyspec/changes/<change-name>/plan.md\`
+2. 检查所有 \`- [x]\` checkbox 是否已勾选
+3. 如果 plan.md 不存在，回退读取 tasks.md 作为备选
+4. 如有遗漏 → 询问用户是否继续归档
 
 ### 输出
-完成度报告`,
+完成度报告（已勾选/总数 + 未完成任务列表）`,
       outputHint: '完成度报告',
       optional: false
     },
@@ -25,9 +25,15 @@ export const definition = {
 ### 操作
 1. 展示：变更目录名、包含的文件列表、生成总结
 2. 请用户确认是否执行归档
-3. 确认后：将 \`.sillyspec/changes/<change-name>/\` 移动到 \`.sillyspec/changes/archive/YYYY-MM-DD-<change-name>/\`
+3. 确认后：将 \.sillyspec/changes/<change-name>/ 移动到 \.sillyspec/changes/archive/YYYY-MM-DD-<change-name>/
 4. 确保所有 checkbox 都已勾选
 
+### 归档执行
+确认归档后，执行以下命令自动完成目录移动：
+\	\	sillyspec run archive --done --confirm --output "确认归档"
+- \`--confirm\` 标志会自动执行目录移动（原子操作）
+- 不带 \`--confirm\` 则只提示需要确认
+
 ### 输出
 归档确认`,
       outputHint: '归档确认',
@@ -39,7 +45,7 @@ export const definition = {
 
 ### 操作
 1. 如果 \`.sillyspec/ROADMAP.md\` 存在，标记对应 Phase 为已完成
-2. \`git add .sillyspec/\` — **不要 commit**，由用户通过统一提交工具处理
+2. \`git add .sillyspec/changes/\` — 暂存归档结果（不要 commit，由用户通过统一提交工具处理）
 3. 更新 progress.json：
    - 清除当前变更信息（归档后不再活跃）
    - 如果是主变更（有 MASTER.md），标记所有阶段为 ✅，然后清除

package/src/stages/brainstorm.js

@@ -31,7 +31,7 @@ export const definition = {
 2. 加载项目信息：\`cat .sillyspec/projects/*.yaml 2>/dev/null\`
 3. 加载本地配置：\`cat .sillyspec/local.yaml 2>/dev/null\`
 4. 询问本次需求属于哪个子项目
-5. 棕地项目：读取 docs/<project>/scan/ 下的 STRUCTURE.md、CONVENTIONS.md、ARCHITECTURE.md
+5. 棕地项目：读取 .sillyspec/docs/<project>/scan/ 下的 STRUCTURE.md、CONVENTIONS.md、ARCHITECTURE.md
 6. 查看进行中的变更：\`ls .sillyspec/changes/ | grep -v archive\`
 
 ### 输出
@@ -173,22 +173,47 @@ export const definition = {
 2. 复杂项目：每段 200-300 字，逐段展示
 3. 每段展示后等待用户确认
 4. 收集修改意见，调整设计
+5. 确认设计后，确定变更名（格式：\`YYYY-MM-DD-<简短描述>\`，例如 \`2026-05-13-user-auth\`）
 
 ### 输出
-用户确认的完整设计方案
+用户确认的完整设计方案 + 变更名
 
 ### 注意
 - 不要一次输出大段文字
-- 逐段确认，确保用户跟上`,
+- 逐段确认，确保用户跟上
+- 变更名必须以当天日期开头（YYYY-MM-DD-），后跟英文短横线分隔的简短描述`,
       outputHint: '用户确认的设计方案',
       optional: false
     },
+    {
+      name: 'HTML 原型生成',
+      prompt: `为设计方案生成可交互的 HTML 原型，帮助用户可视化确认。
+
+### 操作
+1. 判断本次设计是否适合生成 HTML 原型：
+   - 适合：有 UI 组件/布局/交互流程/状态转换/架构图
+   - 不适合：纯后端逻辑/配置修改/无可视化意义
+2. 如果适合，生成一个独立的 HTML 文件（内联 CSS + JS），保存到：
+   \`.sillyspec/changes/<变更名>/prototype-<名称>.html\`（变更名格式：YYYY-MM-DD-<简短描述>）
+3. 原型要求：
+   - 单文件，浏览器直接打开
+   - 展示关键布局结构和交互流程
+   - 不需要完整功能，重点是让用户确认设计方向
+   - 使用 ASCII/流程图/线框图风格，不需要精美 UI
+4. 展示给用户确认设计方向
+
+### 输出
+HTML 原型文件路径（或"跳过"如果不适合）`,
+      outputHint: '原型文件路径或跳过',
+      optional: true
+    },
     {
       name: '写设计文档并自审',
       prompt: `撰写 design 文档并进行 AI 自审。
 
 ### 操作
 1. 确认变更目录存在：\`mkdir -p .sillyspec/changes/<变更名>\`（Windows 用 \`mkdir .sillyspec\\changes\\<变更名>\` 或 PowerShell \`New-Item -ItemType Directory -Force -Path .sillyspec/changes/<变更名>\`）
+   - 变更名格式必须为 \`YYYY-MM-DD-<简短描述>\`（如 \`2026-05-13-user-auth\`）
 2. 将确认的设计写入 \`.sillyspec/changes/<变更名>/design.md\`
 3. 自审检查：
    - 需求覆盖：是否完整覆盖 Step 6 确认的需求
@@ -220,7 +245,7 @@ design.md 文件路径 + 自审结果
    - **proposal.md**：动机、变更范围、不在范围内、成功标准
    - **requirements.md**：功能需求、用户场景（Given/When/Then 格式）、非功能需求
    - **tasks.md**：任务列表（只列名称和对应文件路径，细节在 plan 阶段展开）
-   - \`git add .sillyspec/\` — **不要 commit**
+   - \`git add .sillyspec/\` — 暂存规范文件（不要 commit）
 
 ### 输出
 所有规范文件路径

package/src/stages/execute.js

@@ -69,6 +69,73 @@ Wave 分组 + 模型分配 + 确认模式 + 知识库匹配结果
   }
 ]
 
+// 全局验收步骤定义
+const acceptanceSteps = [
+  {
+    name: '对照设计检查',
+    mode: 'acceptance',
+    prompt: `对照 design.md 检查所有实现是否与设计一致。
+
+### 执行方式
+本步骤由当前 agent 汇总执行，不需要为每个检查项启动独立子代理。
+如需深入验证某个模块，可启动单个 QA 子代理统一处理。
+
+### 操作
+1. 读取 design.md（技术方案）
+2. 逐一对照 design.md 中的设计要点与实际代码实现
+3. 检查接口签名、数据结构、模块划分是否一致
+4. 记录偏差项（偏差 ≠ 错误，可能是合理的实现调整）
+
+### 输出
+检查清单：每项设计要点的实现状态 ✅/⚠️/❌ + 偏差说明`,
+    outputHint: '设计对照检查清单',
+    optional: false
+  },
+  {
+    name: '运行测试',
+    mode: 'acceptance',
+    prompt: `运行所有测试，验证代码质量。
+
+### 执行方式
+本步骤由当前 agent 执行，不需要启动独立子代理。
+
+### 操作
+1. 读取 local.yaml 获取构建和测试命令
+2. 运行测试套件（单元测试、集成测试）
+3. 运行 lint 检查
+4. 如果有测试失败 → 分析原因，标注是代码问题还是测试本身的问题
+5. 汇总测试结果
+
+### 输出
+测试结果摘要：通过/失败/跳过数量 + 失败项分析`,
+    outputHint: '测试结果摘要',
+    optional: false
+  },
+  {
+    name: '代码审查',
+    mode: 'acceptance',
+    prompt: `对本次变更进行代码审查。
+
+### 执行方式
+本步骤由当前 agent 或一个 QA agent 汇总执行，不需要为每个文件启动独立子代理。
+
+### 操作
+1. 检查 git diff 查看所有变更
+2. 审查要点：
+   - 代码风格是否符合 CONVENTIONS.md
+   - 是否有明显的 bug 或安全漏洞
+   - 是否有未处理的 TODO/FIXME
+   - 错误处理是否完善
+   - 是否有冗余代码或可简化的逻辑
+3. 对照 ARCHITECTURE.md 检查架构合规性
+
+### 输出
+审查结果：问题列表（严重程度 + 建议修复方式）+ 总体评价`,
+    outputHint: '代码审查结果',
+    optional: true
+  }
+]
+
 // 固定后缀步骤定义
 const fixedSuffix = [
   {
@@ -90,11 +157,10 @@ const fixedSuffix = [
     prompt: `所有任务完成后的收尾。
 
 ### 操作
-1. 询问用户下一步：
-   - 验证 → sillyspec run verify
-   - 归档 → /sillyspec:archive
-   - 继续开发
-2. 提示 git add 暂存变更
+1. 建议下一步：
+   - 运行 \`sillyspec run verify\` 进行验证（验证通过后才能归档）
+   - 如果发现问题需要修复，先修复再验证
+   - 用户也可以选择继续开发（不验证）
 
 ### 输出
 用户选择 + 下一步命令
@@ -168,38 +234,54 @@ function parseWavesFromPlan(planContent) {
 }
 
 /**
- * 为 Wave 生成 prompt
+ * 为 Wave 生成 prompt（强制子代理执行）
  */
 function buildWavePrompt(wave, waveIndex, changeDir) {
+  // 构建任务摘要（不再内联完整蓝图，减少上下文污染）
+  const taskSummary = wave.tasks.map((t, ti) => {
+    const taskNum = String(t.index || (ti + 1)).padStart(2, '0')
+    const taskRelPath = changeDir
+      ? `.sillyspec/changes/${path.basename(changeDir)}/tasks/task-${taskNum}.md`
+      : `task-${taskNum}.md`
+    const fileInfo = t.file ? ` (${t.file})` : ''
+    return `task-${taskNum}: ${t.name}${fileInfo} → ${taskRelPath}`
+  }).join('\n')
+
   const taskList = wave.tasks.map((t, ti) => {
     const taskNum = String(t.index || (ti + 1)).padStart(2, '0')
-    const taskFile = changeDir ? `${changeDir}/tasks/task-${taskNum}.md` : ''
-    const taskFileExists = taskFile && existsSync(taskFile)
     let s = `- [ ] ${t.name}`
     if (t.file) s += ` (${t.file})`
-    if (taskFileExists) {
-      let taskContent = ''
-      try { taskContent = readFileSync(taskFile, 'utf8').trim() } catch { taskContent = '（无法读取任务蓝图文件）' }
-      s += `
-\n### 📋 任务蓝图（task-${taskNum}.md）\n${taskContent}`
-    }
-    if (t.reference) s += `\n  参考: ${t.reference}`
-    if (t.steps) s += `\n  步骤: ${t.steps}`
     return s
   }).join('\n')
-  const { join } = path
-const hasTaskBlueprints = changeDir && existsSync(join(changeDir, 'tasks'))
-  const taskBlueprintRule = hasTaskBlueprints
-    ? '每个任务有独立的 task-N.md 蓝图——只做蓝图里写的事，不要实现蓝图之外的功能。如果蓝图有问题，**停下来反馈**，不要自己改。问题归因：实现困难 → task 蓝图没写好 → plan 没做好 → design 有缺陷。'
-    : '如果发现 plan 不合理，**停下来反馈**，不要自己改方案。问题归因：实现困难 → plan 没做好 → design 有缺陷。'
+
   return `## Wave ${waveIndex}: 执行以下任务
 
+## 执行方式（必须严格遵守）
+
+**每个任务必须由独立子代理执行，你不要自己写代码。**
+
+你的角色是调度者 + 审查者：
+1. 为每个任务启动一个子代理（Agent tool），同 Wave 内可并行
+2. 子代理完成后审查结果
+3. 勾选 plan.md 中的 checkbox
+4. 记录改动文件和测试结果
+
+### 任务摘要（按需读取完整蓝图）
+为每个任务启动子代理时，**只需告知任务目标和蓝图文件路径，让子代理按需读取**：
+
+${taskSummary}
+
+子代理 prompt 要点：
+1. 任务目标（简短描述）
+2. 蓝图文件路径（让子代理自行读取详情）
+3. 编码铁律：先读后写、TDD、不编造方法、只做蓝图里写的事
+
 ### Wave 开始前
 1. 读取 design.md 的「编码铁律」章节（如果存在），严格遵守
 2. 读取 plan.md 了解全局任务划分和依赖关系
-2. 确认本 Wave 的输入/输出契约（前置 Wave 产出了什么，本 Wave 需要消费什么）
-3. 检查前置 Wave 的产出是否完整（文件是否存在、测试是否通过）
-4. **上下文分层加载**：
+3. 确认本 Wave 的输入/输出契约（前置 Wave 产出了什么，本 Wave 需要消费什么）
+4. 检查前置 Wave 的产出是否完整（文件是否存在、测试是否通过）
+5. **上下文分层加载**：
    - 🔥 热上下文：design.md 编码铁律 + 当前 Wave 任务（必须加载）
    - 🌡️ 温上下文：CONVENTIONS.md + ARCHITECTURE.md（需要时加载）
    - ❄️ 冷上下文：其他变更的 design.md、历史 plan.md（不要主动加载，除非明确需要）
@@ -207,26 +289,23 @@ const hasTaskBlueprints = changeDir && existsSync(join(changeDir, 'tasks'))
 ### 本 Wave 任务
 ${taskList}
 
-### 执行要求
-1. 按任务顺序执行，同一 Wave 内任务可并行
-2. 铁律：先读后写、grep 确认方法存在、不编造、TDD
-3. **禁止发散思维**：你是代码搬运工，严格按任务描述执行，不增不减不改。${taskBlueprintRule}
-4. **Reverse Sync**：发现 Bug 或实现与 design.md/task-N.md 不一致时，先检查是代码错了还是文档有遗漏，有遗漏则先修文档再修代码。
-4. **不要频繁编译！** 编译很慢，只在以下情况运行：
+### 调度要求
+1. 同一 Wave 内任务可并行启动子代理
+2. **Reverse Sync**：子代理报告实现与 design.md 不一致时，先检查是代码错了还是文档有遗漏
+3. **不要频繁编译！** 编译很慢，只在以下情况运行：
    - 写了大量代码后需要验证语法正确性
    - 最后一个 Wave 完成后做一次全量编译验证
    - 用户明确要求编译时
-5. 单个任务完成后只跑**对应模块的单元测试**（TDD 绿灯确认），不要跑全量编译
-6. 每个任务完成后：
-   - 勾选 task-N.md 中的验收标准 checkbox
+4. 每个任务完成后：
    - 勾选 plan.md / tasks.md 中对应任务的 checkbox
    - 记录改动文件和测试结果
-7. 遇到 BLOCKED → 记录原因，选择：重试/跳过/停止
+5. 遇到 BLOCKED → 记录原因，选择：重试/跳过/停止
 
 ### 完成后
 运行 sillyspec run execute --done --input "用户原始反馈" --output "Wave ${waveIndex} 结果摘要"`
 }
 
+
 /**
  * 动态构建 execute 步骤列表
  * @param {string|null} planFilePath - plan 文件路径，null 则用默认 3 Wave
@@ -253,10 +332,11 @@ export function buildExecuteSteps(planFilePath = null) {
 
   const waveSteps = waves.map((wave, i) => ({
     name: `Wave ${i + 1} 执行`,
+    mode: 'implementation',
     prompt: buildWavePrompt(wave, i + 1, changeDir),
     outputHint: `Wave ${i + 1} 执行结果`,
     optional: false
   }))
 
-  return [...fixedPrefix, ...waveSteps, ...fixedSuffix]
+  return [...fixedPrefix, ...waveSteps, ...acceptanceSteps, ...fixedSuffix]
 }

package/src/stages/explore.js

@@ -0,0 +1,34 @@
+export const definition = {
+  name: 'explore',
+  title: '自由探索',
+  description: '讨论、调研、画图，不写实现代码',
+  auxiliary: true,
+  steps: [
+    {
+      name: '自由探索',
+      prompt: `围绕用户给出的话题做技术探索，不进入实现。
+
+### 操作
+1. 明确探索边界：这次只讨论、调研、画图和识别风险
+2. 如果需要代码库上下文，可以读取：
+   - \`.sillyspec/projects/*.yaml\`
+   - \`.sillyspec/docs/<project>/scan/ARCHITECTURE.md\`
+   - \`.sillyspec/docs/<project>/scan/CONVENTIONS.md\`
+   - \`.sillyspec/changes/<change-name>/design.md\`
+3. 可以用 \`rg\` / \`ls\` / \`cat\` 调查已有结构和集成点
+4. 输出 2-3 个有价值方向、关键风险和下一步建议
+5. 如果用户要求保存结论，先明确保存位置，再写入对应文档
+
+### 输出
+探索结论、选项对比、风险清单或 ASCII 图
+
+### 铁律
+- 不写实现代码
+- 不安装依赖
+- 不修改文件，除非用户明确要求保存探索结论
+- 不强行推进到 brainstorm/plan/execute`,
+      outputHint: '探索结论',
+      optional: false
+    }
+  ]
+}

package/src/stages/index.js

@@ -5,22 +5,27 @@ import { definition as execute } from './execute.js'
 import { definition as verify } from './verify.js'
 import { definition as scan } from './scan.js'
 import { definition as quick } from './quick.js'
+import { definition as explore } from './explore.js'
 import { definition as archive } from './archive.js'
 import { definition as status } from './status.js'
 import { definition as doctor } from './doctor.js'
 
+// 标记辅助阶段
+const auxiliaryFlag = { auxiliary: true }
+
 export const stageRegistry = {
   brainstorm,
   propose,
   plan,
   execute,
   verify,
-  scan,
-  quick,
-  archive,
-  status,
-  doctor
+  scan: { ...scan, ...auxiliaryFlag },
+  quick: { ...quick, ...auxiliaryFlag },
+  explore: { ...explore, ...auxiliaryFlag },
+  archive: { ...archive, ...auxiliaryFlag },
+  status: { ...status, ...auxiliaryFlag },
+  doctor: { ...doctor, ...auxiliaryFlag }
 }
 
 // 辅助命令（在没有 progress.json 时也可执行）
-export const auxiliaryStages = ['scan', 'quick', 'archive', 'status', 'doctor']
+export const auxiliaryStages = ['scan', 'quick', 'explore', 'archive', 'status', 'doctor']