sillyspec 3.25.0 → 3.25.1

package/package.json

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

package/src/db.js

@@ -2,6 +2,11 @@ import initSqlJs from 'sql.js';
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'fs';
 import { basename, dirname, join } from 'path';
 
+// DB schema 版本（与 project.schema_version DEFAULT 对齐）。_createSchema 改动（加表/列/migration）时 bump，
+// 触发 .schema-version 戳失效 → 下次 init 重跑 _createSchema + _save（W4-H：高频读路径 gate/derive/status
+// 每次 new ProgressManager 都过 init，原无条件 _createSchema+_save 致每次整库 export+三段原子写）。
+const DB_SCHEMA_VERSION = 3;
+
 export class DB {
   constructor(dbPath) {
     this.dbPath = dbPath;
@@ -25,11 +30,21 @@ export class DB {
     this.db.run('PRAGMA foreign_keys = ON');
     this.db.run('PRAGMA synchronous = NORMAL');
 
-    // 5. 创建表结构
-    this._createSchema();
+    // 5. 创建表结构（仅当 schema 版本戳不匹配时——W4-H）：
+    //    schema 已最新则只 load 不写，省掉 _createSchema + _save 的整库 export + 三段原子写。
+    //    戳在但 db 缺表属"手动改 db"边角（SillySpec 不支持），_loadDatabase 的损坏检测兜底正常路径。
+    const versionPath = `${this.dbPath}.schema-version`;
+    let schemaCurrent = false;
+    try {
+      schemaCurrent = existsSync(versionPath)
+        && readFileSync(versionPath, 'utf8').trim() === String(DB_SCHEMA_VERSION);
+    } catch { /* 戳读取失败保守重跑 schema */ }
 
-    // 6. 保存到磁盘
-    this._save();
+    if (!schemaCurrent) {
+      this._createSchema();
+      this._save();
+      try { writeFileSync(versionPath, String(DB_SCHEMA_VERSION)); } catch { /* 戳写入失败不阻断，下次重跑 */ }
+    }
   }
 
   close() {
@@ -43,15 +58,20 @@ export class DB {
   transaction(fn) {
     if (!this.db) throw new Error('DB not initialized');
     this.db.run('BEGIN');
+    let result;
     try {
-      const result = fn(this.db);
+      result = fn(this.db);
       this.db.run('COMMIT');
-      this._save();
-      return result;
     } catch (err) {
-      this.db.run('ROLLBACK');
+      // fn 抛错或 COMMIT 失败：事务级回滚（此时事务确实活跃，ROLLBACK 有效）
+      try { this.db.run('ROLLBACK'); } catch { /* 事务可能已被 fn 内的错自动回滚 */ }
       throw err;
     }
+    // COMMIT 成功后才持久化。_save 失败时抛原生错（磁盘满/EPERM），不再被 catch 里
+    // 无效的 ROLLBACK 二级异常（"no transaction active"）掩盖——内存库已 commit，
+    // 下次 _save / close() 会落盘，调用方拿到的是准确的持久化错误而非被替换的误报。
+    this._save();
+    return result;
   }
 
   /** 获取底层 db 对象（供 progress.js 直接使用） */

package/src/hooks/worktree-guard.js

@@ -258,12 +258,19 @@ function queryDbFirstCell(cwd, sql) {
     "if(!fs.existsSync(dbPath))process.exit(0);" +
     "import(lib).then(async m=>{const SQL=await m.default();" +
     "const db=new SQL.Database(fs.readFileSync(dbPath));const r=db.exec(sql);" +
-    "if(r.length&&r[0].values.length)process.stdout.write(String(r[0].values[0][0]??''));db.close()}).catch(()=>{});"
+    "if(r.length&&r[0].values.length)process.stdout.write(String(r[0].values[0][0]??''));db.close()}).catch(e=>{process.stderr.write('hook db query failed: '+String(e&&e.message||e));process.exit(1)});"
   try {
     return execFileSync(process.execPath, ['-e', script], {
       encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'],
     }).trim() || null
-  } catch { return null }
+  } catch (e) {
+    // DB 查询失败（db 损坏 / sql.js resolve 失败 / 子进程超时）：降级返回 null，调用方
+    //（readCurrentStage 等）对 null 走 fail-closed。补 warn 让 doctor/agent 能看到根因，
+    // 而非完全静默（子进程把诊断写到了 stderr，execFileSync 抛错时挂在 e.stderr 上）。
+    const detail = (e && e.stderr ? String(e.stderr).trim() : '') || (e && e.message) || 'timeout/crash'
+    console.warn('⚠️ sillyspec.db 查询失败，hook 降级 fail-closed: ' + detail)
+    return null
+  }
 }
 
 export { queryDbFirstCell as _queryDbFirstCellForTest };

package/src/index.js

@@ -340,8 +340,8 @@ async function main() {
           for (const e of (c.errors || [])) console.log(`     ✗ ${e}`);
           for (const w of (c.warnings || [])) console.log(`     ⚠ ${w}`);
         }
-        for (const e of (envelope.errors || [])) console.log(`  ✗ ${e}`);
-        for (const w of (envelope.warnings || [])) console.log(`  ⚠ ${w}`);
+        // 顶层 errors/warnings 是各 check 的聚合，已在上面按 check 分组显示；不再重复打印——
+        // 非 json 是 agent 默认消费路径，重复文本纯耗 context（W1-J）。
       }
       process.exitCode = exitCode;
       break;
@@ -402,7 +402,7 @@ async function main() {
       const { runCommand } = await import('./run.js')
       // 平台模式（--spec-dir 已指定）时，--dir 是明确的 source_root，不应被 resolveEffectiveDir 纠正
       const effectiveDir = specDir ? dir : resolveEffectiveDir(dir)
-      await runCommand(filteredArgs.slice(1), effectiveDir, specDir)
+      await runCommand(filteredArgs.slice(1), effectiveDir, specDir, { json })
       break
     }
     // 顶层命令别名：转发 runCommand，与 case 'run': 路径行为一致。
@@ -513,7 +513,7 @@ async function main() {
       }
       // 否则：保持原有 prompt 驱动的 bash 自检流程
       const { runCommand } = await import('./run.js');
-      await runCommand([command, ...filteredArgs.slice(1)], doctorEffectiveDir, specDir);
+      await runCommand([command, ...filteredArgs.slice(1)], doctorEffectiveDir, specDir, { json });
       break;
     }
     case 'scan':
@@ -528,7 +528,7 @@ async function main() {
       const { runCommand } = await import('./run.js')
       const stageArgs = [command, ...filteredArgs.slice(1)]
       const effectiveDir = specDir ? dir : resolveEffectiveDir(dir)
-      await runCommand(stageArgs, effectiveDir, specDir)
+      await runCommand(stageArgs, effectiveDir, specDir, { json })
       break
     }
     case 'knowledge': {

package/src/machine-interface.js

@@ -125,10 +125,16 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot }
     const currentStage = progress.currentStage || '';
     const checks = [];
 
+    // W4-G (D-008)：execute 阶段预计算 code evidence 一次，供 artifacts check（经 runValidators
+    // → validateExecuteOutputs）与下方 execute-evidence check 共享——避免各调一次 checkExecuteCodeEvidence
+    // 各 spawn 2 个 git 进程（gate execute 一次省 ≈ 60-200ms on Windows）。
+    const sharedEvidence = stage === 'execute' ? checkExecuteCodeEvidence(cwd, changeName) : undefined;
+
     // ── a. artifacts：阶段产物校验（全部阶段）──
     const r = runValidators(stage, cwd, changeName, {
       projectName: progress.project,
       specRoot,
+      ...(sharedEvidence ? { evidence: sharedEvidence } : {}),
     });
     checks.push({
       id: 'artifacts',
@@ -137,24 +143,24 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot }
       warnings: r.warnings || [],
     });
 
-    // ── b. transition：状态转换合法性（信息性，不参与综合 ok）──
-    // 与 run.js:1727 同源：传 fromStageData 触发 failed_post_check 门控，避免 gate 的
-    // transition 结论与 completeStep 漂移（design §8「聚合语义漂移」风险对策）。
+    // ── b. transition：状态转换合法性（参与综合 ok，与 completeStep 硬阻断一致）──
+    // 与 run.js runStage 同源：传 fromStageData 触发 failed_post_check 门控。
+    // transition 必须参与 ok：否则 gate 返回 ok=true、exit 0，Agent 据此 --done 却被
+    // runStage 的 checkTransition 硬阻断（exit 1），gate/run 判定分裂（design §8 漂移）。
     const fromStageData = (progress.stages && currentStage && progress.stages[currentStage]) || undefined;
     const t = checkTransition(currentStage, stage, fromStageData ? { fromStageData } : {});
     checks.push({
       id: 'transition',
       ok: t.allowed,
-      informational: true,
       errors: t.allowed ? [] : [t.reason].filter(Boolean),
       warnings: [],
     });
 
     // ── c. execute 阶段追加 execute-evidence + task-reviews ──
-    // D-008@v1 去重：checkExecuteCodeEvidence 整个 runGate 只调一次，
-    // 结果同时供 execute-evidence check 的 data 与综合结论。
+    // D-008 + W4-G：checkExecuteCodeEvidence 整个 runGate 只调一次（顶部 sharedEvidence 预计算），
+    // 这里复用——真正落实去重（原注释声称"只调一次"但实现里 execute-evidence check 仍重复调了第二次）。
     if (stage === 'execute') {
-      const ev = checkExecuteCodeEvidence(cwd, changeName);
+      const ev = sharedEvidence;
       checks.push({
         id: 'execute-evidence',
         ok: ev.status !== 'unchanged',

package/src/progress.js

@@ -645,8 +645,12 @@ export class ProgressManager {
           db.transaction((sqlDb) => {
             sqlDb.run(`UPDATE changes SET name = ?, last_active = ? WHERE name = ?`, [oldName, now, newName]);
           });
-        } catch {}
-        console.error(`❌ 重命名失败：移动目录出错（${e.message}），已回滚数据库`);
+          console.error(`❌ 重命名失败：移动目录出错（${e.message}），已回滚数据库`);
+        } catch (rollbackErr) {
+          // 回滚本身也失败：DB 是 newName、目录是 oldName，两端分裂且无自动恢复。
+          // 不能再撒谎"已回滚"——必须显式报错让用户跑 doctor 修复。
+          console.error(`❌ 重命名失败且数据库回滚也失败（状态分裂，需手动修复）：原错=${e.message} 回滚错=${rollbackErr.message}。请跑 sillyspec doctor --json`);
+        }
       }
     } else {
       mkdirSync(newDir, { recursive: true });
@@ -1815,9 +1819,16 @@ export class ProgressManager {
     const gatePath = this._runtimePath(cwd, 'gate-status.json');
 
     if (!rows || rows.length === 0 || rows[0].values.length === 0) {
-      // 无 execute/quick 阶段的活跃变更，删除 gate-status
+      // 无 execute/quick 阶段的活跃变更：写墓碑而非 unlink。unlink 失败（Windows 杀毒/索引占用）
+      // 会被空 catch 吞掉，陈旧 gate-status 残留 → hook 把 brainstorm 误当 execute 放行（fail-open）。
+      // 墓碑 {stage:null} 让 readCurrentStage 的 `gateStatus.stage` 为假 → 自动 fallback DB，语义等价删除但原子。
       if (existsSync(gatePath)) {
-        try { unlinkSync(gatePath); } catch {}
+        try {
+          this._ensureRuntimeDir(cwd);
+          writeAtomicSync(gatePath, JSON.stringify({ stage: null, tombstone: true, updatedAt: new Date().toISOString() }) + '\n');
+        } catch (e) {
+          console.warn(`⚠️ gate-status 墓碑写入失败（hook 可能读到陈旧缓存）: ${e.message}`);
+        }
       }
       return;
     }
@@ -1837,9 +1848,14 @@ export class ProgressManager {
     }
 
     if (!gateStage) {
-      // current_stage 为 NULL 的边界情况，等同于无 execute/quick
+      // current_stage 为 NULL 的边界情况，等同于无 execute/quick：同样写墓碑（见上 rationale）
       if (existsSync(gatePath)) {
-        try { unlinkSync(gatePath); } catch {}
+        try {
+          this._ensureRuntimeDir(cwd);
+          writeAtomicSync(gatePath, JSON.stringify({ stage: null, tombstone: true, updatedAt: new Date().toISOString() }) + '\n');
+        } catch (e) {
+          console.warn(`⚠️ gate-status 墓碑写入失败（hook 可能读到陈旧缓存）: ${e.message}`);
+        }
       }
       return;
     }