sillyspec 3.25.9 → 3.26.0

package/src/progress/change-registry.js

@@ -12,32 +12,33 @@ export class ChangeRegistry {
    * 列出所有活跃变更名
    * SQL: SELECT name FROM changes WHERE status = 'active'
    */
-  async listChanges(cwd) {
-    const db = await this.pm._ensureDB(cwd);
+  listChanges(cwd) {
+    const db = this.pm._ensureDB(cwd);
     const sqlDb = db.getDb();
-    const rows = sqlDb.exec("SELECT name FROM changes WHERE status = 'active' ORDER BY name");
-    if (!rows || rows.length === 0) return [];
-    return rows[0].values.map(r => r[0]);
+    const rows = sqlDb.prepare("SELECT name FROM changes WHERE status = 'active' ORDER BY name").all();
+    return rows.map(r => r.name);
   }
 
   /**
    * 注册变更到活跃列表
    * SQL: INSERT OR IGNORE → 若已 archived 则 UPDATE status='active'
    */
-  async registerChange(cwd, changeName) {
+  registerChange(cwd, changeName) {
     if (!changeName) {
       console.warn('⚠️  registerChange: changeName 为空，跳过');
       return;
     }
-    const db = await this.pm._ensureDB(cwd);
-    db.transaction((sqlDb) => {
+    const db = this.pm._ensureDB(cwd);
+    db.transaction(() => {
+      const sqlDb = db.getDb();
       const now = new Date().toISOString();
       // 尝试插入新行
-      sqlDb.run(
+      const ins = sqlDb.prepare(
         `INSERT OR IGNORE INTO changes (name, created_at, last_active)
-         VALUES (?, ?, ?)`,
-        [changeName, now, now]
-      );
+         VALUES (?, ?, ?)`
+      ).run(changeName, now, now);
+      // 只在真正创建 change 时标脏（D-013/task-04）；已存在行不标（读路径/重复调用不误判脏）
+      if (ins.changes > 0) this.pm._touchLocalModified(cwd, changeName, now);
       // 注意：不复活已归档的变更——归档是不可逆操作
       // 如果变更已存在且为 archived，保持 archived 状态不变
     });
@@ -49,15 +50,18 @@ export class ChangeRegistry {
    * @param {string} changeName - 变更名
    * @param {{ status: string, mode?: string, reason?: string }} isolation
    */
-  async updateChangeIsolation(cwd, changeName, isolation) {
-    const db = await this.pm._ensureDB(cwd);
-    const sqlDb = db.getDb();
+  updateChangeIsolation(cwd, changeName, isolation) {
+    const db = this.pm._ensureDB(cwd);
     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();
+      db.transaction(() => {
+        const sqlDb = db.getDb();
+        const now = new Date().toISOString();
+        sqlDb.prepare(
+          `UPDATE changes SET isolation_status = ?, isolation_mode = ?, isolation_reason = ?, last_active = ? WHERE name = ?`
+        ).run(isolation.status, isolation.mode || null, isolation.reason || null, now, changeName);
+        // 本地脏度（D-013 / task-04）：隔离状态变更也是本地推进
+        this.pm._touchLocalModified(cwd, changeName, now);
+      });
     } catch (err) {
       console.warn('⚠️  更新 isolation 状态失败:', err.message);
     }
@@ -69,56 +73,57 @@ export class ChangeRegistry {
    * @param {string} changeName - 变更名
    * @returns {{ status: string|null, mode: string|null, reason: string|null }|null}
    */
-  async readChangeIsolation(cwd, changeName) {
-    const db = await this.pm._ensureDB(cwd);
+  readChangeIsolation(cwd, changeName) {
+    const db = this.pm._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];
+      const row = sqlDb.prepare(
+        `SELECT isolation_status, isolation_mode, isolation_reason FROM changes WHERE name = ?`
+      ).get(changeName);
+      if (row === undefined) return null;
+      const { isolation_status: status, isolation_mode: mode, isolation_reason: reason } = row;
       return { status: status || null, mode: mode || null, reason: reason || null };
     } catch {
       return null;
     }
   }
 
-  async _updatePlatformLastSync(cwd, changeName) {
+  _updatePlatformLastSync(cwd, changeName) {
     if (!changeName) return;
-    const db = await this.pm._ensureDB(cwd);
-    db.transaction((sqlDb) => {
-      sqlDb.run(
-        'UPDATE changes SET platform_last_sync = ?, platform_sync_enabled = 1 WHERE name = ?',
-        [new Date().toISOString(), changeName]
-      );
+    const db = this.pm._ensureDB(cwd);
+    db.transaction(() => {
+      const sqlDb = db.getDb();
+      sqlDb.prepare(
+        'UPDATE changes SET platform_last_sync = ?, platform_sync_enabled = 1 WHERE name = ?'
+      ).run(new Date().toISOString(), changeName);
     });
   }
 
-  async _updateApprovalStatus(cwd, changeName, status, reason = null) {
+  _updateApprovalStatus(cwd, changeName, status, reason = null) {
     if (!changeName || !status) return;
-    const db = await this.pm._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 db = this.pm._ensureDB(cwd);
+    db.transaction(() => {
+      const sqlDb = db.getDb();
+      const row = sqlDb.prepare('SELECT id FROM changes WHERE name = ?').get(changeName);
+      if (row === undefined) return;
+      const changeId = row.id;
       const now = new Date().toISOString();
-      sqlDb.run(
+      sqlDb.prepare(
         `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,
-        ]
+           rejection_reason = excluded.rejection_reason`
+      ).run(
+        changeId,
+        status,
+        now,
+        status === 'approved' ? now : null,
+        status === 'rejected' ? reason : null,
       );
+      // 本地脏度（D-013 / task-04）：审批状态变更也是本地推进
+      this.pm._touchLocalModified(cwd, changeName, now);
     });
   }
 
@@ -128,7 +133,7 @@ export class ChangeRegistry {
    * @param {string} oldName - 旧变更名
    * @param {string} newName - 新变更名
    */
-  async renameChange(cwd, oldName, newName) {
+  renameChange(cwd, oldName, newName) {
     if (!oldName || !newName) {
       console.warn('⚠️  renameChange: 旧名或新名为空，跳过');
       return;
@@ -137,21 +142,23 @@ export class ChangeRegistry {
       console.warn('⚠️  renameChange: 新旧名称相同，跳过');
       return;
     }
-    const db = await this.pm._ensureDB(cwd);
+    const db = this.pm._ensureDB(cwd);
     // 检查旧名是否存在
-    const existing = db.transaction((sqlDb) => {
-      const row = sqlDb.exec(`SELECT name, status FROM changes WHERE name = ?`, [oldName]);
-      if (!row || !row[0] || row[0].values.length === 0) return null;
-      return { name: row[0].values[0][0], status: row[0].values[0][1] };
+    const existing = db.transaction(() => {
+      const sqlDb = db.getDb();
+      const row = sqlDb.prepare(`SELECT name, status FROM changes WHERE name = ?`).get(oldName);
+      if (row === undefined) return null;
+      return { name: row.name, status: row.status };
     });
     if (!existing) {
       console.error(`❌ 变更 ${oldName} 不存在`);
       return;
     }
     // 检查新名是否已存在
-    const conflict = db.transaction((sqlDb) => {
-      const row = sqlDb.exec(`SELECT name FROM changes WHERE name = ?`, [newName]);
-      return row && row[0] && row[0].values.length > 0;
+    const conflict = db.transaction(() => {
+      const sqlDb = db.getDb();
+      const row = sqlDb.prepare(`SELECT name FROM changes WHERE name = ?`).get(newName);
+      return row !== undefined;
     });
     if (conflict) {
       console.error(`❌ 变更 ${newName} 已存在`);
@@ -164,8 +171,11 @@ export class ChangeRegistry {
     const newDir = this.pm._changePath(cwd, newName);
     const now = new Date().toISOString();
     try {
-      db.transaction((sqlDb) => {
-        sqlDb.run(`UPDATE changes SET name = ?, last_active = ? WHERE name = ?`, [newName, now, oldName]);
+      db.transaction(() => {
+        const sqlDb = db.getDb();
+        sqlDb.prepare(`UPDATE changes SET name = ?, last_active = ? WHERE name = ?`).run(newName, now, oldName);
+        // 本地脏度（D-013 / task-04）：重命名也是本地推进（标新名）
+        this.pm._touchLocalModified(cwd, newName, now);
       });
     } catch (e) {
       console.error(`❌ 重命名失败：更新数据库时出错（${e.message}）`);
@@ -179,8 +189,11 @@ export class ChangeRegistry {
         renamed = false;
         // FS 重命名失败：回滚 DB 恢复 oldName，保持 DB 与目录一致
         try {
-          db.transaction((sqlDb) => {
-            sqlDb.run(`UPDATE changes SET name = ?, last_active = ? WHERE name = ?`, [oldName, now, newName]);
+          db.transaction(() => {
+            const sqlDb = db.getDb();
+            sqlDb.prepare(`UPDATE changes SET name = ?, last_active = ? WHERE name = ?`).run(oldName, now, newName);
+            // 回滚也是写（恢复 oldName），对称标脏旧名
+            this.pm._touchLocalModified(cwd, oldName, now);
           });
           console.error(`❌ 重命名失败：移动目录出错（${e.message}），已回滚数据库`);
         } catch (rollbackErr) {
@@ -199,18 +212,20 @@ export class ChangeRegistry {
    * 从活跃列表移除变更（归档时调用，不物理删除）
    * SQL: UPDATE changes SET status = 'archived'
    */
-  async unregisterChange(cwd, changeName) {
+  unregisterChange(cwd, changeName) {
     if (!changeName) {
       console.warn('⚠️  unregisterChange: changeName 为空，跳过');
       return;
     }
-    const db = await this.pm._ensureDB(cwd);
-    db.transaction((sqlDb) => {
+    const db = this.pm._ensureDB(cwd);
+    db.transaction(() => {
+      const sqlDb = db.getDb();
       const now = new Date().toISOString();
-      sqlDb.run(
-        `UPDATE changes SET status = 'archived', last_active = ? WHERE name = ?`,
-        [now, changeName]
-      );
+      sqlDb.prepare(
+        `UPDATE changes SET status = 'archived', last_active = ? WHERE name = ?`
+      ).run(now, changeName);
+      // 本地脏度（D-013 / task-04）：归档也是本地状态推进
+      this.pm._touchLocalModified(cwd, changeName, now);
     });
   }
 }

package/src/progress/consistency-doctor.js

@@ -1,9 +1,10 @@
 // W6 Step9a: Revision v1 状态一致性检查 + 修复 + --force 审计日志。
 // 从 src/progress.js 单体 ProgressManager 抽出。持有 pm 引用（构造注入），调 pm.read / pm._write /
 // pm._ensureRuntimeDir / pm._runtimePath（persistence-core 留 facade 本体）。
-import { appendFileSync } from 'fs';
-import { existsSync } from 'fs';
-import { STAGE_ORDER } from './shared.js';
+import { appendFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { summarizeTaskCompletion } from '../task-review.js';
+import { STAGE_ORDER, MAIN_FLOW_ORDER } from './shared.js';
 
 export class ConsistencyDoctor {
   constructor(pm) {
@@ -32,8 +33,8 @@ export class ConsistencyDoctor {
    * @param {string|null} changeName
    * @returns {{ ok: boolean, issues: string[], warnings: string[] }}
    */
-  async checkConsistency(cwd, changeName = null) {
-    const data = await this.pm.read(cwd, changeName);
+  checkConsistency(cwd, changeName = null) {
+    const data = this.pm.read(cwd, changeName);
     if (!data) {
       return { ok: false, issues: ['无法读取进度数据'], warnings: [] };
     }
@@ -71,9 +72,11 @@ export class ConsistencyDoctor {
       }
 
       // d. 下游 completed 不能出现在上游 stale/revising 之后
-      const stageIdx = STAGE_ORDER.indexOf(stageName);
+      // 用 MAIN_FLOW_ORDER（不含 scan）算上下游：scan 是 auxiliary 永不要求 completed，
+      // 把 scan 当上游会让「scan stale/revising」误报 brainstorm 不该 completed（plan-c 同根因）。
+      const stageIdx = MAIN_FLOW_ORDER.indexOf(stageName);
       for (let i = 0; i < stageIdx; i++) {
-        const upstream = STAGE_ORDER[i];
+        const upstream = MAIN_FLOW_ORDER[i];
         const upData = data.stages[upstream];
         if (upData && (upData.status === 'stale' || upData.status === 'revising')) {
           if (sd.status === 'completed') {
@@ -91,6 +94,12 @@ export class ConsistencyDoctor {
       }
     }
 
+    // FR-07 / AC-03 / design §7 / D-02：lost-update 间接信号
+    // （.runtime/worktrees/<change> 目录残留 vs DB current_stage≠execute）。
+    // 只读诊断并入 issues 报告，不写 DB / 不删 worktree / 不自动修复。
+    const lostUpdateSignals = this.detectLostUpdateSignals(cwd);
+    issues.push(...lostUpdateSignals);
+
     // 输出报告
     console.log('');
     console.log('  ═══════════════════════════════════════');
@@ -114,6 +123,55 @@ export class ConsistencyDoctor {
     return { ok: issues.length === 0, issues, warnings };
   }
 
+  /**
+   * 检测 lost-update 间接信号（FR-07 / AC-03 / design §7 / D-02）。
+   *
+   * 判据：.runtime/worktrees/<change> 目录存在但 DB current_stage ≠ 'execute'
+   * → worktree 残留但进度被回退，是并发场景下 lost-update 的间接痕迹。
+   *
+   * 信号定义严格遵循 design §7 / FR-07：仅 current_stage !== 'execute' 判信号，
+   * 不扩展到 quick 等其它 stage；DB 无对应行（data=null）的 worktree 目录不算信号。
+   *
+   * 只读诊断：不写 DB、不删 worktree 目录、不自动修复
+   * （修复仍走 doctor --align / repairConsistency 既有逻辑）。
+   *
+   * @param {string} cwd
+   * @returns {string[]} issue 描述数组（每条含 change 名、实际 current_stage、worktree 目录路径）
+   */
+  detectLostUpdateSignals(cwd) {
+    const worktreesRoot = this.pm._runtimePath(cwd, 'worktrees');
+    // 零信号兼容既有 fixture：worktrees 目录不存在或读取失败时直接返回空数组
+    if (!existsSync(worktreesRoot)) return [];
+
+    let entries;
+    try {
+      entries = readdirSync(worktreesRoot, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+
+    const issues = [];
+    for (const entry of entries) {
+      // Dirent.isDirectory 在 Windows / Linux / macOS 上一致判定目录项
+      if (!entry.isDirectory()) continue;
+      const changeName = entry.name;
+      const worktreeDir = join(worktreesRoot, changeName);
+
+      // 复用 pm.read（task-08 已同步化，直接拿返回值，无 await），不新开 DB 连接
+      const data = this.pm.read(cwd, changeName);
+      // DB 无对应行（data=null）不算信号，跳过
+      if (!data) continue;
+      // 仅 current_stage !== 'execute' 判信号
+      if (data.currentStage !== 'execute') {
+        issues.push(
+          `lost-update 信号: change "${changeName}" 的 worktree 目录仍存在（${worktreeDir}），` +
+          `但 current_stage 为 "${data.currentStage}"（非 execute，疑进度被回退）`
+        );
+      }
+    }
+    return issues;
+  }
+
   /**
    * Revision v1.2 状态修复
    * 默认 dry-run，--apply 才真正修改 DB。
@@ -125,10 +183,10 @@ export class ConsistencyDoctor {
    * @param {string|null} [opts.changeName]
    * @returns {{ fixable: object[], manual: string[], applied: object[] }}
    */
-  async repairConsistency(cwd, opts = {}) {
+  repairConsistency(cwd, opts = {}) {
     const { apply = false, changeName = null } = opts;
 
-    const data = await this.pm.read(cwd, changeName);
+    const data = this.pm.read(cwd, changeName);
     if (!data) {
       console.log('❌ 无法读取进度数据');
       return { fixable: [], manual: ['无法读取进度数据'], applied: [] };
@@ -156,10 +214,10 @@ export class ConsistencyDoctor {
         });
       }
 
-      // Fix b: 上游 stale/revising，下游仍 completed → cascade stale
-      const stageIdx = STAGE_ORDER.indexOf(stageName);
+      // Fix b: 上游 stale/revising，下游仍 completed → cascade stale（同 d，用 MAIN_FLOW_ORDER 排除 scan）
+      const stageIdx = MAIN_FLOW_ORDER.indexOf(stageName);
       for (let i = 0; i < stageIdx; i++) {
-        const upstream = STAGE_ORDER[i];
+        const upstream = MAIN_FLOW_ORDER[i];
         const upData = data.stages[upstream];
         if (upData && (upData.status === 'stale' || upData.status === 'revising')) {
           if (sd.status === 'completed') {
@@ -206,7 +264,6 @@ export class ConsistencyDoctor {
             const changeDir = this.pm._changePath(cwd, changeName);
             if (changeDir && existsSync(changeDir)) {
               const runtimeRoot = this.pm._runtimePath(cwd);
-              const { summarizeTaskCompletion } = await import('../task-review.js');
               const summary = summarizeTaskCompletion({ changeDir, runtimeRoot, changeName });
               if (summary.source === 'review.json' && summary.total > 0 && summary.pending.length === 0) {
                 const desc = `execute: ${badSteps.length} 个 step 状态脱钩（${badSteps.map(st => st.name).join(', ')}）——review.json 客观产出全通过（${summary.completed}/${summary.total}），自动标 completed`;
@@ -286,7 +343,7 @@ export class ConsistencyDoctor {
 
     if (apply && applied.length > 0) {
       data.lastActive = now;
-      await this.pm._write(cwd, data, changeName);
+      this.pm._write(cwd, data, changeName);
       console.log(`\n  ✅ 已修复 ${applied.length} 项`);
     }
 

package/src/progress/shared.js

@@ -18,13 +18,16 @@ export const STAGE_LABELS = {
   archive: '📦 归档变更',
 };
 
-// 完整主流程顺序（含 scan），用于下游 cascade / 一致性检查
+// 完整阶段顺序（含 scan），仅用于展示/迭代顺序
 export const STAGE_ORDER = ['scan', 'brainstorm', 'plan', 'execute', 'verify', 'archive'];
-// 主流程阶段（不含 scan/quick/explore 等辅助阶段）—— 当前与 STAGE_ORDER 同值
-export const MAIN_FLOW_ORDER = STAGE_ORDER;
+// 主流程阶段（不含 scan/quick/explore 等辅助阶段）—— 用于下游 cascade / 一致性上下游判定。
+// scan 是 auxiliary（AUXILIARY_STAGES，按需显式跑、可 failed_post_check、永不要求 completed），
+// 把它算进主流程上下游会让「scan stale/revising」误报 brainstorm/plan/execute 不该 completed
+// （consistency-doctor 坑 + prompt-control-debt plan-c 同根因）。
+export const MAIN_FLOW_ORDER = ['brainstorm', 'plan', 'execute', 'verify', 'archive'];
 
-// progress 数据版本（v3 = SQLite）
-export const CURRENT_VERSION = 3;
+// progress 数据版本（v3 = SQLite；v4 = changes 加 base_ts / 本地脏度两列，platform-sync §8）
+export const CURRENT_VERSION = 4;
 
 // 空阶段骨架
 export function emptyStage() {