sillyspec 3.8.6 → 3.9.0

package/src/step.js

@@ -0,0 +1,543 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync, statSync, rmSync } from 'fs';
+import { join, resolve } from 'path';
+import { randomBytes } from 'crypto';
+
+// ── 简易 YAML 工具 ──
+
+function parseYaml(text) {
+  const result = {};
+  for (const line of text.split('\n')) {
+    const trimmed = line.trimStart();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const m = trimmed.match(/^(\w[\w-]*):\s*(.*)/);
+    if (m) {
+      const key = m[1];
+      const val = m[2].trim();
+      if (val === '' || val === '[]') result[key] = val === '[]' ? [] : '';
+      else if (val.startsWith('[')) result[key] = val.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
+      else if (/^\d+$/.test(val)) result[key] = parseInt(val, 10);
+      else result[key] = val;
+    }
+  }
+  return result;
+}
+
+function parseManifest(text) {
+  const lines = text.split('\n');
+  const result = { phase: '', description: '', requires: [], steps: [] };
+  let inSteps = false;
+  let currentStep = null;
+
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    if (inSteps && trimmed.startsWith('- file:')) {
+      if (currentStep) result.steps.push(currentStep);
+      currentStep = { file: '', name: '' };
+      currentStep.file = trimmed.match(/^- file:\s*(.+)/)?.[1]?.trim() || '';
+      continue;
+    }
+    if (inSteps && currentStep && trimmed.startsWith('name:')) {
+      currentStep.name = trimmed.match(/^name:\s*(.+)/)?.[1]?.trim() || '';
+      continue;
+    }
+    if (inSteps && !trimmed.startsWith('-') && !trimmed.startsWith(' ')) {
+      if (currentStep) result.steps.push(currentStep);
+      currentStep = null;
+      inSteps = false;
+    }
+
+    if (trimmed.startsWith('phase:')) result.phase = trimmed.match(/^phase:\s*(.+)/)?.[1]?.trim() || '';
+    else if (trimmed.startsWith('description:')) result.description = trimmed.match(/^description:\s*(.+)/)?.[1]?.trim() || '';
+    else if (trimmed.startsWith('requires:')) {
+      const m = trimmed.match(/^requires:\s*\[?(.*?)\]?$/);
+      result.requires = m ? m[1].split(',').map(s => s.trim()).filter(Boolean) : [];
+    }
+    else if (trimmed.startsWith('steps:')) inSteps = true;
+  }
+  if (currentStep) result.steps.push(currentStep);
+  return result;
+}
+
+function toYaml(obj) {
+  return Object.entries(obj).map(([k, v]) => {
+    if (Array.isArray(v)) return `${k}: []`;
+    return `${k}: ${v}`;
+  }).join('\n') + '\n';
+}
+
+// ── 文件操作 ──
+
+function atomicWrite(filePath, content) {
+  const tmpPath = filePath + '.tmp.' + process.pid;
+  writeFileSync(tmpPath, content, 'utf8');
+  writeFileSync(filePath, content, 'utf8');
+  try { unlinkSync(tmpPath); } catch {}
+}
+
+function findSillyspecDir(dir) {
+  const p = join(dir, '.sillyspec');
+  if (existsSync(p)) return p;
+  return null;
+}
+
+function getAvailablePhases(sillyDir) {
+  const stepsDir = join(sillyDir, 'steps');
+  if (!existsSync(stepsDir)) return [];
+  return readdirSync(stepsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && existsSync(join(stepsDir, d.name, 'manifest.yaml')))
+    .map(d => d.name);
+}
+
+// ── 会话管理 ──
+
+function getSessionId(dir, explicitId) {
+  if (explicitId) return explicitId;
+  if (process.env.SILLYSPEC_SESSION) return process.env.SILLYSPEC_SESSION;
+  const markerFile = join(dir, '.sillyspec', '.session');
+  if (existsSync(markerFile)) return readFileSync(markerFile, 'utf8').trim();
+  // 生成新 ID 并原子写入
+  const id = randomBytes(4).toString('hex');
+  const sillyDir = join(dir, '.sillyspec');
+  try {
+    writeFileSync(markerFile, id + '\n', { flag: 'wx' });
+  } catch {
+    // 已存在，读取
+    return readFileSync(markerFile, 'utf8').trim();
+  }
+  return id;
+}
+
+function getProgress(sillyDir, sessionId) {
+  const pFile = join(sillyDir, 'sessions', sessionId, 'progress.yaml');
+  if (!existsSync(pFile)) return {};
+  return parseYaml(readFileSync(pFile, 'utf8'));
+}
+
+function saveProgress(sillyDir, sessionId, progress) {
+  const pDir = join(sillyDir, 'sessions', sessionId);
+  mkdirSync(pDir, { recursive: true });
+  atomicWrite(join(pDir, 'progress.yaml'), toYaml(progress));
+}
+
+function updateLastActive(sillyDir, sessionId) {
+  const pDir = join(sillyDir, 'sessions', sessionId);
+  mkdirSync(pDir, { recursive: true });
+  atomicWrite(join(pDir, 'last-active'), Date.now().toString());
+}
+
+function getLastActive(sillyDir, sessionId) {
+  const f = join(sillyDir, 'sessions', sessionId, 'last-active');
+  if (!existsSync(f)) return null;
+  try { return parseInt(readFileSync(f, 'utf8').trim(), 10); } catch { return null; }
+}
+
+// ── 时间格式化 ──
+
+function timeAgo(ts) {
+  if (!ts) return '未知';
+  const diff = Date.now() - ts;
+  const mins = Math.floor(diff / 60000);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// ── 核心逻辑 ──
+
+function getManifest(sillyDir, phase) {
+  const mFile = join(sillyDir, 'steps', phase, 'manifest.yaml');
+  if (!existsSync(mFile)) return null;
+  return parseManifest(readFileSync(mFile, 'utf8'));
+}
+
+function checkPhaseComplete(sillyDir, phase, progress) {
+  const m = getManifest(sillyDir, phase);
+  if (!m) return false;
+  const p = parseInt(progress[phase], 10) || 0;
+  return p >= m.steps.length;
+}
+
+function formatNextOutput(manifest, stepNum, stepFile) {
+  return `---\nphase: ${manifest.phase}\nstep: ${stepNum}/${manifest.steps.length}\nname: ${manifest.steps[stepNum - 1].name}\n---\n\n${stepFile}\n\n---\n完成后请执行: sillyspec step ${manifest.phase} --next\n`;
+}
+
+function handleNext(dir, sillyDir, phase, sessionId, json) {
+  const manifest = getManifest(sillyDir, phase);
+  if (!manifest) {
+    return { ok: false, error: `❌ 阶段 "${phase}" 不存在`, available: getAvailablePhases(sillyDir) };
+  }
+
+  // 前置依赖提醒
+  for (const req of manifest.requires) {
+    const progress = getProgress(sillyDir, sessionId);
+    if (!checkPhaseComplete(sillyDir, req, progress)) {
+      console.log(`⚠️  建议先完成 ${req} 阶段`);
+    }
+  }
+
+  const progress = getProgress(sillyDir, sessionId);
+  let p = parseInt(progress[phase], 10);
+  if (isNaN(p) || p < 0) {
+    console.log(`⚠️  progress 值非法，已重置为 0`);
+    p = 0;
+    progress[phase] = 0;
+    saveProgress(sillyDir, sessionId, progress);
+  }
+
+  const total = manifest.steps.length;
+
+  if (p >= total) {
+    if (json) return { ok: true, done: true, phase, total };
+    console.log(`DONE ✅`);
+    return { ok: true, done: true, phase, total };
+  }
+
+  // 确定要分发的步骤
+  let nextStep;
+  if (p === 0) {
+    nextStep = 1;
+  } else {
+    nextStep = p + 1;
+  }
+
+  if (nextStep > total) {
+    if (json) return { ok: true, done: true, phase, total };
+    console.log(`DONE ✅`);
+    return { ok: true, done: true, phase, total };
+  }
+
+  // 标记进度
+  progress[phase] = nextStep;
+  saveProgress(sillyDir, sessionId, progress);
+  updateLastActive(sillyDir, sessionId);
+
+  // 读取步骤文件
+  const stepFile = join(sillyDir, 'steps', phase, manifest.steps[nextStep - 1].file);
+  if (!existsSync(stepFile)) {
+    return { ok: false, error: `❌ 步骤文件不存在: ${manifest.steps[nextStep - 1].file}` };
+  }
+  const content = readFileSync(stepFile, 'utf8');
+
+  if (json) {
+    return { ok: true, done: false, phase, step: nextStep, total, name: manifest.steps[nextStep - 1].name, content };
+  }
+
+  console.log(formatNextOutput(manifest, nextStep, content));
+  return { ok: true, done: false, phase, step: nextStep, total, name: manifest.steps[nextStep - 1].name };
+}
+
+function handleJump(dir, sillyDir, phase, target, sessionId, json) {
+  const manifest = getManifest(sillyDir, phase);
+  if (!manifest) {
+    return { ok: false, error: `❌ 阶段 "${phase}" 不存在`, available: getAvailablePhases(sillyDir) };
+  }
+
+  const total = manifest.steps.length;
+  if (target < 1 || target > total) {
+    return { ok: false, error: `❌ 步骤 ${target} 越界（有效范围: 1-${total}）` };
+  }
+
+  const progress = getProgress(sillyDir, sessionId);
+  progress[phase] = target;
+  saveProgress(sillyDir, sessionId, progress);
+  updateLastActive(sillyDir, sessionId);
+
+  const stepFile = join(sillyDir, 'steps', phase, manifest.steps[target - 1].file);
+  if (!existsSync(stepFile)) {
+    return { ok: false, error: `❌ 步骤文件不存在: ${manifest.steps[target - 1].file}` };
+  }
+  const content = readFileSync(stepFile, 'utf8');
+
+  if (json) {
+    return { ok: true, phase, step: target, total, name: manifest.steps[target - 1].name, content };
+  }
+
+  console.log(formatNextOutput(manifest, target, content));
+  return { ok: true, phase, step: target, total, name: manifest.steps[target - 1].name };
+}
+
+function handleStatus(sillyDir, sessionId, json) {
+  const phases = getAvailablePhases(sillyDir);
+  const progress = getProgress(sillyDir, sessionId);
+  const results = [];
+
+  for (const phase of phases) {
+    const manifest = getManifest(sillyDir, phase);
+    const p = parseInt(progress[phase], 10) || 0;
+    const total = manifest ? manifest.steps.length : 0;
+    const name = manifest ? (manifest.steps[Math.max(0, p - 1)]?.name || '') : '';
+    results.push({ phase, progress: p, total, name });
+  }
+
+  if (json) return { ok: true, phases: results };
+
+  for (const r of results) {
+    if (r.total === 0) {
+      console.log(`${r.phase}: 未开始`);
+    } else if (r.progress === 0) {
+      console.log(`${r.phase}: 未开始`);
+    } else if (r.progress >= r.total) {
+      console.log(`${r.phase}: 已完成 ✅`);
+    } else {
+      console.log(`${r.phase}: 步骤 ${r.progress}/${r.total}（${r.name}）`);
+    }
+  }
+  return { ok: true, phases: results };
+}
+
+function handleList(sillyDir, phase, sessionId, json) {
+  const manifest = getManifest(sillyDir, phase);
+  if (!manifest) {
+    return { ok: false, error: `❌ 阶段 "${phase}" 不存在`, available: getAvailablePhases(sillyDir) };
+  }
+
+  const progress = getProgress(sillyDir, sessionId);
+  const current = parseInt(progress[phase], 10) || 0;
+  const results = [];
+
+  if (!json) console.log(`# ${phase} — ${manifest.description}`);
+
+  for (let i = 0; i < manifest.steps.length; i++) {
+    const num = i + 1;
+    const s = manifest.steps[i];
+    let status = '';
+    if (num < current) status = '✅';
+    else if (num === current) status = '← 当前';
+    results.push({ step: num, name: s.name, status: num < current ? 'done' : num === current ? 'current' : 'pending' });
+
+    if (!json) {
+      console.log(`  ${num}. ${s.name.padEnd(16)}${status}`);
+    }
+  }
+  return { ok: true, phase, description: manifest.description, steps: results };
+}
+
+function handleSessions(sillyDir, json) {
+  const sessionsDir = join(sillyDir, 'sessions');
+  if (!existsSync(sessionsDir)) {
+    if (json) return { ok: true, sessions: [] };
+    console.log('暂无会话');
+    return { ok: true, sessions: [] };
+  }
+
+  const dirs = readdirSync(sessionsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  if (dirs.length === 0) {
+    if (json) return { ok: true, sessions: [] };
+    console.log('暂无会话');
+    return { ok: true, sessions: [] };
+  }
+
+  const phases = getAvailablePhases(sillyDir);
+  const results = [];
+
+  for (const sid of dirs) {
+    const progress = getProgress(sillyDir, sid);
+    const last = getLastActive(sillyDir, sid);
+    const phaseSummaries = phases.map(ph => {
+      const manifest = getManifest(sillyDir, ph);
+      const p = parseInt(progress[ph], 10) || 0;
+      const total = manifest ? manifest.steps.length : 0;
+      return { phase: ph, progress: p, total };
+    });
+    const allDone = phaseSummaries.every(ps => ps.total > 0 && ps.progress >= ps.total);
+    results.push({ sessionId: sid, phases: phaseSummaries, lastActive: last, allDone });
+  }
+
+  if (json) return { ok: true, sessions: results };
+
+  for (const r of results) {
+    const phaseStr = r.phases.map(ps => `${ps.phase} ${ps.progress}/${ps.total}`).join('  ');
+    const done = r.allDone ? ' ✅' : '';
+    console.log(`${r.sessionId}  ${phaseStr}  (last: ${timeAgo(r.lastActive)})${done}`);
+  }
+  return { ok: true, sessions: results };
+}
+
+function handleClean(sillyDir, options, json) {
+  const { allDone, olderThan, sessionId: targetSession } = options;
+  const sessionsDir = join(sillyDir, 'sessions');
+  if (!existsSync(sessionsDir)) {
+    if (json) return { ok: true, cleaned: [], dryRun: !targetSession && !allDone && !olderThan };
+    console.log('暂无会话');
+    return { ok: true, cleaned: [], dryRun: true };
+  }
+
+  const dirs = readdirSync(sessionsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  const phases = getAvailablePhases(sillyDir);
+  const toClean = [];
+
+  for (const sid of dirs) {
+    const progress = getProgress(sillyDir, sid);
+    const last = getLastActive(sillyDir, sid);
+    const isAllDone = phases.every(ph => {
+      const manifest = getManifest(sillyDir, ph);
+      const p = parseInt(progress[ph], 10) || 0;
+      return manifest && p >= manifest.steps.length;
+    });
+    const ageMs = last ? Date.now() - last : Infinity;
+    const ageDays = ageMs / (1000 * 60 * 60 * 24);
+
+    let match = false;
+    if (targetSession) match = sid === targetSession;
+    else if (allDone) match = true;
+    else if (olderThan !== null) match = ageDays >= olderThan;
+
+    toClean.push({ sessionId: sid, allDone: isAllDone, lastActive: last, ageDays, match });
+  }
+
+  // 无参数 = dry-run
+  const isDryRun = !targetSession && !allDone && olderThan === null;
+
+  if (isDryRun) {
+    if (json) return { ok: true, dryRun: true, sessions: toClean.map(s => ({ sessionId: s.sessionId, allDone: s.allDone, lastActive: s.lastActive, ageDays: Math.floor(s.ageDays) })) };
+    console.log('📋 会话列表（dry-run，未执行清理）：');
+    console.log('');
+    for (const s of toClean) {
+      const status = s.allDone ? '✅ 全部完成' : `进行中（${Math.floor(s.ageDays)}天前活跃）`;
+      console.log(`  ${s.sessionId}  ${status}  (last: ${timeAgo(s.lastActive)})`);
+    }
+    return { ok: true, dryRun: true, sessions: toClean };
+  }
+
+  // 执行清理
+  const cleaned = toClean.filter(s => s.match);
+  if (cleaned.length === 0) {
+    if (json) return { ok: true, cleaned: [] };
+    console.log('没有匹配的会话需要清理');
+    return { ok: true, cleaned: [] };
+  }
+
+  for (const s of cleaned) {
+    rmSync(join(sessionsDir, s.sessionId), { recursive: true });
+  }
+
+  if (json) return { ok: true, cleaned: cleaned.map(s => s.sessionId) };
+  console.log(`🗑️  已清理 ${cleaned.length} 个会话:`);
+  for (const s of cleaned) console.log(`  - ${s.sessionId}`);
+  return { ok: true, cleaned: cleaned.map(s => s.sessionId) };
+}
+
+// ── 主入口 ──
+
+export async function cmdStep(dir, args = []) {
+  const sillyDir = findSillyspecDir(dir);
+  if (!sillyDir) {
+    console.log('❌ 未找到 .sillyspec/ 目录，请先执行 sillyspec init');
+    process.exit(1);
+  }
+
+  // 解析参数
+  let json = false;
+  let sessionId = null;
+  let action = null;
+  let phase = null;
+  let jumpTarget = null;
+  let cleanAllDone = false;
+  let cleanOlderThan = null;
+  let cleanSession = null;
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--json') json = true;
+    else if (a === '--session' && args[i + 1]) { sessionId = args[++i]; }
+    else if (a === '--next') action = 'next';
+    else if (a === '--status') action = 'status';
+    else if (a === '--list') action = 'list';
+    else if (a === '--jump' && args[i + 1]) { action = 'jump'; jumpTarget = parseInt(args[++i], 10); }
+    else if (a === '--sessions') action = 'sessions';
+    else if (a === '--clean') {
+      action = 'clean';
+      // 检查后续选项
+      if (args[i + 1] === '--all-done') { cleanAllDone = true; i++; }
+      else if (args[i + 1] === '--session' && args[i + 2]) { cleanSession = args[i + 2]; i += 2; }
+      else if (args[i + 1] === '--older-than' && args[i + 2]) { cleanOlderThan = parseFloat(args[i + 2]); i += 2; }
+    }
+    else if (!a.startsWith('-')) {
+      if (!phase) phase = a;
+    }
+  }
+
+  const sid = getSessionId(dir, sessionId);
+
+  // 如果 phase 提供但步骤目录不存在
+  if (phase && action && action !== 'sessions' && action !== 'clean') {
+    const stepsDir = join(sillyDir, 'steps');
+    if (!existsSync(stepsDir) || !existsSync(join(stepsDir, phase, 'manifest.yaml'))) {
+      const available = getAvailablePhases(sillyDir);
+      if (json) {
+        console.log(JSON.stringify({ ok: false, error: `阶段 "${phase}" 不存在`, available }));
+        process.exit(1);
+      }
+      console.log(`❌ 阶段 "${phase}" 不存在`);
+      if (available.length > 0) {
+        console.log(`可用阶段: ${available.join(', ')}`);
+      } else {
+        console.log('暂无可用阶段（.sillyspec/steps/ 下无 manifest.yaml）');
+      }
+      process.exit(1);
+    }
+  }
+
+  let result;
+  switch (action) {
+    case 'next':
+      result = handleNext(dir, sillyDir, phase, sid, json);
+      break;
+    case 'jump':
+      result = handleJump(dir, sillyDir, phase, jumpTarget, sid, json);
+      break;
+    case 'status':
+      result = handleStatus(sillyDir, sid, json);
+      break;
+    case 'list':
+      result = handleList(sillyDir, phase, sid, json);
+      break;
+    case 'sessions':
+      result = handleSessions(sillyDir, json);
+      break;
+    case 'clean':
+      result = handleClean(sillyDir, { allDone: cleanAllDone, olderThan: cleanOlderThan, sessionId: cleanSession }, json);
+      break;
+    default:
+      console.log('❌ 请指定操作: --next, --status, --list, --jump <n>, --sessions, --clean');
+      console.log('');
+      console.log('用法:');
+      console.log('  sillyspec step <phase> --next          获取步骤 + 自动推进');
+      console.log('  sillyspec step <phase> --status        查看进度');
+      console.log('  sillyspec step <phase> --list          查看步骤列表');
+      console.log('  sillyspec step <phase> --jump <n>      跳到指定步骤');
+      console.log('  sillyspec step --sessions              查看所有会话');
+      console.log('  sillyspec step --clean                 dry-run 列出可清理会话');
+      console.log('  sillyspec step --clean --all-done      清理所有阶段完成的会话');
+      console.log('  sillyspec step --clean --session <id>  清理指定会话');
+      console.log('  sillyspec step --clean --older-than <days>  清理 N 天前的会话');
+      console.log('');
+      console.log('选项:');
+      console.log('  --session <id>    指定会话 ID');
+      console.log('  --json            输出 JSON');
+      process.exit(1);
+  }
+
+  if (result && !result.ok) {
+    if (json) {
+      console.log(JSON.stringify(result));
+    } else if (result.error) {
+      console.log(result.error);
+    }
+    process.exit(1);
+  }
+
+  if (json && result) {
+    console.log(JSON.stringify(result));
+  }
+}

package/templates/archive.md

@@ -109,7 +109,6 @@ git log --oneline --no-merges --since="<创建时间>" -- "*.ts" "*.js" "*.vue"
 
 - **tasks.md：** 确保所有 checkbox 都已勾选 `[x]`
 - **ROADMAP.md**（如存在）：标记对应 Phase 已完成
-- **STATE.md：** 清除当前变更信息，历史记录追加归档完成（含精确到秒的时间戳）
 - **Git 暂存：** `git add .sillyspec/`
 
 **工作区模式下：** 如果变更属于某个子项目，cd 到子项目目录执行 git add。工作区根目录无 git 则跳过。

package/templates/brainstorm.md

@@ -12,32 +12,6 @@
 - ❌ 一次性抛出多个问题（必须逐个等待回答）
 - ❌ 用户确认前自行推进到 plan 或任何后续阶段
 
-## 状态检查（必须先执行）
-
-```bash
-cat .sillyspec/STATE.md 2>/dev/null
-```
-
-- phase 为 `brainstorm` 或无 STATE.md → ✅ 继续
-- 其他 phase → 提示用户当前阶段，建议先完成
-
-## 进度恢复检查（必须先执行）
-
-1. 读取 `.sillyspec/.runtime/progress.json`（使用 read 工具）
-2. 如果文件存在且 `currentStage` 为 `brainstorm`：
-   a. 按 resume-dialog.md 模板向用户展示恢复信息（见下方）
-   b. 用户确认后，将 `resumeCount` +1，更新 `lastActiveAt`，写入 progress.json
-   c. 将已完成步骤的结论作为「已确认的决策，无需重新讨论」注入上下文
-   d. 从 `inProgressStep.id` 继续，**禁止回头重新讨论已完成步骤**
-3. 如果文件不存在或 `currentStage` 不是 `brainstorm`：正常启动
-
-### 恢复对话规则
-- 首次恢复（resumeCount < 3）：友好欢迎，展示进度条和关键结论
-- 频繁中断（resumeCount >= 3）：建议重新开始，但尊重用户选择
-- 长时间中断（距 lastActiveAt > 24h）：先回顾上次聊了什么，再问是否继续
-- 恢复时说「欢迎回来」而非「检测到中断」
-- 参考模板：`.sillyspec/.runtime/templates/resume-dialog.md`
-
 ## 用户想法
 $ARGUMENTS
 
@@ -45,19 +19,17 @@ $ARGUMENTS
 
 ## Checklist（必须按顺序完成，不允许跳步或并行）
 
-- [ ] **Step 1** — 加载项目上下文 → 保存进度
-- [ ] **Step 2** — 协作与复用检查（同名变更 + 全局模板）→ 保存进度
-- [ ] **Step 3** — 原型/设计图分析（如有）→ 保存进度
-- [ ] **Step 4** — 评估需求范围，复杂需求拆分子项目/阶段，生成 MASTER.md → 保存进度
-- [ ] **Step 5** — 对话式探索（一次一个问题，2-3 轮内完成）→ 保存进度
-- [ ] **Step 6** — 提出 2-3 个方案并推荐 → 保存进度
-- [ ] **Step 7** — 分段展示设计，逐段确认 → 保存进度
-- [ ] **Step 8** — 写设计文档并保存 → 保存进度
-- [ ] **Step 9** — AI 自审（对照约束检查）→ 保存进度
-- [ ] **Step 10** — 用户确认设计方案 → 保存进度
-- [ ] **Step 11** — 输出 design.md → 保存进度
-- [ ] **Step 12** — 更新 STATE.md → 保存进度
-- [ ] **Step 13** — 保存最终进度
+- [ ] **Step 1** — 加载项目上下文
+- [ ] **Step 2** — 协作与复用检查（同名变更 + 全局模板）
+- [ ] **Step 3** — 原型/设计图分析（如有）
+- [ ] **Step 4** — 评估需求范围，复杂需求拆分子项目/阶段，生成 MASTER.md
+- [ ] **Step 5** — 对话式探索（一次一个问题，2-3 轮内完成）
+- [ ] **Step 6** — 提出 2-3 个方案并推荐
+- [ ] **Step 7** — 分段展示设计，逐段确认
+- [ ] **Step 8** — 写设计文档并保存
+- [ ] **Step 9** — AI 自审（对照约束检查）
+- [ ] **Step 10** — 用户确认设计方案
+- [ ] **Step 11** — 输出 design.md
 
 **终态：** brainstorm 完成后唯一出口是 `/sillyspec:plan`。不允许直接进入 execute 或任何代码操作。
 
@@ -191,50 +163,8 @@ git add .sillyspec/changes/<变更名>/MASTER.md
 
 用户确认后，确认 design.md 已包含完整内容（动机、需求、方案、文件变更、代码风格参照）。如 Step 8 已保存则无需重复。
 
-### Step 12: 更新 STATE.md
-
-自动更新 `.sillyspec/STATE.md`（不存在则创建）：当前变更、阶段、下一步 `/sillyspec:plan`、关键决策、历史记录。不需要 Git 提交。
-
-### Step 13: 保存最终进度
-
-1. 更新 `.sillyspec/.runtime/progress.json`：
-   - `stages.brainstorm.status` 设为 `completed`
-   - 写入 `stageSummary`（2-3 句总结核心设计决策）
-   - `currentStage` 更新为 `plan`
-   - `checkpoint` 设为「brainstorm 完成，等待 plan」
-2. Append `user-inputs.md` 最终记录
-3. 告知用户：「brainstorm 完成 ✅ 进度已保存，下一步 /sillyspec:plan」
-
 ## 关键原则
 - YAGNI — 无情砍掉不需要的功能
 - 总是探索替代方案
 - 设计可以很短，但必须存在
 - "简单"的项目更需要设计——未检视的假设造成最大浪费
-
-## 进度保存规则（⚠️ HARD-GATE）
-
-**每步完成后必须执行，不允许跳过：**
-
-1. 使用 write 工具更新 `.sillyspec/.runtime/progress.json`
-2. 将当前步骤 ID 加入 `completedSteps`
-3. 在 `summaries` 中写入本步结构化摘要：
-   - `conclusion`（1-2句核心结论，必填）
-   - `decisions`（用户确认的决策列表）
-   - `rejectedAlternatives`（被否方案 + 简要理由）
-   - `userMessages`（用户影响决策的原话）
-   - `openQuestions`（遗留问题）
-   - `keyEntities`（涉及的关键实体/概念）
-4. 更新 `checkpoint`（一句话描述）
-5. 刷新 `lastActiveAt`（ISO 格式）
-6. `_version` +1
-7. Append `.sillyspec/.runtime/user-inputs.md`（格式见 progress-format.md）
-8. 对用户说：「✅ 第X步完成，进度已保存。」
-
-**下步启动检查：** 进入下一步前，先确认 progress.json 的 currentStep 已更新。如果发现未保存，立即补保存。
-
-## 多任务并行提醒
-
-如果用户在 brainstorm 过程中临时要求执行 quick 任务：
-- quick 任务不写入 progress.json，不影响当前 brainstorm 状态
-- quick 完成后，brainstorm 从断点继续
-- 告知用户：「quick 任务会独立执行，brainstorm 进度不受影响」

package/templates/commit.md

@@ -54,10 +54,8 @@ cat "$LATEST/tasks.md" 2>/dev/null
 ```
 筛选时间戳 > LAST_COMMIT_TIME 的已勾选 task。
 
-**来源 C — 阶段产出（scan/brainstorm/propose/plan/archive 等）：**
 检查 `.sillyspec/` 下新增或修改的文件，根据路径识别来源阶段：
 - `docs/*/scan/*.md` → scan 产出
-- `changes/<name>/proposal.md` → propose 产出
 - `changes/<name>/design.md` 或 `tasks.md` → plan 产出
 - `changes/archive/` → archive 产出
 - `specs/*.md` → brainstorm 产出