sillyspec 3.15.2 → 3.16.1

package/docs/worktree-isolation.md

@@ -117,9 +117,11 @@ allowWrite = stageGate && locationGate && fileGate
 | **`--no-worktree` 标志** | 跳过隔离创建，但 hook 仍然拦截源码写入 |
 | **`SILLYSPEC_DISABLE_HOOKS=1`** | 紧急禁用所有 hook，全部放行 |
 | **无 gate-status.json** | stageGate=false，默认禁止源码写入 |
-| **worktree 创建失败** | 报错停止，不进入无隔离状态 |
+| **worktree 创建失败** | 自动降级为 in-place + baseline protection（mode: in-place-fallback） |
+| **已在 linked worktree** | 复用当前目录（mode: native-worktree） |
+| **worktree 目录未 ignore** | 阻断创建，提示修复 |
 
-> ⚠️ 不存在"降级到放行"的路径。只有"降级到更严格"或"紧急逃生开关"。设计原则是默认安全。
+> ⚠️ in-place 降级模式仍会记录 baseline（baselineFiles + baselineHash + baselineCommit），hook 拦截继续生效，不会无保护地直接写源码。
 
 ## 多 Agent 并行使用
 
@@ -146,6 +148,59 @@ sillyspec worktree create feature-ui
 | `SILLYSPEC_DISABLE_HOOKS` | 设为 `1` 时禁用所有 hook（紧急逃生） |
 | `SILLYSPEC_WORKTREE_DIR` | 自定义 worktree 存储目录（默认 `.sillyspec/.runtime/worktrees/`） |
 
+## 环境隔离检测
+
+SillySpec 在创建 worktree 前会自动检测当前环境的隔离状态：
+
+### submodule 防护
+
+使用 `git rev-parse --git-dir` 和 `--git-common-dir` 判断是否在 linked worktree 中。
+同时用 `--show-superproject-working-tree` 排除 git submodule 的误判：
+
+```
+if GIT_DIR != GIT_COMMON && 无 superproject:
+  → 已在 linked worktree，复用当前隔离环境
+if 无 superproject 为空:
+  → 在 git submodule 内，阻断创建并提示
+else:
+  → 在主仓库中，正常创建 worktree
+```
+
+### .gitignore 强制校验
+
+worktree 存储目录 `.sillyspec/.runtime/worktrees/` 必须被 `.gitignore` 忽略：
+
+- **init / doctor 阶段：** 预检查并提示修复
+- **execute 阶段：** 未 ignore 则直接阻断 worktree 创建，抛出明确错误
+- **不会自动修改 .gitignore：** 避免污染 baseline
+
+修复方式：在项目 `.gitignore` 中添加：
+```
+.sillyspec/.runtime/worktrees/
+```
+
+### isolation 状态
+
+worktree create 后，isolation 状态写入 `sillyspec.db` 的 `changes` 表（权威状态源）：
+
+| 字段 | 说明 |
+|------|------|
+| `isolation_status` | pending / verified / degraded / blocked |
+| `isolation_mode` | worktree / native-worktree / in-place-fallback / null |
+| `isolation_reason` | blocked 或 degraded 时的原因说明 |
+
+状态映射：
+
+| status | mode | 触发条件 |
+|--------|------|----------|
+| verified | worktree | `git worktree add` 成功 |
+| verified | native-worktree | 已在 linked worktree，复用 |
+| degraded | in-place-fallback | `git worktree add` 失败，降级 in-place |
+| blocked | null | submodule 内 / gitignore 未配置 |
+| null | null | 尚未执行隔离检查 |
+
+> ⚠️ isolation 的权威来源是 sillyspec.db。meta.json 中的 mode 仅作为 worktree 目录的运行时元信息。gate-status.json 不存储 isolation。
+
 ## 常见问题和故障排除
 
 ### worktree 残留无法清理

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.15.2",
+  "version": "3.16.1",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",
@@ -23,6 +23,10 @@
     "spec-driven"
   ],
   "license": "MIT",
+  "scripts": {
+    "test": "node test/run-tests.mjs",
+    "lint": "node test/check-syntax.mjs"
+  },
   "dependencies": {
     "@inquirer/prompts": "^7.10.1",
     "chalk": "^5.6.2",

package/src/db.js

@@ -164,5 +164,22 @@ export class DB {
     this.db.run('CREATE INDEX IF NOT EXISTS idx_changes_status ON changes(status)');
     this.db.run('CREATE INDEX IF NOT EXISTS idx_stages_change ON stages(change_id)');
     this.db.run('CREATE INDEX IF NOT EXISTS idx_steps_stage ON steps(stage_id)');
+
+    // Migration: add isolation columns to changes table (idempotent)
+    this._migrateAddColumn('changes', 'isolation_status', 'TEXT');
+    this._migrateAddColumn('changes', 'isolation_mode', 'TEXT');
+    this._migrateAddColumn('changes', 'isolation_reason', 'TEXT');
+  }
+
+  /**
+   * 幂等地给表添加列（列已存在则跳过）
+   * @private
+   */
+  _migrateAddColumn(table, column, type) {
+    try {
+      this.db.run(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+    } catch {
+      // 列已存在，静默跳过
+    }
   }
 }

package/src/hooks/worktree-guard.js

@@ -16,8 +16,6 @@ import path from 'path'
 
 const WORKTREE_STAGES = ['execute'] // 这些阶段必须在 worktree 里
 
-const WORKTREE_SEGMENT = '.sillyspec/.runtime/worktrees/'
-
 const FILE_WHITELIST_EXTS = ['.md']
 const FILE_WHITELIST_NAMES = ['package.json', 'tsconfig.json', 'local.yaml', 'local.yml']
 
@@ -84,6 +82,55 @@ function resolveWorktreeDir(cwd) {
   return path.join(cwd, '.sillyspec', '.runtime', 'worktrees')
 }
 
+function findProjectRoot(cwd) {
+  let dir = path.resolve(cwd || process.cwd())
+  while (true) {
+    if (
+      existsSync(path.join(dir, '.sillyspec', '.runtime', 'gate-status.json')) ||
+      existsSync(path.join(dir, '.sillyspec', '.runtime', 'sillyspec.db')) ||
+      existsSync(path.join(dir, '.sillyspec', 'local.yaml')) ||
+      existsSync(path.join(dir, '.sillyspec', 'local.yml')) ||
+      existsSync(path.join(dir, '.sillyspec', 'projects'))
+    ) {
+      return dir
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) return path.resolve(cwd || process.cwd())
+    dir = parent
+  }
+}
+
+function safeChangeName(changeName) {
+  return typeof changeName === 'string'
+    && changeName
+    && !changeName.includes('..')
+    && !changeName.includes('/')
+    && !changeName.includes('\\')
+}
+
+function readWorktreeMeta(cwd, changeName) {
+  if (!safeChangeName(changeName)) return null
+  const metaPath = path.join(resolveWorktreeDir(cwd), changeName, 'meta.json')
+  if (!existsSync(metaPath)) return null
+  try {
+    return JSON.parse(readFileSync(metaPath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function isPathInside(child, parent) {
+  if (!child || !parent) return false
+  const absChild = path.resolve(child)
+  const absParent = path.resolve(parent)
+  return absChild === absParent || absChild.startsWith(absParent + path.sep)
+}
+
+function isInsideWorktreeStorage(filePath, cwd) {
+  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd || process.cwd(), filePath)
+  return isPathInside(absPath, resolveWorktreeDir(cwd || process.cwd()))
+}
+
 /**
  * 读取 gate-status.json
  * @param {string} cwd
@@ -155,8 +202,18 @@ function isNoWorktreeMode(cwd) {
  * @param {string} filePath - 绝对路径
  * @returns {boolean}
  */
-function isInsideWorktree(filePath) {
-  return filePath.includes(WORKTREE_SEGMENT)
+function isInsideRegisteredWorktree(filePath, cwd) {
+  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd || process.cwd(), filePath)
+  const effectiveCwd = cwd || process.cwd()
+  const gateStatus = readGateStatus(effectiveCwd)
+  const changes = Array.isArray(gateStatus?.changes) ? gateStatus.changes : []
+
+  for (const changeName of changes) {
+    const meta = readWorktreeMeta(effectiveCwd, changeName)
+    if (meta?.worktreePath && isPathInside(absPath, meta.worktreePath)) return true
+  }
+
+  return false
 }
 
 /**
@@ -194,6 +251,8 @@ function matchFileWhitelist(filePath) {
  */
 function loadLocalConfig(cwd) {
   const candidates = [
+    path.join(cwd, '.sillyspec', 'local.yaml'),
+    path.join(cwd, '.sillyspec', 'local.yml'),
     path.join(cwd, 'local.yaml'),
     path.join(cwd, 'local.yml'),
   ]
@@ -209,49 +268,74 @@ function loadLocalConfig(cwd) {
   return {}
 }
 
-/**
- * 简易 YAML 解析，只处理顶层简单结构
- */
 function parseSimpleYaml(content) {
   const result = {}
-  let currentKey = null
-  let inArray = false
+  let topKey = null
+  let childKey = null
+
+  function parseValue(value) {
+    const trimmed = value.trim()
+    if (!trimmed) return ''
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+      return trimmed.slice(1, -1)
+    }
+    if (trimmed === 'true') return true
+    if (trimmed === 'false') return false
+    return trimmed
+  }
 
   for (const line of content.split('\n')) {
-    const trimmed = line.trim()
+    const noComment = line.replace(/\s+#.*$/, '')
+    const trimmed = noComment.trim()
     if (!trimmed || trimmed.startsWith('#')) continue
+    const indent = noComment.length - noComment.trimStart().length
 
-    // 顶层键
-    const topLevelMatch = trimmed.match(/^(\S[\S]*)\s*:\s*(.*)$/)
-    if (topLevelMatch && !trimmed.startsWith(' ')) {
+    if (indent === 0) {
+      const topLevelMatch = trimmed.match(/^([^:]+):\s*(.*)$/)
+      if (!topLevelMatch) continue
       const key = topLevelMatch[1]
-      const val = topLevelMatch[2].trim()
-      currentKey = key
+      const value = topLevelMatch[2]
+      topKey = key
+      childKey = null
 
-      if (val) {
-        // key: value (单行)
-        result[key] = val
-        inArray = false
+      if (value.trim()) {
+        result[key] = parseValue(value)
       } else {
-        // key: (多行值开始)
-        result[key] = []
-        inArray = true
+        result[key] = {}
       }
       continue
     }
 
-    // 数组项
-    if (inArray && currentKey && trimmed.startsWith('- ')) {
-      const item = trimmed.slice(2).trim()
-      if (Array.isArray(result[currentKey])) {
-        result[currentKey].push(item)
-      }
+    if (!topKey) continue
+
+    if (indent === 2 && trimmed.startsWith('- ')) {
+      if (!Array.isArray(result[topKey])) result[topKey] = []
+      result[topKey].push(parseValue(trimmed.slice(2)))
+      continue
+    }
+
+    if (indent === 2) {
+      const childMatch = trimmed.match(/^([^:]+):\s*(.*)$/)
+      if (!childMatch) continue
+      childKey = childMatch[1]
+      const value = childMatch[2]
+      if (typeof result[topKey] !== 'object' || Array.isArray(result[topKey])) result[topKey] = {}
+      result[topKey][childKey] = value.trim() ? parseValue(value) : []
       continue
     }
 
-    // 非数组行结束数组模式
-    if (inArray && !trimmed.startsWith('- ') && !trimmed.startsWith('#')) {
-      inArray = false
+    if (indent >= 4 && childKey && trimmed.startsWith('- ')) {
+      if (typeof result[topKey] !== 'object' || Array.isArray(result[topKey])) result[topKey] = {}
+      if (!Array.isArray(result[topKey][childKey])) result[topKey][childKey] = []
+      result[topKey][childKey].push(parseValue(trimmed.slice(2)))
+    }
+  }
+
+  for (const key of Object.keys(result)) {
+    if (result[key] && typeof result[key] === 'object' && !Array.isArray(result[key])) {
+      if (Object.keys(result[key]).length === 0) {
+        result[key] = {}
+      }
     }
   }
 
@@ -401,14 +485,15 @@ function buildStageHint(stage) {
 export function shouldBlockWrite(filePath, cwd) {
   if (!filePath) return { blocked: true, reason: 'no file path' }
 
-  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd || process.cwd(), filePath)
+  const callerCwd = cwd || process.cwd()
+  const projectRoot = findProjectRoot(callerCwd)
+  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(callerCwd, filePath)
 
-  // 1. 文件门禁：文档类/配置类始终放行
-  if (matchFileWhitelist(absPath)) return { blocked: false }
+  // 1. 文件门禁：文档类/配置类始终放行，但 worktree 存储区内的源码必须继续走登记校验。
+  if (!isInsideWorktreeStorage(absPath, projectRoot) && matchFileWhitelist(absPath)) return { blocked: false }
 
   // 2. 阶段门禁（使用 fallback 读取）
-  const effectiveCwd = cwd || process.cwd()
-  const stage = readCurrentStage(effectiveCwd) || '(none)'
+  const stage = readCurrentStage(projectRoot) || '(none)'
 
   if (!['execute', 'quick'].includes(stage)) {
     return {
@@ -417,14 +502,35 @@ export function shouldBlockWrite(filePath, cwd) {
     }
   }
 
-  // quick 阶段直接放行（不要求 worktree）
-  if (stage === 'quick') return { blocked: false }
+  // quick 阶段：检查 quick-guard.json 的 baselineFiles
+  if (stage === 'quick') {
+    try {
+      const guardFile = path.join(projectRoot, '.sillyspec', '.runtime', 'quick-guard.json')
+      const guard = JSON.parse(readFileSync(guardFile, 'utf8'))
+      const baselineFiles = guard.baselineFiles || []
+      const relTarget = path.relative(projectRoot, absPath)
+      // 如果目标是 baseline protected file，阻止写入
+      if (baselineFiles.some(f => relTarget === f || relTarget.startsWith(f + path.sep))) {
+        return {
+          blocked: true,
+          reason: [
+            `⚠️ quick 变更边界保护：${relTarget} 是 baseline 文件，不允许覆盖。`,
+            `当前 quick 任务不能修改任务开始前已修改的文件。`,
+            `如确需修改，请在 quick 完成后单独处理此文件。`,
+          ].join('\n')
+        }
+      }
+    } catch {
+      // quick-guard.json 不存在（非 quick 任务或未记录），放行
+    }
+    return { blocked: false }
+  }
 
   // execute 阶段：位置门禁
-  if (isInsideWorktree(absPath)) return { blocked: false }
+  if (isInsideRegisteredWorktree(absPath, projectRoot)) return { blocked: false }
 
   // noWorktree 模式：无隔离环境，禁止源码写入（降级到更严格）
-  if (isNoWorktreeMode(effectiveCwd)) {
+  if (isNoWorktreeMode(projectRoot)) {
     return {
       blocked: true,
       reason: [
@@ -441,7 +547,7 @@ export function shouldBlockWrite(filePath, cwd) {
       '源码修改只能在 worktree 隔离环境中进行。',
       '',
       '你可能需要：',
-      '  1. 确认 worktree 已创建：sillyspec worktree list',
+      '  1. 确认 worktree 已创建并登记：sillyspec worktree list',
       '  2. 如未创建，先创建：sillyspec worktree create <变更名>',
       '  3. 在 worktree 目录中工作（子代理的 cwd 设为 worktree 路径）',
       '',
@@ -460,17 +566,18 @@ export function shouldBlockWrite(filePath, cwd) {
 export function shouldBlockBash(command, cwd) {
   if (!command || !command.trim()) return { blocked: false }
 
-  const effectiveCwd = cwd || process.cwd()
+  const callerCwd = cwd || process.cwd()
+  const projectRoot = findProjectRoot(callerCwd)
 
   // cwd 在 worktree 内 → 全部放行
-  if (isInsideWorktree(effectiveCwd)) return { blocked: false }
+  if (isInsideRegisteredWorktree(callerCwd, projectRoot)) return { blocked: false }
 
   // 阶段门禁（使用 fallback 读取）
-  const stage = readCurrentStage(effectiveCwd) || '(none)'
+  const stage = readCurrentStage(projectRoot) || '(none)'
 
   if (!['execute', 'quick'].includes(stage)) {
     // 非 execute/quick 阶段，只允许只读白名单
-    const localConfig = loadLocalConfig(effectiveCwd)
+    const localConfig = loadLocalConfig(projectRoot)
     const extraReadonly = localConfig.worktreeHook?.readonlyCommands || localConfig['worktree-hook']?.readonlyCommands || []
     if (matchReadonlyWhitelist(command, extraReadonly)) return { blocked: false }
     return {
@@ -479,17 +586,29 @@ export function shouldBlockBash(command, cwd) {
     }
   }
 
-  // quick 阶段直接放行（不要求 worktree）
+  // quick 阶段：检查 quick-guard.json
   if (stage === 'quick') {
     // 危险黑名单仍然拦截
     if (matchDangerBlacklist(command)) {
       return { blocked: true, reason: `dangerous command blocked: ${command.trim()}` }
     }
+    // 检查命令是否会覆盖 baseline files
+    try {
+      const guardFile = path.join(projectRoot, '.sillyspec', '.runtime', 'quick-guard.json')
+      const guard = JSON.parse(readFileSync(guardFile, 'utf8'))
+      const baselineFiles = guard.baselineFiles || []
+      // 检查命令中是否引用了 baseline file
+      for (const f of baselineFiles) {
+        if (command.includes(f) && (command.includes('> ') || command.includes(' tee ') || command.includes('sed ') || command.includes('mv '))) {
+          return { blocked: true, reason: `quick 变更边界保护：命令可能覆盖 baseline 文件 ${f}` }
+        }
+      }
+    } catch {}
     return { blocked: false }
   }
 
   // execute 阶段 + 主工作区
-  const localConfig = loadLocalConfig(effectiveCwd)
+  const localConfig = loadLocalConfig(projectRoot)
   const extraReadonly = localConfig.worktreeHook?.readonlyCommands || localConfig['worktree-hook']?.readonlyCommands || []
 
   // 危险黑名单

package/src/index.js

@@ -32,6 +32,10 @@ SillySpec CLI — 规范驱动开发工具包
     --status                   查看阶段进度
     --reset                    重置阶段
     --change <name>            设置当前变更名
+    --spec-root <path>         平台模式：SillySpec storage root 路径
+    --runtime-root <path>       平台模式：运行时产物根路径
+    --workspace-id <id>         平台模式：workspace ID
+    --scan-run-id <id>          平台模式：scan run ID
     auto                       连续推进 brainstorm→plan→execute→verify
 
   可选阶段:
@@ -270,10 +274,29 @@ async function main() {
     }
     case 'worktree': {
       const { WorktreeManager } = await import('./worktree.js');
+      const { ProgressManager } = await import('./progress.js');
       const wtSubCmd = filteredArgs[1];
-      // 提取第一个非 -- 开头的位置参数作为 wtName
       const wtName = filteredArgs.slice(2).find(a => !a.startsWith('-'));
       const wm = new WorktreeManager({ cwd: dir });
+      const pm = new ProgressManager();
+
+      // isolation 写入 DB 的辅助函数
+      async function _writeIsolationToDB(cwd, changeName, info) {
+        if (info.blocked) {
+          await pm.updateChangeIsolation(cwd, changeName, {
+            status: 'blocked',
+            mode: null,
+            reason: info.reason,
+          });
+        } else {
+          const mode = info.mode || 'worktree';
+          const statusMap = { 'worktree': 'verified', 'native-worktree': 'verified', 'in-place-fallback': 'degraded' };
+          await pm.updateChangeIsolation(cwd, changeName, {
+            status: statusMap[mode] || 'verified',
+            mode,
+          });
+        }
+      }
 
       if (!wtSubCmd || wtSubCmd === 'help' || wtSubCmd === '--help' || wtSubCmd === '-h') {
         console.log(`
@@ -306,8 +329,15 @@ SillySpec worktree — git worktree 隔离管理
             console.log(`   分支: ${info.branch}`);
             console.log(`   路径: ${info.worktreePath}`);
             console.log(`   基准: ${info.baseHash.slice(0, 8)}`);
+            if (info.mode) {
+              console.log(`   模式: ${info.mode}`);
+            }
+            // 写入 isolation 信息到 gate-status.json
+            await _writeIsolationToDB(dir, wtName, info);
           } catch (e) {
             console.error(`❌ ${e.message}`);
+            // 写入 blocked 状态到 gate-status.json
+            await _writeIsolationToDB(dir, wtName, { blocked: true, reason: e.message });
             process.exit(1);
           }
           break;
@@ -373,9 +403,20 @@ SillySpec worktree — git worktree 隔离管理
             console.error('❌ 用法: sillyspec worktree cleanup <change-name>');
             process.exit(1);
           }
+          const forceFlag = args.includes('--force');
           try {
-            wm.cleanup(wtName);
-            console.log(`✅ worktree 已清理: ${wtName}`);
+            const result = wm.cleanup(wtName, { force: forceFlag });
+            if (result.result === 'cleaned') {
+              console.log(`✅ worktree 已清理: ${wtName} (mode: ${result.mode})`);
+            } else if (result.result === 'force-cleaned') {
+              console.log(`⚠️  worktree 已强制清理: ${wtName} (mode: ${result.mode})`);
+              console.log(`   原因: git worktree remove 失败，通过直接删除目录完成`);
+            } else if (result.result === 'skipped') {
+              console.log(`⏭️  worktree 跳过清理: ${wtName} (mode: ${result.mode})`);
+              console.log(`   原因: in-place 模式没有隔离目录需要清理`);
+            } else {
+              console.log(`ℹ️  worktree 未找到: ${wtName}`);
+            }
           } catch (e) {
             console.error(`❌ ${e.message}`);
             process.exit(1);

package/src/progress.js

@@ -393,6 +393,85 @@ export class ProgressManager {
     });
   }
 
+  /**
+   * 更新变更的隔离状态
+   * @param {string} cwd - 项目根目录
+   * @param {string} changeName - 变更名
+   * @param {{ status: string, mode?: string, reason?: string }} isolation
+   */
+  async updateChangeIsolation(cwd, changeName, isolation) {
+    const db = await this._ensureDB(cwd);
+    const sqlDb = db.getDb();
+    try {
+      sqlDb.run(
+        `UPDATE changes SET isolation_status = ?, isolation_mode = ?, isolation_reason = ?, last_active = ? WHERE name = ?`,
+        [isolation.status, isolation.mode || null, isolation.reason || null, new Date().toISOString(), changeName]
+      );
+      db._save();
+    } catch (err) {
+      console.warn('⚠️  更新 isolation 状态失败:', err.message);
+    }
+  }
+
+  /**
+   * 读取变更的隔离状态
+   * @param {string} cwd - 项目根目录
+   * @param {string} changeName - 变更名
+   * @returns {{ status: string|null, mode: string|null, reason: string|null }|null}
+   */
+  async readChangeIsolation(cwd, changeName) {
+    const db = await this._ensureDB(cwd);
+    const sqlDb = db.getDb();
+    try {
+      const rows = sqlDb.exec(
+        `SELECT isolation_status, isolation_mode, isolation_reason FROM changes WHERE name = ?`,
+        [changeName]
+      );
+      if (!rows || rows.length === 0 || rows[0].values.length === 0) return null;
+      const [status, mode, reason] = rows[0].values[0];
+      return { status: status || null, mode: mode || null, reason: reason || null };
+    } catch {
+      return null;
+    }
+  }
+
+  async _updatePlatformLastSync(cwd, changeName) {
+    if (!changeName) return;
+    const db = await this._ensureDB(cwd);
+    db.transaction((sqlDb) => {
+      sqlDb.run(
+        'UPDATE changes SET platform_last_sync = ?, platform_sync_enabled = 1 WHERE name = ?',
+        [new Date().toISOString(), changeName]
+      );
+    });
+  }
+
+  async _updateApprovalStatus(cwd, changeName, status, reason = null) {
+    if (!changeName || !status) return;
+    const db = await this._ensureDB(cwd);
+    db.transaction((sqlDb) => {
+      const rows = sqlDb.exec('SELECT id FROM changes WHERE name = ?', [changeName]);
+      if (!rows || rows.length === 0 || rows[0].values.length === 0) return;
+      const changeId = rows[0].values[0][0];
+      const now = new Date().toISOString();
+      sqlDb.run(
+        `INSERT INTO approvals (change_id, status, requested_at, approved_at, rejection_reason)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(change_id) DO UPDATE SET
+           status = excluded.status,
+           approved_at = excluded.approved_at,
+           rejection_reason = excluded.rejection_reason`,
+        [
+          changeId,
+          status,
+          now,
+          status === 'approved' ? now : null,
+          status === 'rejected' ? reason : null,
+        ]
+      );
+    });
+  }
+
   /**
    * 重命名变更：同步更新 DB + 目录
    * @param {string} cwd - 项目根目录