sillyspec 3.10.5 → 3.10.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.10.5",
+  "version": "3.10.6",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",

package/src/index.js

@@ -136,9 +136,13 @@ async function main() {
       break;
     case 'progress': {
       const pm = new ProgressManager();
+      pm._migrateIfNeeded(dir);
       const subCommand = filteredArgs[1];
       const stageIdx = filteredArgs.indexOf('--stage');
       const stage = stageIdx >= 0 && filteredArgs[stageIdx + 1] ? filteredArgs[stageIdx + 1] : null;
+      // 解析 --change 参数
+      const progChangeIdx = args.indexOf('--change');
+      const progChangeName = progChangeIdx >= 0 && args[progChangeIdx + 1] ? args[progChangeIdx + 1] : null;
 
       switch (subCommand) {
         case 'init':
@@ -146,49 +150,48 @@ async function main() {
           break;
         case 'status':
         case 'show':
-          pm.show(dir);
+          pm.show(dir, progChangeName);
           break;
         case 'validate':
-          await pm.validate(dir);
+          await pm.validate(dir, progChangeName);
           break;
         case 'reset':
-          pm.reset(dir, stage);
+          pm.reset(dir, stage, progChangeName);
           break;
         case 'set-stage': {
           const setStageName = filteredArgs[2];
-          if (!setStageName) { console.log('❌ 用法: sillyspec progress set-stage <stage>'); break; }
-          pm.setStage(dir, setStageName);
+          if (!setStageName) { console.log('❌ 用法: sillyspec progress set-stage <stage> [--change <name>]'); break; }
+          pm.setStage(dir, setStageName, progChangeName);
           break;
         }
         case 'add-step': {
           const addStepStage = filteredArgs[2];
           const addStepName = filteredArgs[3];
-          if (!addStepStage || !addStepName) { console.log('❌ 用法: sillyspec progress add-step <stage> <step-name>'); break; }
-          pm.addStep(dir, addStepStage, addStepName);
+          if (!addStepStage || !addStepName) { console.log('❌ 用法: sillyspec progress add-step <stage> <step-name> [--change <name>]'); break; }
+          pm.addStep(dir, addStepStage, addStepName, progChangeName);
           break;
         }
         case 'update-step': {
           const updStepStage = filteredArgs[2];
           const updStepName = filteredArgs[3];
-          if (!updStepStage || !updStepName) { console.log('❌ 用法: sillyspec progress update-step <stage> <step-name> --status <status> [--output <text>]'); break; }
-          // Parse --status and --output from args
+          if (!updStepStage || !updStepName) { console.log('❌ 用法: sillyspec progress update-step <stage> <step-name> --status <status> [--output <text>] [--change <name>]'); break; }
           let updStatus = null, updOutput = undefined;
           for (let ai = 0; ai < args.length; ai++) {
             if (args[ai] === '--status' && args[ai + 1]) { updStatus = args[ai + 1]; ai++; }
             if (args[ai] === '--output' && args[ai + 1]) { updOutput = args[ai + 1]; ai++; }
           }
-          pm.updateStep(dir, updStepStage, updStepName, { status: updStatus, output: updOutput });
+          pm.updateStep(dir, updStepStage, updStepName, { status: updStatus, output: updOutput }, progChangeName);
           break;
         }
         case 'complete-stage': {
           const compStageName = filteredArgs[2];
           if (!compStageName) { console.log('❌ 用法: sillyspec progress complete-stage <stage>'); break; }
-          pm.completeStage(dir, compStageName);
+          pm.completeStage(dir, compStageName, progChangeName);
           break;
         }
         case 'batch': {
           if (filteredArgs.includes('--status')) {
-            const bp = pm.readBatchProgress(dir);
+            const bp = pm.readBatchProgress(dir, progChangeName);
             if (!bp) { console.log('📭 无批量进度数据'); break; }
             const line = pm._renderBatchProgress(bp);
             console.log(line || '📭 无批量进度数据');
@@ -207,7 +210,7 @@ async function main() {
               console.log('     sillyspec progress batch --status');
               break;
             }
-            pm.updateBatchProgress(dir, batchData);
+            pm.updateBatchProgress(dir, batchData, progChangeName);
             console.log('✅ 批量进度已更新');
           }
           break;

package/src/init.js

@@ -56,7 +56,7 @@ const INJECTION_CONTENT = `## SillySpec — 规范驱动开发
 - 遵循 \`.sillyspec/docs/<project>/scan/CONVENTIONS.md\` 中的代码风格
 
 ### 工作流程
-- 读取 \`.sillyspec/.runtime/progress.json\` 确认当前阶段（使用 \`sillyspec progress show\`）
+- 读取当前变更的 progress.json 确认当前阶段（使用 \`sillyspec progress show\`）
 - 各阶段产出文件位于 \`.sillyspec/changes/<变更名>/\` 下
 `;
 
@@ -141,18 +141,15 @@ async function doInstall(projectDir, tools, subprojects = []) {
     writeFileSync(uncatPath, `# 未分类知识\n\n> execute/quick 执行中发现的坑暂存于此，用户审阅后归类到对应文件并更新 INDEX.md。\n`);
   }
 
-  // 创建 .sillyspec/.runtime/ 目录结构
+  // 创建 .sillyspec/.runtime/ 目录结构（全局状态）
   const runtimeDir = join(projectDir, '.sillyspec', '.runtime');
   for (const sub of ['artifacts', 'history', 'logs', 'templates']) {
     mkdirSync(join(runtimeDir, sub), { recursive: true });
   }
 
-  // 创建初始 progress.json
-  const progressPath = join(runtimeDir, 'progress.json');
-  if (!existsSync(progressPath)) {
-    const pm = new ProgressManager();
-    pm.init(projectDir);
-  }
+  // 创建全局状态文件
+  const pm = new ProgressManager();
+  pm.init(projectDir);
 
   // 创建初始 user-inputs.md
   const inputsPath = join(runtimeDir, 'user-inputs.md');

package/src/progress.js

@@ -1,19 +1,25 @@
 /**
  * SillySpec ProgressManager — 进度恢复管理
  *
- * 纯 Node.js，无外部依赖。管理 .sillyspec/.runtime/progress.json。
+ * 纯 Node.js，无外部依赖。支持多变更并行。
  *
- * Schema v2: { project, currentStage, stages: { [name]: { status, steps, startedAt, completedAt } }, lastActive }
+ * 存储结构（v3）：
+ *   .sillyspec/.runtime/global.json          — 全局状态（项目名、活跃变更列表）
+ *   .sillyspec/changes/<name>/progress.json  — 每个变更独立的阶段/步骤状态
+ *
+ * 向后兼容：如果存在旧的 .sillyspec/.runtime/progress.json，自动迁移。
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, unlinkSync, readdirSync } from 'fs';
 import { join, basename } from 'path';
 
 const RUNTIME_DIR = '.sillyspec/.runtime';
+const CHANGES_DIR = '.sillyspec/changes';
+const GLOBAL_FILE = 'global.json';
 const PROGRESS_FILE = 'progress.json';
-const BACKUP_FILE = 'progress.json.bak';
+const BACKUP_SUFFIX = '.bak';
 
-const CURRENT_VERSION = 2;
+const CURRENT_VERSION = 3;
 const VALID_STAGES = ['scan', 'brainstorm', 'plan', 'execute', 'verify', 'archive', 'quick', 'explore'];
 const VALID_STATUSES = ['pending', 'in-progress', 'completed', 'failed', 'blocked'];
 
@@ -38,18 +44,131 @@ function makeInitialProgress(project) {
   return { _version: CURRENT_VERSION, project: project || '', currentStage: '', currentChange: null, stages, lastActive: null };
 }
 
+function makeInitialGlobal(project) {
+  return { _version: CURRENT_VERSION, project: project || '', activeChanges: [] };
+}
+
 // ── ProgressManager ──
 
 export class ProgressManager {
-  // ── 核心读写 ──
+  // ── 路径工具 ──
 
-  _path(cwd, ...parts) {
+  _runtimePath(cwd, ...parts) {
     return join(cwd, RUNTIME_DIR, ...parts);
   }
 
-  read(cwd) {
-    const progressPath = this._path(cwd, PROGRESS_FILE);
-    const backupPath = this._path(cwd, BACKUP_FILE);
+  _changePath(cwd, changeName, ...parts) {
+    return join(cwd, CHANGES_DIR, changeName, ...parts);
+  }
+
+  _ensureRuntimeDir(cwd) {
+    const runtimeDir = this._runtimePath(cwd);
+    if (!existsSync(runtimeDir)) {
+      mkdirSync(runtimeDir, { recursive: true });
+      for (const d of ['artifacts', 'history', 'logs', 'templates']) {
+        mkdirSync(join(runtimeDir, d), { recursive: true });
+      }
+    }
+  }
+
+  _ensureChangeDir(cwd, changeName) {
+    const dir = this._changePath(cwd, changeName);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+
+  // ── 向后兼容：检测并迁移旧版 progress.json ──
+
+  _migrateIfNeeded(cwd) {
+    const oldPath = this._runtimePath(cwd, PROGRESS_FILE);
+    const globalPath = this._runtimePath(cwd, GLOBAL_FILE);
+
+    // 新版已存在，不迁移
+    if (existsSync(globalPath)) return;
+
+    // 旧版不存在，不迁移
+    if (!existsSync(oldPath)) return;
+
+    const oldData = this._parseWithRecovery(readFileSync(oldPath, 'utf8'));
+    if (!oldData) return;
+
+    console.log('🔄 检测到旧版 progress.json，正在迁移到按变更隔离存储...');
+
+    // 提取变更名
+    const changeName = oldData.currentChange || 'default';
+
+    // 迁移：将旧 progress.json 复制到变更目录
+    this._ensureChangeDir(cwd, changeName);
+    const newChangePath = this._changePath(cwd, changeName, PROGRESS_FILE);
+    if (!existsSync(newChangePath)) {
+      writeFileSync(newChangePath, JSON.stringify(oldData, null, 2) + '\n');
+    }
+
+    // 创建全局文件
+    const globalData = makeInitialGlobal(oldData.project);
+    globalData.activeChanges = [changeName];
+    if (!existsSync(globalPath)) {
+      writeFileSync(globalPath, JSON.stringify(globalData, null, 2) + '\n');
+    }
+
+    // 备份旧文件
+    const backupPath = oldPath + BACKUP_SUFFIX;
+    if (!existsSync(backupPath)) copyFileSync(oldPath, backupPath);
+    unlinkSync(oldPath);
+
+    console.log(`  ✅ 已迁移到 .sillyspec/changes/${changeName}/progress.json`);
+    console.log(`  📦 旧文件已备份到 .sillyspec/.runtime/progress.json.bak`);
+  }
+
+  // ── 全局状态 ──
+
+  readGlobal(cwd) {
+    this._migrateIfNeeded(cwd);
+    const globalPath = this._runtimePath(cwd, GLOBAL_FILE);
+    if (!existsSync(globalPath)) return null;
+    return this._parseWithRecovery(readFileSync(globalPath, 'utf8'));
+  }
+
+  writeGlobal(cwd, data) {
+    this._ensureRuntimeDir(cwd);
+    const globalPath = this._runtimePath(cwd, GLOBAL_FILE);
+    const tmpPath = globalPath + '.tmp';
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n');
+    renameSync(tmpPath, globalPath);
+  }
+
+  // ── 变更级别状态 ──
+
+  /**
+   * 读取指定变更的 progress
+   * @param {string} cwd
+   * @param {string|null} changeName - 变更名，null 时尝试自动检测
+   */
+  read(cwd, changeName = null) {
+    // 向后兼容：如果没有 changeName，尝试读旧版路径
+    if (!changeName) {
+      // 先看新版全局文件
+      const global = this.readGlobal(cwd);
+      if (global && global.activeChanges && global.activeChanges.length === 1) {
+        changeName = global.activeChanges[0];
+      } else {
+        // fallback：扫描 changes 目录
+        const changes = this.listChanges(cwd);
+        if (changes.length === 1) {
+          changeName = changes[0];
+        } else {
+          // 最后尝试旧版路径
+          const oldPath = this._runtimePath(cwd, PROGRESS_FILE);
+          if (existsSync(oldPath)) {
+            return this._parseWithRecovery(readFileSync(oldPath, 'utf8'));
+          }
+          return null;
+        }
+      }
+    }
+
+    const progressPath = this._changePath(cwd, changeName, PROGRESS_FILE);
+    const backupPath = progressPath + BACKUP_SUFFIX;
 
     for (const p of [progressPath, backupPath]) {
       if (!existsSync(p)) continue;
@@ -65,62 +184,125 @@ export class ProgressManager {
     return null;
   }
 
-  _write(cwd, data) {
-    const progressPath = this._path(cwd, PROGRESS_FILE);
+  /**
+   * 写入指定变更的 progress
+   * @param {string} cwd
+   * @param {object} data
+   * @param {string|null} changeName - 从 data.currentChange 推导，或显式传入
+   */
+  _write(cwd, data, changeName = null) {
+    const cn = changeName || data.currentChange;
+    if (!cn) {
+      // 无变更名时 fallback 到旧路径（不应该发生，但保底）
+      const progressPath = this._runtimePath(cwd, PROGRESS_FILE);
+      this._ensureRuntimeDir(cwd);
+      const tmpPath = progressPath + '.tmp';
+      writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n');
+      renameSync(tmpPath, progressPath);
+      return;
+    }
+
+    this._ensureChangeDir(cwd, cn);
+    const progressPath = this._changePath(cwd, cn, PROGRESS_FILE);
     const tmpPath = progressPath + '.tmp';
-    this._ensureDir(cwd);
     writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n');
     renameSync(tmpPath, progressPath);
   }
 
-  _ensureDir(cwd) {
-    const runtimeDir = this._path(cwd);
-    if (!existsSync(runtimeDir)) {
-      mkdirSync(runtimeDir, { recursive: true });
-      for (const d of ['artifacts', 'history', 'logs', 'templates']) {
-        mkdirSync(join(runtimeDir, d), { recursive: true });
-      }
+  _backup(cwd, data) {
+    const cn = data?.currentChange;
+    if (!cn) return;
+    const p = this._changePath(cwd, cn, PROGRESS_FILE);
+    if (existsSync(p)) copyFileSync(p, this._changePath(cwd, cn, PROGRESS_FILE + BACKUP_SUFFIX));
+  }
+
+  // ── 变更管理 ──
+
+  /**
+   * 列出所有变更名（不含 archive 子目录）
+   */
+  listChanges(cwd) {
+    const changesDir = join(cwd, CHANGES_DIR);
+    if (!existsSync(changesDir)) return [];
+    return readdirSync(changesDir, { withFileTypes: true })
+      .filter(e => e.isDirectory() && e.name !== 'archive')
+      .map(e => e.name);
+  }
+
+  /**
+   * 注册变更到全局活跃列表
+   */
+  registerChange(cwd, changeName) {
+    let global = this.readGlobal(cwd);
+    if (!global) {
+      global = makeInitialGlobal(basename(cwd));
+    }
+    if (!global.activeChanges.includes(changeName)) {
+      global.activeChanges.push(changeName);
+      this.writeGlobal(cwd, global);
     }
   }
 
-  _backup(cwd) {
-    const p = this._path(cwd, PROGRESS_FILE);
-    if (existsSync(p)) copyFileSync(p, this._path(cwd, BACKUP_FILE));
+  /**
+   * 从全局活跃列表移除变更（归档时调用）
+   */
+  unregisterChange(cwd, changeName) {
+    const global = this.readGlobal(cwd);
+    if (!global) return;
+    global.activeChanges = global.activeChanges.filter(c => c !== changeName);
+    this.writeGlobal(cwd, global);
   }
 
   // ── CLI 命令 ──
 
   init(cwd) {
-    this._ensureDir(cwd);
-    const progressPath = this._path(cwd, PROGRESS_FILE);
-
-    if (existsSync(progressPath)) {
-      console.log(`ℹ️  progress.json 已存在，跳过`);
-      return this.read(cwd);
+    this._migrateIfNeeded(cwd);
+    this._ensureRuntimeDir(cwd);
+
+    const globalPath = this._runtimePath(cwd, GLOBAL_FILE);
+    if (!existsSync(globalPath)) {
+      const data = makeInitialGlobal(basename(cwd));
+      this.writeGlobal(cwd, data);
+      console.log(`✅ 已创建全局状态文件`);
+    } else {
+      console.log(`ℹ️  全局状态文件已存在，跳过`);
     }
 
-    const project = basename(cwd);
-    const data = makeInitialProgress(project);
-    this._write(cwd, data);
-    console.log(`✅ 已创建 ${join(RUNTIME_DIR, PROGRESS_FILE)}`);
-
     // 创建 user-inputs.md
-    const inputsPath = this._path(cwd, 'user-inputs.md');
+    const inputsPath = this._runtimePath(cwd, 'user-inputs.md');
     if (!existsSync(inputsPath)) {
       writeFileSync(inputsPath, '# 用户输入记录\n\n> 每步完成时由 AI 自动追加，记录用户所有原话。\n\n');
     }
 
     this._ensureGitignore(cwd);
-    return data;
+    return this.readGlobal(cwd);
   }
 
-  setStage(cwd, stage) {
+  /**
+   * 初始化指定变更的 progress
+   */
+  initChange(cwd, changeName) {
+    this._ensureChangeDir(cwd, changeName);
+    this.registerChange(cwd, changeName);
+
+    const progressPath = this._changePath(cwd, changeName, PROGRESS_FILE);
+    if (!existsSync(progressPath)) {
+      const data = makeInitialProgress(basename(cwd));
+      data.currentChange = changeName;
+      this._write(cwd, data, changeName);
+      console.log(`✅ 已创建变更 ${changeName} 的 progress.json`);
+    }
+
+    return this.read(cwd, changeName);
+  }
+
+  setStage(cwd, stage, changeName = null) {
     if (!VALID_STAGES.includes(stage)) {
       console.log(`❌ 未知阶段: ${stage}，可选: ${VALID_STAGES.join(', ')}`);
       return;
     }
 
-    const data = this._readOrInit(cwd);
+    const data = this._readOrInit(cwd, changeName);
     if (!data) return;
 
     if (!data.stages[stage]) data.stages[stage] = emptyStage();
@@ -133,14 +315,14 @@ export class ProgressManager {
     }
     data.lastActive = new Date().toLocaleString('zh-CN',{hour12:false});
 
-    this._backup(cwd);
+    this._backup(cwd, data);
     this._write(cwd, data);
     console.log(`✅ 当前阶段已设为: ${STAGE_LABELS[stage] || stage} (${stageData.status})`);
   }
 
-  addStep(cwd, stage, stepName) {
+  addStep(cwd, stage, stepName, changeName = null) {
     if (!stepName) { console.log('❌ 请指定步骤名称'); return; }
-    const data = this._requireStage(cwd, stage);
+    const data = this._requireStage(cwd, stage, changeName);
     if (!data) return;
 
     const stageData = data.stages[stage];
@@ -152,15 +334,15 @@ export class ProgressManager {
     stageData.steps.push({ name: stepName, status: 'pending' });
     data.lastActive = new Date().toLocaleString('zh-CN',{hour12:false});
 
-    this._backup(cwd);
+    this._backup(cwd, data);
     this._write(cwd, data);
     console.log(`✅ 已添加步骤: ${stage}/${stepName}`);
   }
 
-  updateStep(cwd, stage, stepName, options = {}) {
+  updateStep(cwd, stage, stepName, options = {}, changeName = null) {
     const { status, output } = options;
     if (!stepName) { console.log('❌ 请指定步骤名称'); return; }
-    const data = this._requireStage(cwd, stage);
+    const data = this._requireStage(cwd, stage, changeName);
     if (!data) return;
 
     const stageData = data.stages[stage];
@@ -184,18 +366,18 @@ export class ProgressManager {
     }
 
     data.lastActive = new Date().toLocaleString('zh-CN',{hour12:false});
-    this._backup(cwd);
+    this._backup(cwd, data);
     this._write(cwd, data);
     console.log(`✅ 步骤已更新: ${stage}/${stepName} → ${status || step.status}`);
   }
 
-  completeStage(cwd, stage) {
+  completeStage(cwd, stage, changeName = null) {
     if (!VALID_STAGES.includes(stage)) {
       console.log(`❌ 未知阶段: ${stage}`);
       return;
     }
 
-    const data = this._readOrInit(cwd);
+    const data = this._readOrInit(cwd, changeName);
     if (!data) return;
 
     if (!data.stages[stage]) data.stages[stage] = emptyStage();
@@ -210,27 +392,74 @@ export class ProgressManager {
 
     data.lastActive = new Date().toLocaleString('zh-CN',{hour12:false});
 
-    // 归档到 history/（ISO 时间戳，去掉所有非法路径字符）
-    const historyDir = this._path(cwd, 'history');
+    // 归档到 history/（ISO 时间戳）
+    const historyDir = this._runtimePath(cwd, 'history');
     mkdirSync(historyDir, { recursive: true });
     const ts = new Date().toISOString().replace(/[:.TZ-]/g, '');
-    writeFileSync(join(historyDir, `${stage}-${ts}.json`), JSON.stringify({ stage, data: stageData, completedAt: stageData.completedAt }, null, 2) + '\n');
+    const cn = data.currentChange || 'unknown';
+    writeFileSync(join(historyDir, `${cn}-${stage}-${ts}.json`), JSON.stringify({ change: cn, stage, data: stageData, completedAt: stageData.completedAt }, null, 2) + '\n');
 
-    this._backup(cwd);
+    this._backup(cwd, data);
     this._write(cwd, data);
 
     console.log(`✅ 阶段 ${stage} 已标记为完成（不自动推进，下一步由你决定）`);
   }
 
-  show(cwd) {
-    const data = this.read(cwd);
+  show(cwd, changeName = null) {
+    // 如果指定了变更名，只显示该变更
+    if (changeName) {
+      return this._showChange(cwd, changeName);
+    }
+
+    // 否则显示所有变更
+    const changes = this.listChanges(cwd);
+    if (changes.length === 0) {
+      console.log('ℹ️  没有活跃的变更');
+      return;
+    }
+
+    if (changes.length === 1) {
+      return this._showChange(cwd, changes[0]);
+    }
+
+    // 多个变更：汇总显示
+    const global = this.readGlobal(cwd);
+    console.log('');
+    console.log('  ═══════════════════════════════════════');
+    console.log(`  项目: ${(global?.project) || basename(cwd) || '(未命名)'}`);
+    console.log(`  活跃变更: ${changes.length} 个`);
+    console.log('  ═══════════════════════════════════════');
+    console.log('');
+
+    for (const cn of changes) {
+      const data = this.read(cwd, cn);
+      if (!data) {
+        console.log(`  📂 ${cn} — (无法读取)`);
+        continue;
+      }
+      const currentStage = data.currentStage || '(无)';
+      const stageLabel = STAGE_LABELS[data.currentStage] || currentStage;
+      const lastActive = data.lastActive ? this._timeAgo(data.lastActive) : '未知';
+
+      console.log(`  📂 ${cn}`);
+      console.log(`     当前阶段: ${stageLabel}  最近活跃: ${lastActive}`);
+      console.log('');
+    }
+
+    console.log(`  💡 查看详情：sillyspec progress show --change <name>`);
+    console.log('');
+  }
+
+  _showChange(cwd, changeName) {
+    const data = this.read(cwd, changeName);
     if (!data) {
-      console.log('❌ 未找到 progress.json，请先运行 sillyspec progress init');
+      console.log(`❌ 未找到变更 ${changeName} 的 progress.json`);
       return;
     }
 
     console.log('');
     console.log('  ═══════════════════════════════════════');
+    console.log(`  变更:     ${changeName}`);
     console.log(`  项目:     ${data.project || '(未命名)'}`);
     console.log(`  当前阶段: ${STAGE_LABELS[data.currentStage] || data.currentStage || '(无)'}`);
     console.log(`  最近活跃: ${data.lastActive ? this._timeAgo(data.lastActive) : '未知'}`);
@@ -275,12 +504,12 @@ export class ProgressManager {
     console.log('');
   }
 
-  status(cwd) {
-    this.show(cwd);
+  status(cwd, changeName = null) {
+    this.show(cwd, changeName);
   }
 
-  async validate(cwd) {
-    const data = this.read(cwd);
+  async validate(cwd, changeName = null) {
+    const data = this.read(cwd, changeName);
     if (!data) { console.log('❌ 无法读取 progress.json'); return false; }
 
     const errors = [];
@@ -307,7 +536,7 @@ export class ProgressManager {
       if (!fixed.stages[s]) { fixed.stages[s] = emptyStage(); changed = true; }
     }
     if (changed) {
-      this._backup(cwd);
+      this._backup(cwd, fixed);
       this._write(cwd, fixed);
       console.log('✅ 已修复并备份');
     }
@@ -315,56 +544,76 @@ export class ProgressManager {
     return true;
   }
 
-  reset(cwd, stage) {
-    this._ensureDir(cwd);
-
+  reset(cwd, stage, changeName = null) {
     if (stage) {
-      this._backup(cwd);
-      const data = this.read(cwd);
+      const data = this.read(cwd, changeName);
       if (!data) { console.log('❌ 无法读取 progress.json'); return; }
+      this._backup(cwd, data);
       if (!data.stages[stage]) { console.log(`❌ 未知阶段: ${stage}`); return; }
       data.stages[stage] = emptyStage();
       data.lastActive = new Date().toLocaleString('zh-CN',{hour12:false});
       this._write(cwd, data);
       console.log(`✅ 已重置阶段: ${stage}`);
     } else {
-      const p = this._path(cwd, PROGRESS_FILE);
-      const backup = this._path(cwd, BACKUP_FILE);
-      let didReset = false;
-      if (existsSync(p)) { unlinkSync(p); didReset = true; }
-      if (existsSync(backup)) { unlinkSync(backup); didReset = true; }
-      if (didReset) {
-        console.log('✅ 已重置所有进度');
+      // 重置所有变更或指定变更
+      if (changeName) {
+        const p = this._changePath(cwd, changeName, PROGRESS_FILE);
+        const backup = this._changePath(cwd, changeName, PROGRESS_FILE + BACKUP_SUFFIX);
+        let didReset = false;
+        if (existsSync(p)) { unlinkSync(p); didReset = true; }
+        if (existsSync(backup)) { unlinkSync(backup); didReset = true; }
+        if (didReset) console.log(`✅ 已重置变更 ${changeName} 的进度`);
+        else console.log('ℹ️  无进度文件可重置');
       } else {
-        console.log('ℹ️  无进度文件可重置');
+        const changes = this.listChanges(cwd);
+        for (const cn of changes) {
+          const p = this._changePath(cwd, cn, PROGRESS_FILE);
+          const backup = this._changePath(cwd, cn, PROGRESS_FILE + BACKUP_SUFFIX);
+          if (existsSync(p)) unlinkSync(p);
+          if (existsSync(backup)) unlinkSync(backup);
+        }
+        console.log('✅ 已重置所有变更的进度');
       }
     }
   }
 
   // ── 内部辅助 ──
 
-  _readOrInit(cwd) {
-    let data = this.read(cwd);
+  _readOrInit(cwd, changeName = null) {
+    let data = this.read(cwd, changeName);
     if (!data) {
-      this._ensureDir(cwd);
-      const progressPath = this._path(cwd, PROGRESS_FILE);
-      if (!existsSync(progressPath)) {
-        data = makeInitialProgress(basename(cwd));
-        this._write(cwd, data);
-      } else {
-        console.log('❌ progress.json 损坏，请运行 sillyspec progress validate');
+      // 尝试自动检测变更名
+      if (!changeName) {
+        const changes = this.listChanges(cwd);
+        if (changes.length === 1) changeName = changes[0];
+      }
+      if (changeName) {
+        this._ensureChangeDir(cwd, changeName);
+        const progressPath = this._changePath(cwd, changeName, PROGRESS_FILE);
+        if (!existsSync(progressPath)) {
+          data = makeInitialProgress(basename(cwd));
+          data.currentChange = changeName;
+          this._write(cwd, data, changeName);
+          this.registerChange(cwd, changeName);
+        }
+      }
+      if (!data) {
+        data = this.read(cwd, changeName);
+      }
+      if (!data) {
+        console.log('❌ 无法确定当前变更，请指定 --change <name>');
         return null;
       }
     }
     return data;
   }
 
-  _requireStage(cwd, stage) {
+  _requireStage(cwd, stage, changeName = null) {
     if (!VALID_STAGES.includes(stage)) {
       console.log(`❌ 未知阶段: ${stage}，可选: ${VALID_STAGES.join(', ')}`);
       return null;
     }
-    const data = this._readOrInit(cwd);
+    const data = this._readOrInit(cwd, changeName);
     if (!data) return null;
     if (!data.stages[stage]) data.stages[stage] = emptyStage();
     return data;
@@ -393,7 +642,6 @@ export class ProgressManager {
   _timeAgo(dateStr) {
     if (!dateStr) return '未知';
     let ts = Date.parse(dateStr);
-    // toLocaleString('zh-CN') 格式（如 2026/5/12 21:09:00）可能解析失败，尝试手动解析
     if (isNaN(ts)) {
       const m = dateStr.match(/(\d{4})[\/-](\d{1,2})[\/-](\d{1,2})[\s,]+(\d{1,2}):(\d{2})(?::(\d{2}))?/);
       if (m) ts = new Date(+m[1], +m[2]-1, +m[3], +m[4], +m[5], +(m[6]||0)).getTime();
@@ -410,8 +658,8 @@ export class ProgressManager {
 
   // ── 批量进度 ──
 
-  updateBatchProgress(cwd, batchData) {
-    const data = this._readOrInit(cwd);
+  updateBatchProgress(cwd, batchData, changeName = null) {
+    const data = this._readOrInit(cwd, changeName);
     if (!data) return;
 
     if (!data.batchProgress) {
@@ -423,19 +671,18 @@ export class ProgressManager {
     if (batchData.skipped !== undefined) data.batchProgress.skipped = batchData.skipped;
 
     data.lastActive = new Date().toLocaleString('zh-CN', { hour12: false });
-    this._backup(cwd);
+    this._backup(cwd, data);
     this._write(cwd, data);
   }
 
-  readBatchProgress(cwd) {
-    const data = this.read(cwd);
+  readBatchProgress(cwd, changeName = null) {
+    const data = this.read(cwd, changeName);
     return data?.batchProgress || null;
   }
 
   _renderBatchProgress(batchProgress) {
     if (!batchProgress || !batchProgress.total) return null;
     const { total, completed = 0, failed = 0, skipped = 0 } = batchProgress;
-    const done = Math.min(completed + failed + skipped, total);
     const barLen = 20;
     const filled = Math.round((completed / total) * barLen);
     const bar = '█'.repeat(filled) + '░'.repeat(barLen - filled);

package/src/run.js

@@ -2,6 +2,7 @@
  * sillyspec run 命令实现
  *
  * CLI 成为流程引擎，AI 变成步骤执行器。
+ * 支持多变更并行：每个变更独立 progress.json。
  */
 import { basename, join } from 'path'
 import { existsSync, readdirSync, mkdirSync, writeFileSync, appendFileSync, readFileSync, statSync } from 'fs'
@@ -11,7 +12,7 @@ import { buildExecuteSteps } from './stages/execute.js'
 import { buildPlanSteps } from './stages/plan.js'
 
 /**
- * 统一查找变更目录
+ * 统一查找变更目录（与 progress.js 的变更检测逻辑一致）
  */
 function resolveChangeDir(cwd, progress) {
   const changesDir = join(cwd, '.sillyspec', 'changes')
@@ -48,6 +49,19 @@ function autoDetectChange(progress, cwd) {
   return false
 }
 
+/**
+ * 从 progress 或变更目录推导变更名
+ */
+function resolveChangeName(cwd, progress) {
+  if (progress.currentChange) return progress.currentChange
+  const changesDir = join(cwd, '.sillyspec', 'changes')
+  if (!existsSync(changesDir)) return null
+  const entries = readdirSync(changesDir, { withFileTypes: true })
+    .filter(e => e.isDirectory() && e.name !== 'archive')
+  if (entries.length === 1) return entries[0].name
+  return null
+}
+
 /**
  * 获取阶段的步骤定义（execute 需要动态构建）
  */
@@ -70,7 +84,7 @@ async function getStageSteps(stageName, cwd, progress) {
 }
 
 /**
- * 确保阶段的 steps 已初始化到 progress.json
+ * 确保阶段的 steps 已初始化到 progress
  */
 async function ensureStageSteps(progress, stageName, cwd) {
   if (!progress.stages) progress.stages = {}
@@ -90,7 +104,6 @@ async function ensureStageSteps(progress, stageName, cwd) {
 
   // 检查步骤数量是否匹配（execute 动态步骤可能变化）
   if (progress.stages[stageName].steps.length !== steps.length) {
-    // 保留已完成的状态，重新构建步骤列表
     const oldSteps = progress.stages[stageName].steps
     progress.stages[stageName].steps = steps.map(s => {
       const old = oldSteps.find(step => step.name === s.name)
@@ -106,7 +119,7 @@ async function ensureStageSteps(progress, stageName, cwd) {
 /**
  * 输出当前步骤的 prompt
  */
-function outputStep(stageName, stepIndex, steps, cwd) {
+function outputStep(stageName, stepIndex, steps, cwd, changeName) {
   const step = steps[stepIndex]
   const total = steps.length
   const projectName = basename(cwd)
@@ -131,6 +144,7 @@ function outputStep(stageName, stepIndex, steps, cwd) {
   console.log(`step: ${stepIndex + 1}/${total}`)
   console.log(`stepName: ${step.name}`)
   console.log(`project: ${projectName}`)
+  if (changeName) console.log(`change: ${changeName}`)
   console.log(`---\n`)
   if (personas[stageName]) {
     console.log(personas[stageName])
@@ -146,8 +160,9 @@ function outputStep(stageName, stepIndex, steps, cwd) {
   console.log('- 完成后立即执行 --done 命令，不得跳过')
   console.log('- 文档类型文件（.md/.yaml/.json 等）头部必须包含 author（git 用户名）和 created_at（精确到秒）')
   console.log('- 执行构建/测试前必须先读 local.yaml，优先使用其中配置的命令、路径和环境变量；未配置时才使用默认值')
+  const changeFlag = changeName ? ` --change ${changeName}` : ''
   console.log(`\n### 完成后执行`)
-  console.log(`sillyspec run ${stageName} --done --input "用户原始需求/反馈" --output "你的摘要"`)
+  console.log(`sillyspec run ${stageName} --done${changeFlag} --input "用户原始需求/反馈" --output "你的摘要"`)
 }
 
 /**
@@ -200,41 +215,45 @@ export async function runCommand(args, cwd) {
   const isAuxiliary = auxiliaryStages.includes(stageName)
 
   const pm = new ProgressManager()
-  let progress = pm.read(cwd)
+  pm._migrateIfNeeded(cwd)
+  let progress = pm.read(cwd, changeName)
 
   if (!progress) {
-    // 辅助命令可以在没有 progress.json 时工作（比如 scan）
-    if (!isAuxiliary) {
+    // 如果指定了变更名或有变更目录，自动初始化变更的 progress
+    const autoChange = changeName || resolveChangeNameAuto(cwd)
+    if (autoChange) {
+      progress = pm.initChange(cwd, autoChange)
+    } else if (!isAuxiliary) {
       console.error('❌ 未找到 progress.json，请先运行 sillyspec init')
+      console.error('  提示：使用 --change <name> 指定变更名')
       process.exit(1)
     }
-    progress = pm.init(cwd)
   }
 
+  // 确保 progress 有 currentChange
+  const effectiveChange = changeName || progress.currentChange || resolveChangeName(cwd, progress)
+
   // -- auto 模式：自动推进所有流程阶段
   if (stageName === 'auto') {
-    return await runAutoMode(pm, progress, cwd, flags)
+    return await runAutoMode(pm, progress, cwd, flags, effectiveChange)
   }
 
-  // --change 设置当前变更名
-  if (changeName) {
-    progress.currentChange = changeName
-    progress.lastActive = new Date().toLocaleString('zh-CN', { hour12: false })
-    pm._write(cwd, progress)
-    console.log(`✅ 当前变更设置为：${changeName}`)
-    return
+  // --change 只作为变更名标识，不再拦截流程
+  // 注册变更到全局活跃列表（如果尚未注册）
+  if (effectiveChange) {
+    pm.registerChange(cwd, effectiveChange)
   }
 
   // --reset
   if (isReset) {
-    return await resetStage(pm, progress, stageName, cwd)
+    return await resetStage(pm, progress, stageName, cwd, effectiveChange)
   }
 
   // 确保步骤已初始化
   const changed = await ensureStageSteps(progress, stageName, cwd)
   if (changed) {
-    pm._write(cwd, progress)
-    progress = pm.read(cwd)
+    pm._write(cwd, progress, effectiveChange)
+    progress = pm.read(cwd, effectiveChange)
   }
 
   // --status
@@ -244,23 +263,35 @@ export async function runCommand(args, cwd) {
 
   // --skip
   if (isSkip) {
-    return await skipStep(pm, progress, stageName, cwd)
+    return await skipStep(pm, progress, stageName, cwd, effectiveChange)
   }
 
   // --done
   if (isDone) {
-    return await completeStep(pm, progress, stageName, cwd, outputText, inputText, { confirm: isConfirm })
+    return await completeStep(pm, progress, stageName, cwd, outputText, inputText, { confirm: isConfirm, changeName: effectiveChange })
   }
 
   // 默认：输出当前步骤
-  return await runStage(pm, progress, stageName, cwd)
+  return await runStage(pm, progress, stageName, cwd, effectiveChange)
 }
 
-async function runStage(pm, progress, stageName, cwd) {
+/**
+ * 自动推导变更名（不依赖 progress）
+ */
+function resolveChangeNameAuto(cwd) {
+  const changesDir = join(cwd, '.sillyspec', 'changes')
+  if (!existsSync(changesDir)) return null
+  const entries = readdirSync(changesDir, { withFileTypes: true })
+    .filter(e => e.isDirectory() && e.name !== 'archive')
+  if (entries.length === 1) return entries[0].name
+  return null
+}
+
+async function runStage(pm, progress, stageName, cwd, changeName) {
   // 自动探测 currentChange
   if (autoDetectChange(progress, cwd)) {
     progress.lastActive = new Date().toLocaleString('zh-CN', { hour12: false })
-    pm._write(cwd, progress)
+    pm._write(cwd, progress, changeName)
   }
 
   const stageData = progress.stages[stageName]
@@ -273,7 +304,7 @@ async function runStage(pm, progress, stageName, cwd) {
   if (progress.currentStage !== stageName) {
     progress.currentStage = stageName
     progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
-    pm._write(cwd, progress)
+    pm._write(cwd, progress, changeName)
   }
 
   const steps = stageData.steps
@@ -288,13 +319,12 @@ async function runStage(pm, progress, stageName, cwd) {
     stageData.status = 'in-progress'
     stageData.startedAt = new Date().toLocaleString('zh-CN', { hour12: false })
     stageData.completedAt = null
-    pm._write(cwd, progress)
+    pm._write(cwd, progress, changeName)
     currentIdx = 0
     console.log(`🔄 ${stageName} 阶段已自动重置，重新开始。\n`)
   }
 
   if (currentIdx > 0) {
-    // 有进行中的步骤，提示用户
     const completed = currentIdx
     const total = steps.length
     console.log(`⚠️  ${stageName} 已进行到第 ${currentIdx + 1}/${total} 步（前 ${completed} 步已完成）。`)
@@ -303,7 +333,7 @@ async function runStage(pm, progress, stageName, cwd) {
 
   const defSteps = await getStageSteps(stageName, cwd, progress)
   if (defSteps && defSteps[currentIdx]) {
-    outputStep(stageName, currentIdx, defSteps, cwd)
+    outputStep(stageName, currentIdx, defSteps, cwd, changeName)
   }
 }
 
@@ -311,7 +341,6 @@ function validateMetadata(cwd, stageName) {
   const changesDir = join(cwd, '.sillyspec', 'changes')
   if (!existsSync(changesDir)) return
 
-  // 找最近 10 分钟内修改的 md/yaml 文件
   const cutoff = Date.now() - 10 * 60 * 1000
   const missing = []
 
@@ -340,7 +369,7 @@ function validateMetadata(cwd, stageName) {
 }
 
 async function completeStep(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
-  const { printNext = true, confirm = false } = options
+  const { printNext = true, confirm = false, changeName } = options
   const stageData = progress.stages[stageName]
   if (!stageData || !stageData.steps) {
     console.error(`❌ 阶段 ${stageName} 未初始化`)
@@ -355,19 +384,16 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
     process.exit(1)
   }
 
-  // 标记完成（先标记，再处理动态步骤插入）
-
   steps[currentIdx].status = 'completed'
   steps[currentIdx].completedAt = new Date().toLocaleString('zh-CN',{hour12:false})
   if (outputText) {
     const MAX_OUTPUT = 200
     if (outputText.length > MAX_OUTPUT) {
       steps[currentIdx].output = outputText.slice(0, MAX_OUTPUT) + '…'
-      // Save full output to artifacts/
       const artifactsDir = join(cwd, '.sillyspec', '.runtime', 'artifacts')
       mkdirSync(artifactsDir, { recursive: true })
       const ts = new Date().toISOString().slice(0,19).replace(/[-T:]/g, '')
-      writeFileSync(join(artifactsDir, `${stageName}-step${currentIdx + 1}-${ts}.txt`), outputText)
+      writeFileSync(join(artifactsDir, `${changeName || 'unknown'}-${stageName}-step${currentIdx + 1}-${ts}.txt`), outputText)
     } else {
       steps[currentIdx].output = outputText
     }
@@ -384,10 +410,8 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
         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) {
-          // 在当前步骤之后插入协调器步骤（含 prompt，否则 outputStep 无法打印）
           for (let i = 0; i < coordinatorSteps.length; i++) {
             steps.splice(currentIdx + 1 + i, 0, {
               name: coordinatorSteps[i].name,
@@ -406,36 +430,34 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
   const nextPendingIdx = steps.findIndex(s => s.status === 'pending')
 
   if (nextPendingIdx === -1) {
-    // 全部完成 — 仅标记当前阶段，不自动推进 currentStage
     stageData.status = 'completed'
     stageData.completedAt = new Date().toLocaleString('zh-CN',{hour12:false})
     progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
-    pm._write(cwd, progress)
+    pm._write(cwd, progress, changeName)
 
     // Append to user-inputs.md
     if (outputText) {
       const inputsPath = join(cwd, '.sillyspec', '.runtime', 'user-inputs.md')
-      const entry = `\n## ${new Date().toLocaleString('zh-CN',{hour12:false})} | ${stageName}: ${steps[currentIdx].name}\n${inputText ? "- 输入：" + inputText + "\n" : ""}- 输出：${outputText}\n`
+      const entry = `\n## ${new Date().toLocaleString('zh-CN',{hour12:false})} | ${changeName || '?'} | ${stageName}: ${steps[currentIdx].name}\n${inputText ? "- 输入：" + inputText + "\n" : ""}- 输出：${outputText}\n`
       appendFileSync(inputsPath, entry)
     }
 
-    // 验证：检查生成的文件是否包含 author 和 created_at
     validateMetadata(cwd, stageName)
 
-    // archive 阶段 Step 2（确认归档）完成时自动执行归档移动
+    // archive 阶段确认归档
     if (stageName === 'archive' && steps[currentIdx]?.name === '确认归档') {
       if (confirm) {
         const { renameSync } = await import('fs')
-        const changeName = progress.currentChange
-        if (!changeName) {
+        const archiveChangeName = progress.currentChange
+        if (!archiveChangeName) {
           console.error('❌ 归档失败：未找到当前变更名（currentChange）')
           process.exit(1)
         }
         const changesDir = join(cwd, '.sillyspec', 'changes')
         const archiveDir = join(changesDir, 'archive')
-        const srcDir = join(changesDir, changeName)
+        const srcDir = join(changesDir, archiveChangeName)
         const date = new Date().toISOString().slice(0, 10)
-        const destDir = join(archiveDir, `${date}-${changeName}`)
+        const destDir = join(archiveDir, `${date}-${archiveChangeName}`)
 
         if (!existsSync(srcDir)) {
           console.error(`❌ 归档失败：源目录不存在 ${srcDir}`)
@@ -448,21 +470,20 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
         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}/`)
+        // 从全局活跃列表移除
+        pm.unregisterChange(cwd, archiveChangeName)
+        console.log(`📦 已归档：${archiveChangeName} → archive/${date}-${archiveChangeName}/`)
       } 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 => ({
@@ -474,13 +495,12 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
       stageData.steps = freshSteps
       stageData.status = 'pending'
       stageData.completedAt = null
-      pm._write(cwd, progress)
+      pm._write(cwd, progress, changeName)
     }
 
     const total = steps.length
     console.log(`✅ ${stageName} 阶段已完成（${total}/${total} 步）`)
 
-    // 阶段完成后提示下一步
     if (stageName === 'execute') {
       console.log('\n👉 下一步：sillyspec run verify（验证通过后才能归档）')
     } else if (stageName === 'verify') {
@@ -494,24 +514,24 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
   }
 
   progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
-  pm._write(cwd, progress)
+  pm._write(cwd, progress, changeName)
 
   // Append to user-inputs.md
   if (outputText) {
     const inputsPath = join(cwd, '.sillyspec', '.runtime', 'user-inputs.md')
-    const entry = `\n## ${new Date().toLocaleString('zh-CN',{hour12:false})} | ${stageName}: ${steps[currentIdx].name}\n${inputText ? "- 输入：" + inputText + "\n" : ""}- 输出：${outputText}\n`
+    const entry = `\n## ${new Date().toLocaleString('zh-CN',{hour12:false})} | ${changeName || '?'} | ${stageName}: ${steps[currentIdx].name}\n${inputText ? "- 输入：" + inputText + "\n" : ""}- 输出：${outputText}\n`
     appendFileSync(inputsPath, entry)
   }
 
   const defSteps = await getStageSteps(stageName, cwd, progress)
   console.log(`✅ Step ${currentIdx + 1}/${steps.length} 完成：${steps[currentIdx].name}\n`)
   if (printNext) {
-    outputStep(stageName, nextPendingIdx, defSteps, cwd)
+    outputStep(stageName, nextPendingIdx, defSteps, cwd, changeName)
   }
   return { stageCompleted: false, currentIdx, nextPendingIdx }
 }
 
-async function skipStep(pm, progress, stageName, cwd) {
+async function skipStep(pm, progress, stageName, cwd, changeName) {
   const stageData = progress.stages[stageName]
   if (!stageData || !stageData.steps) {
     console.error(`❌ 阶段 ${stageName} 未初始化`)
@@ -536,15 +556,14 @@ async function skipStep(pm, progress, stageName, cwd) {
   steps[currentIdx].status = 'skipped'
   steps[currentIdx].skippedAt = new Date().toLocaleString('zh-CN',{hour12:false})
   progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
-  pm._write(cwd, progress)
+  pm._write(cwd, progress, changeName)
 
   console.log(`⏭️ Step ${currentIdx + 1}/${steps.length} 已跳过：${steps[currentIdx].name}`)
 
-  // 输出下一步
   const nextPendingIdx = steps.findIndex(s => s.status === 'pending')
   if (nextPendingIdx !== -1 && defSteps) {
     console.log('')
-    outputStep(stageName, nextPendingIdx, defSteps, cwd)
+    outputStep(stageName, nextPendingIdx, defSteps, cwd, changeName)
   }
 }
 
@@ -567,7 +586,6 @@ function showStatus(progress, stageName) {
 
   const firstPending = steps.findIndex(s => s.status === 'pending')
 
-  // 批量进度
   if (progress.batchProgress) {
     const bp = progress.batchProgress
     const bpTotal = bp.total || 0
@@ -591,7 +609,7 @@ function showStatus(progress, stageName) {
   })
 }
 
-async function resetStage(pm, progress, stageName, cwd) {
+async function resetStage(pm, progress, stageName, cwd, changeName) {
   const defSteps = await getStageSteps(stageName, cwd, progress)
   progress.stages[stageName] = {
     status: 'in-progress',
@@ -600,14 +618,14 @@ async function resetStage(pm, progress, stageName, cwd) {
     steps: defSteps ? defSteps.map(s => ({ name: s.name, status: 'pending' })) : []
   }
   progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
-  pm._write(cwd, progress)
+  pm._write(cwd, progress, changeName)
   console.log(`🔄 ${stageName} 阶段已重置`)
 }
 
 /**
  * auto 模式：自动推进 brainstorm → plan → execute → verify
  */
-async function runAutoMode(pm, progress, cwd, flags) {
+async function runAutoMode(pm, progress, cwd, flags, changeName) {
   const flowStages = ['brainstorm', 'plan', 'execute', 'verify']
   const isDone = flags.includes('--done')
   const outputIdx = flags.indexOf('--output')
@@ -623,8 +641,8 @@ async function runAutoMode(pm, progress, cwd, flags) {
     const stageChanged = progress.currentStage !== stage
     progress.currentStage = stage
     const changed = await ensureStageSteps(progress, stage, cwd)
-    if (stageChanged || changed) pm._write(cwd, progress)
-    progress = pm.read(cwd)
+    if (stageChanged || changed) pm._write(cwd, progress, changeName)
+    progress = pm.read(cwd, changeName)
     return progress
   }
 
@@ -637,7 +655,6 @@ async function runAutoMode(pm, progress, cwd, flags) {
     return
   }
   if (!flowStages.includes(currentStage)) {
-    // 当前在辅助阶段（scan/quick/archive 等），自动跳到第一个未完成的流程阶段
     const openStage = firstOpenStage()
     if (!openStage) {
       console.log('All auto flow stages are complete.')
@@ -651,6 +668,7 @@ async function runAutoMode(pm, progress, cwd, flags) {
   if (!isDone) {
     console.log('════════════════════════════════════════')
     console.log('  SillySpec Auto Mode')
+    if (changeName) console.log(`  Change: ${changeName}`)
     console.log('════════════════════════════════════════')
     console.log(`  Flow: ${flowStages.join(' -> ')}`)
     console.log(`  Current: ${currentStage}`)
@@ -671,7 +689,7 @@ async function runAutoMode(pm, progress, cwd, flags) {
       else console.log('All auto flow stages are complete.')
       return
     }
-    outputStep(currentStage, pendingIdx, defSteps, cwd)
+    outputStep(currentStage, pendingIdx, defSteps, cwd, changeName)
     return
   }
 
@@ -680,14 +698,14 @@ async function runAutoMode(pm, progress, cwd, flags) {
     process.exit(1)
   }
 
-  const result = await completeStep(pm, progress, currentStage, cwd, outputText, inputText, { printNext: false })
+  const result = await completeStep(pm, progress, currentStage, cwd, outputText, inputText, { printNext: false, changeName })
   if (!result) return
-  progress = pm.read(cwd)
+  progress = pm.read(cwd, changeName)
 
   const nextPendingIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'pending') ?? -1
   if (nextPendingIdx !== -1) {
     const defSteps = await getStageSteps(currentStage, cwd, progress)
-    outputStep(currentStage, nextPendingIdx, defSteps, cwd)
+    outputStep(currentStage, nextPendingIdx, defSteps, cwd, changeName)
     return
   }
 
@@ -707,11 +725,11 @@ async function runAutoMode(pm, progress, cwd, flags) {
   }
   progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
   await ensureStageSteps(progress, next, cwd)
-  pm._write(cwd, progress)
-  progress = pm.read(cwd)
+  pm._write(cwd, progress, changeName)
+  progress = pm.read(cwd, changeName)
 
   console.log(`\n${currentStage} complete. Auto advanced to ${next}.`)
   const nextSteps = await getStageSteps(next, cwd, progress)
   const firstPending = progress.stages[next]?.steps?.findIndex(step => step.status === 'pending') ?? -1
-  if (firstPending !== -1) outputStep(next, firstPending, nextSteps, cwd)
+  if (firstPending !== -1) outputStep(next, firstPending, nextSteps, cwd, changeName)
 }

package/src/stages/brainstorm.js

@@ -5,7 +5,7 @@ export const definition = {
   steps: [
     {
       name: '状态检查',
-      prompt: `检查 .sillyspec/.runtime/progress.json 确认当前状态。
+      prompt: `检查当前变更的 progress.json 确认当前状态。
 
 ### 操作
 1. 运行 \`sillyspec progress show\`

package/src/stages/doctor.js

@@ -18,9 +18,15 @@ export const definition = {
 for d in .sillyspec .sillyspec/projects .sillyspec/docs .sillyspec/changes .sillyspec/.runtime; do
   [ -d "$d" ] && echo "✅ $d" || echo "❌ $d"
 done
-# 检查 progress.json
-[ -f .sillyspec/.runtime/progress.json ] && echo "✅ progress.json 存在" || echo "❌ progress.json 不存在"
-node -e "JSON.parse(require('fs').readFileSync('.sillyspec/.runtime/progress.json','utf8')); console.log('✅ progress.json 可解析')" 2>/dev/null || echo "⚠️ progress.json 不可解析"
+# 检查 progress.json（支持新版按变更隔离和旧版全局）
+if [ -d .sillyspec/changes ]; then
+  PROGRESS_FILE=$(find .sillyspec/changes -maxdepth 2 -name progress.json | head -1)
+fi
+if [ -z "$PROGRESS_FILE" ]; then
+  PROGRESS_FILE='.sillyspec/.runtime/progress.json'
+fi
+[ -f "$PROGRESS_FILE" ] && echo "✅ progress.json 存在 ($PROGRESS_FILE)" || echo "❌ progress.json 不存在"
+node -e "JSON.parse(require('fs').readFileSync('$PROGRESS_FILE','utf8')); console.log('✅ progress.json 可解析')" 2>/dev/null || echo "⚠️ progress.json 不可解析"
 \`\`\`
 
 ### 2. 项目配置检查
@@ -42,7 +48,7 @@ done
 \`\`\`bash
 # 读取 currentChange 并检查目录存在性
 node -e "
-const p = JSON.parse(require('fs').readFileSync('.sillyspec/.runtime/progress.json','utf8'));
+const p = JSON.parse(require('fs').readFileSync(process.env.PROGRESS_FILE || '.sillyspec/.runtime/progress.json','utf8'));
 const cc = p.currentChange;
 if (!cc) { console.log('ℹ️ 无当前变更'); process.exit(0); }
 const dir = '.sillyspec/changes/' + cc;
@@ -68,7 +74,7 @@ if (!fs.existsSync(dir)) { console.log('ℹ️ changes/ 目录不存在'); proce
 const subs = fs.readdirSync(dir).filter(f => fs.statSync(dir+'/'+f).isDirectory());
 if (subs.length === 0) { console.log('ℹ️ 无变更目录'); process.exit(0); }
 let progress;
-try { progress = JSON.parse(fs.readFileSync('.sillyspec/.runtime/progress.json','utf8')); } catch { console.log('⚠️ 无法读取 progress.json'); subs.forEach(s => console.log('❓ ' + s)); process.exit(0); }
+try { progress = JSON.parse(fs.readFileSync(process.env.PROGRESS_FILE || '.sillyspec/.runtime/progress.json','utf8')); } catch { console.log('⚠️ 无法读取 progress.json'); subs.forEach(s => console.log('❓ ' + s)); process.exit(0); }
 const known = new Set();
 if (progress.currentChange) known.add(progress.currentChange);
 for (const sd of Object.values(progress.stages || {})) {
@@ -121,7 +127,7 @@ done
 # 确定项目路径（使用 progress.json 中的项目或当前目录）
 PROJECT_DIR=$(node -e "
 const fs=require('fs');
-try{const p=JSON.parse(fs.readFileSync('.sillyspec/.runtime/progress.json','utf8'));if(p.project){console.log(p.project);process.exit(0)}}catch{}
+try{const fs=require('fs'),path=require('path');const changesDir='.sillyspec/changes';let pp=null;if(fs.existsSync(changesDir)){const entries=fs.readdirSync(changesDir,{withFileTypes:true}).filter(e=>e.isDirectory()&&e.name!=='archive');if(entries.length===1)pp=path.join(changesDir,entries[0].name,'progress.json');}if(!pp)pp='.sillyspec/.runtime/progress.json';const p=JSON.parse(fs.readFileSync(pp,'utf8'));if(p.project){console.log(p.project);process.exit(0)}}catch{}
 const files=fs.readdirSync('.sillyspec/projects').filter(f=>f.endsWith('.yaml'));
 if(files.length>0){const c=fs.readFileSync('.sillyspec/projects/'+files[0],'utf8');const m=c.match(/^path:\\s*(.+)/m);console.log(m?m[1].trim():'.')}else console.log('.')
 " 2>/dev/null)

package/src/stages/scan.js

@@ -39,7 +39,7 @@ export const definition = {
       prompt: `检测已有扫描文档，只生成缺失的。
 
 ### 操作
-1. \`PROJECT=$(python3 -c "import sys,json; print(json.load(open('.sillyspec/.runtime/progress.json')).get('project',''))" 2>/dev/null || basename "$(pwd)")\`
+1. \`PROJECT=$(python3 -c "import sys,json,glob; files=glob.glob('.sillyspec/changes/*/progress.json'); print(json.load(open(files[0])).get('project','')) if files else print('')" 2>/dev/null || basename "$(pwd)")\`
 2. 检查 7 份文档是否存在：ARCHITECTURE、STRUCTURE、CONVENTIONS、INTEGRATIONS、TESTING、CONCERNS、PROJECT
 3. 列出已有 ✅ 和缺失 ⬜
 4. 只生成缺失的文档