sillyspec 3.25.9 → 3.26.0

package/src/progress/stage-machine.js

@@ -6,6 +6,7 @@
 import { mkdirSync } from 'fs';
 import { join, resolve, basename } from 'path';
 import { writeAtomicSync } from '../fs-atomic.js';
+import { runValidators } from '../stage-contract.js';
 import { VALID_STAGES, STAGE_LABELS, STAGE_ORDER, MAIN_FLOW_ORDER, SPEC_DIR_NAME, CURRENT_VERSION, emptyStage } from './shared.js';
 
 export class StageMachine {
@@ -17,14 +18,13 @@ export class StageMachine {
    * 阶段产物校验门：progress complete-stage / update-step 自动完成时复用
    * stage-contract 的 validator，防止零产物阶段被直接标 completed。
    */
-  async _validateStageArtifacts(cwd, stage, changeName) {
-    const { runValidators } = await import('../stage-contract.js');
+  _validateStageArtifacts(cwd, stage, changeName) {
     const specDir = this.pm._getSpecDir(cwd);
     const defaultSpec = join(resolve(cwd), SPEC_DIR_NAME);
     const specRoot = resolve(specDir) === defaultSpec ? null : specDir;
     let projectName = null;
     try {
-      const g = await this.pm.readGlobal(cwd);
+      const g = this.pm.readGlobal(cwd);
       projectName = g?.project || null;
     } catch {}
     return runValidators(stage, cwd, changeName, {
@@ -33,27 +33,27 @@ export class StageMachine {
     });
   }
 
-  async completeStage(cwd, stage, changeName = null, opts = {}) {
+  completeStage(cwd, stage, changeName = null, opts = {}) {
     const { force = false } = opts;
     if (!VALID_STAGES.includes(stage)) {
       console.log(`❌ 未知阶段: ${stage}`);
       return;
     }
 
-    const db = await this.pm._ensureDB(cwd);
+    const db = this.pm._ensureDB(cwd);
     const now = new Date().toISOString();
 
     // 获取变更名
     let cn = changeName;
     if (!cn) {
-      const changes = await this.pm.listChanges(cwd);
+      const changes = this.pm.listChanges(cwd);
       if (changes.length === 1) cn = changes[0];
       if (!cn) { console.log('❌ 无法确定当前变更，请指定 --change <name>'); return; }
     }
 
     // ── 产物校验门：complete-stage 不再是零校验后门 ──
     // 与 run.js completeStep 的 validator 同源；--force 为显式逃生口（留审计）。
-    const validation = await this._validateStageArtifacts(cwd, stage, cn);
+    const validation = this._validateStageArtifacts(cwd, stage, cn);
     if (!validation.ok) {
       if (!force) {
         console.error(`❌ complete-stage 被拒绝：阶段 ${stage} 产物校验未通过`);
@@ -75,39 +75,35 @@ export class StageMachine {
       this.pm._appendAuditLog(cwd, { action: 'complete-stage --force', stage, change: cn, validationErrors: [] });
     }
 
-    db.transaction((sqlDb) => {
-      const changeRow = sqlDb.exec('SELECT id FROM changes WHERE name = ?', [cn]);
-      if (!changeRow || changeRow.length === 0 || changeRow[0].values.length === 0) return;
-      const changeId = changeRow[0].values[0][0];
+    db.transaction(() => {
+      const sqlDb = db.getDb();
+      const changeRow = sqlDb.prepare('SELECT id FROM changes WHERE name = ?').get(cn);
+      if (changeRow === undefined) return;
+      const changeId = changeRow.id;
 
       // 确保 stages 行存在（阶段不存在时自动创建）
-      sqlDb.run(
-        'INSERT OR IGNORE INTO stages (change_id, stage, status) VALUES (?, ?, "pending")',
-        [changeId, stage]
-      );
+      sqlDb.prepare(`INSERT OR IGNORE INTO stages (change_id, stage, status) VALUES (?, ?, 'pending')`).run(changeId, stage);
 
       // UPDATE stages.status=completed + completed_at
-      sqlDb.run(
-        'UPDATE stages SET status = "completed", completed_at = ? WHERE change_id = ? AND stage = ?',
-        [now, changeId, stage]
-      );
+      sqlDb.prepare(`UPDATE stages SET status = 'completed', completed_at = ? WHERE change_id = ? AND stage = ?`).run(now, changeId, stage);
 
       // 将该阶段所有 pending 步骤标记为 completed
-      const stageRow = sqlDb.exec('SELECT id FROM stages WHERE change_id = ? AND stage = ?', [changeId, stage]);
-      if (stageRow && stageRow.length > 0 && stageRow[0].values.length > 0) {
-        const stageId = stageRow[0].values[0][0];
-        sqlDb.run(
-          'UPDATE steps SET status = "completed", completed_at = ? WHERE stage_id = ? AND status IN ("pending", "stale")', // stale 一并回填（reopen --done 场景，坑 brainstorm-reopen-step-state-desync）
-          [now, stageId]
-        );
+      const stageRow = sqlDb.prepare('SELECT id FROM stages WHERE change_id = ? AND stage = ?').get(changeId, stage);
+      if (stageRow !== undefined) {
+        const stageId = stageRow.id;
+        sqlDb.prepare(
+          `UPDATE steps SET status = 'completed', completed_at = ? WHERE stage_id = ? AND status IN ('pending', 'stale')` // stale 一并回填（reopen --done 场景，坑 brainstorm-reopen-step-state-desync）
+        ).run(now, stageId);
       }
 
       // UPDATE changes.last_active
-      sqlDb.run('UPDATE changes SET last_active = ? WHERE name = ?', [now, cn]);
+      sqlDb.prepare('UPDATE changes SET last_active = ? WHERE name = ?').run(now, cn);
+      // 本地脏度（D-013 / task-04）：阶段完成是本地推进
+      this.pm._touchLocalModified(cwd, cn, now);
     });
 
     // 写 history 文件（保持文件系统，不变）
-    const data = await this.pm.read(cwd, cn);
+    const data = this.pm.read(cwd, cn);
     if (data && data.stages && data.stages[stage]) {
       const historyDir = this.pm._runtimePath(cwd, 'history');
       mkdirSync(historyDir, { recursive: true });
@@ -122,25 +118,25 @@ export class StageMachine {
     console.log(`✅ 阶段 ${stage} 已标记为完成（不自动推进，下一步由你决定）`);
   }
 
-  async show(cwd, changeName = null) {
+  show(cwd, changeName = null) {
     // 如果指定了变更名，只显示该变更
     if (changeName) {
-      return await this._showChange(cwd, changeName);
+      return this._showChange(cwd, changeName);
     }
 
     // 否则显示所有变更
-    const changes = await this.pm.listChanges(cwd);
+    const changes = this.pm.listChanges(cwd);
     if (changes.length === 0) {
       console.log('ℹ️  没有活跃的变更');
       return;
     }
 
     if (changes.length === 1) {
-      return await this._showChange(cwd, changes[0]);
+      return this._showChange(cwd, changes[0]);
     }
 
     // 多个变更：汇总显示
-    const global = await this.pm.readGlobal(cwd);
+    const global = this.pm.readGlobal(cwd);
     console.log('');
     console.log('  ═══════════════════════════════════════');
     console.log(`  项目: ${(global?.project) || basename(cwd) || '(未命名)'}`);
@@ -149,7 +145,7 @@ export class StageMachine {
     console.log('');
 
     for (const cn of changes) {
-      const data = await this.pm.read(cwd, cn);
+      const data = this.pm.read(cwd, cn);
       if (!data) {
         console.log(`  📂 ${cn} — (无法读取)`);
         continue;
@@ -167,8 +163,8 @@ export class StageMachine {
     console.log('');
   }
 
-  async _showChange(cwd, changeName) {
-    const data = await this.pm.read(cwd, changeName);
+  _showChange(cwd, changeName) {
+    const data = this.pm.read(cwd, changeName);
     if (!data) {
       console.log(`❌ 未找到变更 ${changeName}`);
       return;
@@ -313,12 +309,12 @@ export class StageMachine {
     return null;
   }
 
-  async status(cwd, changeName = null) {
-    await this.show(cwd, changeName);
+  status(cwd, changeName = null) {
+    this.show(cwd, changeName);
   }
 
-  async validate(cwd, changeName = null) {
-    const data = await this.pm.read(cwd, changeName);
+  validate(cwd, changeName = null) {
+    const data = this.pm.read(cwd, changeName);
     if (!data) { console.log('❌ 无法读取进度数据'); return false; }
 
     const errors = [];
@@ -345,7 +341,7 @@ export class StageMachine {
       if (!fixed.stages[s]) { fixed.stages[s] = emptyStage(); changed = true; }
     }
     if (changed) {
-      await this.pm._write(cwd, fixed);
+      this.pm._write(cwd, fixed);
       console.log('✅ 已修复');
     }
 
@@ -365,10 +361,10 @@ export class StageMachine {
    * @param {string} [opts.changeName]
    * @returns {{ ok: boolean, error?: string }}
    */
-  async reopenStage(cwd, stage, opts = {}) {
+  reopenStage(cwd, stage, opts = {}) {
     const { fromStep, changeName = null } = opts;
 
-    const data = await this.pm.read(cwd, changeName);
+    const data = this.pm.read(cwd, changeName);
     if (!data) return { ok: false, error: '无法读取进度数据' };
 
     const stageData = data.stages[stage];
@@ -435,12 +431,12 @@ export class StageMachine {
     data.lastActive = now;
     data.currentStage = stage;
 
-    await this.pm._write(cwd, data, changeName);
+    this.pm._write(cwd, data, changeName);
 
     // 级联标记下游阶段为 stale
     const downstreamStages = this._getDownstreamStages(stage);
     if (downstreamStages.length > 0) {
-      const data2 = await this.pm.read(cwd, changeName); // 重新读取以获取最新状态
+      const data2 = this.pm.read(cwd, changeName); // 重新读取以获取最新状态
       if (data2) {
         for (const ds of downstreamStages) {
           if (data2.stages[ds] && data2.stages[ds].status === 'completed') {
@@ -449,7 +445,7 @@ export class StageMachine {
             data2.stages[ds].completedAt = null;
           }
         }
-        await this.pm._write(cwd, data2, changeName);
+        this.pm._write(cwd, data2, changeName);
       }
     }
 
@@ -467,9 +463,9 @@ export class StageMachine {
     return MAIN_FLOW_ORDER.slice(idx + 1);
   }
 
-  async reset(cwd, stage, changeName = null) {
+  reset(cwd, stage, changeName = null) {
     if (stage) {
-      const data = await this.pm.read(cwd, changeName);
+      const data = this.pm.read(cwd, changeName);
       if (!data) { console.log('❌ 无法读取进度数据'); return; }
       if (!data.stages[stage]) { console.log(`❌ 未知阶段: ${stage}`); return; }
       // 破坏性预览：reset 不可逆地清空该阶段所有步骤（含已完成），先告诉 agent 丢了什么。
@@ -479,38 +475,44 @@ export class StageMachine {
       console.warn(`⚠️  即将重置阶段「${stage}」：丢弃 ${steps.length} 个步骤（其中 ${doneCount} 个已完成，revision ${sd.revision || 0}）。此操作不可逆。`);
       data.stages[stage] = emptyStage();
       data.lastActive = new Date().toLocaleString('zh-CN',{hour12:false});
-      await this.pm._write(cwd, data);
+      this.pm._write(cwd, data);
       console.log(`✅ 已重置阶段: ${stage}`);
     } else {
       // 重置所有变更或指定变更
       if (changeName) {
         console.warn(`⚠️  即将重置变更「${changeName}」的全部进度（所有阶段的 steps + stage 状态，产物文件不动）。此操作不可逆。`);
         // SQL: 删除该变更的所有 stages 和 steps 数据
-        const db = await this.pm._ensureDB(cwd);
-        db.transaction((sqlDb) => {
-          const changeRow = sqlDb.exec('SELECT id FROM changes WHERE name = ?', [changeName]);
-          if (changeRow && changeRow.length > 0 && changeRow[0].values.length > 0) {
-            const changeId = changeRow[0].values[0][0];
-            sqlDb.run('DELETE FROM steps WHERE stage_id IN (SELECT id FROM stages WHERE change_id = ?)', [changeId]);
-            sqlDb.run('DELETE FROM stages WHERE change_id = ?', [changeId]);
+        const db = this.pm._ensureDB(cwd);
+        db.transaction(() => {
+          const sqlDb = db.getDb();
+          const changeRow = sqlDb.prepare('SELECT id FROM changes WHERE name = ?').get(changeName);
+          if (changeRow !== undefined) {
+            const changeId = changeRow.id;
+            sqlDb.prepare('DELETE FROM steps WHERE stage_id IN (SELECT id FROM stages WHERE change_id = ?)').run(changeId);
+            sqlDb.prepare('DELETE FROM stages WHERE change_id = ?').run(changeId);
             // 重新插入所有阶段（注意：上方已 DELETE stages，无需再 UPDATE）
             for (const s of VALID_STAGES) {
-              sqlDb.run('INSERT OR IGNORE INTO stages (change_id, stage, status) VALUES (?, ?, "pending")', [changeId, s]);
+              sqlDb.prepare(`INSERT OR IGNORE INTO stages (change_id, stage, status) VALUES (?, ?, 'pending')`).run(changeId, s);
             }
+            // 本地脏度（D-013 / task-04）：重置该变更全部进度是本地推进
+            this.pm._touchLocalModified(cwd, changeName);
           }
         });
         console.log(`✅ 已重置变更 ${changeName} 的进度`);
       } else {
-        const changes = await this.pm.listChanges(cwd);
+        const changes = this.pm.listChanges(cwd);
         console.warn(`⚠️  即将重置【所有 ${changes.length} 个变更】的进度（仅 stage 状态，产物文件不动）。此操作不可逆且范围最大。`);
-        const db = await this.pm._ensureDB(cwd);
-        db.transaction((sqlDb) => {
+        const db = this.pm._ensureDB(cwd);
+        db.transaction(() => {
+          const sqlDb = db.getDb();
           for (const cn of changes) {
-            const changeRow = sqlDb.exec('SELECT id FROM changes WHERE name = ?', [cn]);
-            if (changeRow && changeRow.length > 0 && changeRow[0].values.length > 0) {
-              const changeId = changeRow[0].values[0][0];
-              sqlDb.run('DELETE FROM steps WHERE stage_id IN (SELECT id FROM stages WHERE change_id = ?)', [changeId]);
-              sqlDb.run('UPDATE stages SET status = "pending", started_at = NULL, completed_at = NULL WHERE change_id = ?', [changeId]);
+            const changeRow = sqlDb.prepare('SELECT id FROM changes WHERE name = ?').get(cn);
+            if (changeRow !== undefined) {
+              const changeId = changeRow.id;
+              sqlDb.prepare('DELETE FROM steps WHERE stage_id IN (SELECT id FROM stages WHERE change_id = ?)').run(changeId);
+              sqlDb.prepare(`UPDATE stages SET status = 'pending', started_at = NULL, completed_at = NULL WHERE change_id = ?`).run(changeId);
+              // 本地脏度（D-013 / task-04）：重置进度是本地推进
+              this.pm._touchLocalModified(cwd, cn);
             }
           }
         });

package/src/progress/step-store.js

@@ -12,46 +12,44 @@ export class StepStore {
     this.pm = pm;
   }
 
-  async setStage(cwd, stage, changeName = null) {
+  setStage(cwd, stage, changeName = null) {
     if (!VALID_STAGES.includes(stage)) {
       console.log(`❌ 未知阶段: ${stage}，可选: ${VALID_STAGES.join(', ')}`);
       return;
     }
 
-    const db = await this.pm._ensureDB(cwd);
+    const db = this.pm._ensureDB(cwd);
     const now = new Date().toISOString();
 
     // 获取变更名
     let cn = changeName;
     if (!cn) {
-      const changes = await this.pm.listChanges(cwd);
+      const changes = this.pm.listChanges(cwd);
       if (changes.length === 1) cn = changes[0];
       if (!cn) { console.log('❌ 无法确定当前变更，请指定 --change <name>'); return; }
     }
 
     let changeFound = false;
-    db.transaction((sqlDb) => {
+    db.transaction(() => {
+      const sqlDb = db.getDb();
       // 确保 change 存在
-      const changeRow = sqlDb.exec('SELECT id, current_stage FROM changes WHERE name = ?', [cn]);
-      if (!changeRow || changeRow.length === 0 || changeRow[0].values.length === 0) return;
+      const changeRow = sqlDb.prepare('SELECT id, current_stage FROM changes WHERE name = ?').get(cn);
+      if (changeRow === undefined) return;
 
       changeFound = true;
-      const changeId = changeRow[0].values[0][0];
+      const changeId = changeRow.id;
 
       // UPDATE changes.current_stage + last_active
-      sqlDb.run('UPDATE changes SET current_stage = ?, last_active = ? WHERE name = ?', [stage, now, cn]);
+      sqlDb.prepare('UPDATE changes SET current_stage = ?, last_active = ? WHERE name = ?').run(stage, now, cn);
 
       // 确保 stages 行存在（INSERT OR IGNORE）
-      sqlDb.run(
-        'INSERT OR IGNORE INTO stages (change_id, stage, status) VALUES (?, ?, "pending")',
-        [changeId, stage]
-      );
+      sqlDb.prepare(`INSERT OR IGNORE INTO stages (change_id, stage, status) VALUES (?, ?, 'pending')`).run(changeId, stage);
 
       // UPDATE stages.status 为 in-progress（仅当仍为 pending 时）
-      sqlDb.run(
-        "UPDATE stages SET status = 'in-progress', started_at = ? WHERE change_id = ? AND stage = ? AND status = 'pending'",
-        [now, changeId, stage]
-      );
+      sqlDb.prepare("UPDATE stages SET status = 'in-progress', started_at = ? WHERE change_id = ? AND stage = ? AND status = 'pending'").run(now, changeId, stage);
+
+      // 本地脏度（D-013 / task-04）：切换阶段是本地推进
+      this.pm._touchLocalModified(cwd, cn, now);
     });
 
     if (!changeFound) {
@@ -65,62 +63,63 @@ export class StepStore {
     console.log(`✅ 当前阶段已设为: ${STAGE_LABELS[stage] || stage}（变更 ${cn}）`);
   }
 
-  async addStep(cwd, stage, stepName, changeName = null) {
+  addStep(cwd, stage, stepName, changeName = null) {
     if (!stepName) { console.log('❌ 请指定步骤名称'); return; }
 
-    const db = await this.pm._ensureDB(cwd);
+    const db = this.pm._ensureDB(cwd);
 
     // 获取变更名
     let cn = changeName;
     if (!cn) {
-      const changes = await this.pm.listChanges(cwd);
+      const changes = this.pm.listChanges(cwd);
       if (changes.length === 1) cn = changes[0];
       if (!cn) { console.log('❌ 无法确定当前变更，请指定 --change <name>'); return; }
     }
 
     // 查找 stage_id
     const sqlDb = db.getDb();
-    const stageRow = sqlDb.exec(
-      'SELECT s.id FROM stages s JOIN changes c ON s.change_id = c.id WHERE c.name = ? AND s.stage = ?',
-      [cn, stage]
-    );
-    if (!stageRow || stageRow.length === 0 || stageRow[0].values.length === 0) {
+    const stageRow = sqlDb.prepare(
+      'SELECT s.id FROM stages s JOIN changes c ON s.change_id = c.id WHERE c.name = ? AND s.stage = ?'
+    ).get(cn, stage);
+    if (stageRow === undefined) {
       // stages 行不存在，静默跳过
       console.log(`ℹ️  阶段 ${stage} 不存在`);
       return;
     }
-    const stageId = stageRow[0].values[0][0];
+    const stageId = stageRow.id;
 
     // 重复步骤名检查
-    const dupRow = sqlDb.exec('SELECT id FROM steps WHERE stage_id = ? AND name = ?', [stageId, stepName]);
-    if (dupRow && dupRow.length > 0 && dupRow[0].values.length > 0) {
+    const dupRow = sqlDb.prepare('SELECT id FROM steps WHERE stage_id = ? AND name = ?').get(stageId, stepName);
+    if (dupRow !== undefined) {
       console.log(`ℹ️  步骤 "${stepName}" 已存在于 ${stage}`);
       return;
     }
 
     // INSERT INTO steps（ordering 递增）
-    db.transaction((tDb) => {
-      tDb.run(
+    db.transaction(() => {
+      const tDb = db.getDb();
+      tDb.prepare(
         `INSERT INTO steps (stage_id, name, ordering, status)
-         VALUES (?, ?, (SELECT COALESCE(MAX(ordering), 0) + 1 FROM steps WHERE stage_id = ?), 'pending')`,
-        [stageId, stepName, stageId]
-      );
-      tDb.run('UPDATE changes SET last_active = ? WHERE name = ?', [new Date().toISOString(), cn]);
+         VALUES (?, ?, (SELECT COALESCE(MAX(ordering), 0) + 1 FROM steps WHERE stage_id = ?), 'pending')`
+      ).run(stageId, stepName, stageId);
+      tDb.prepare('UPDATE changes SET last_active = ? WHERE name = ?').run(new Date().toISOString(), cn);
+      // 本地脏度（D-013 / task-04）：添加步骤是本地推进
+      this.pm._touchLocalModified(cwd, cn);
     });
 
     console.log(`✅ 已添加步骤: ${stage}/${stepName}`);
   }
 
-  async updateStep(cwd, stage, stepName, options = {}, changeName = null) {
+  updateStep(cwd, stage, stepName, options = {}, changeName = null) {
     const { status, output } = options;
     if (!stepName) { console.log('❌ 请指定步骤名称'); return; }
 
-    const db = await this.pm._ensureDB(cwd);
+    const db = this.pm._ensureDB(cwd);
 
     // 获取变更名
     let cn = changeName;
     if (!cn) {
-      const changes = await this.pm.listChanges(cwd);
+      const changes = this.pm.listChanges(cwd);
       if (changes.length === 1) cn = changes[0];
       if (!cn) { console.log('❌ 无法确定当前变更，请指定 --change <name>'); return; }
     }
@@ -133,50 +132,52 @@ export class StepStore {
 
     // 查找 step_id：通过 changes → stages → steps JOIN 查询
     const sqlDb = db.getDb();
-    const stepRow = sqlDb.exec(
+    const stepRow = sqlDb.prepare(
       `SELECT st.id, st.status FROM steps st
        JOIN stages sg ON st.stage_id = sg.id
        JOIN changes c ON sg.change_id = c.id
-       WHERE c.name = ? AND sg.stage = ? AND st.name = ?`,
-      [cn, stage, stepName]
-    );
-    if (!stepRow || stepRow.length === 0 || stepRow[0].values.length === 0) {
+       WHERE c.name = ? AND sg.stage = ? AND st.name = ?`
+    ).get(cn, stage, stepName);
+    if (stepRow === undefined) {
       console.log(`❌ 步骤不存在: ${stage}/${stepName}`);
       return;
     }
-    const stepId = stepRow[0].values[0][0];
+    const stepId = stepRow.id;
 
     // UPDATE steps
     let stageCompletionCandidateId = null;
-    db.transaction((tDb) => {
+    db.transaction(() => {
+      const tDb = db.getDb();
       const now = new Date().toISOString();
       if (status) {
-        tDb.run('UPDATE steps SET status = ?, completed_at = ? WHERE id = ? AND name = ?', [status, now, stepId, stepName]);
+        tDb.prepare('UPDATE steps SET status = ?, completed_at = ? WHERE id = ? AND name = ?').run(status, now, stepId, stepName);
       }
       if (output !== undefined) {
-        tDb.run('UPDATE steps SET output = ? WHERE id = ? AND name = ?', [output, stepId, stepName]);
+        tDb.prepare('UPDATE steps SET output = ? WHERE id = ? AND name = ?').run(output, stepId, stepName);
       }
 
       // 自动完成检测：同 stage_id 下所有 steps 都 completed 时，候选标记 stage completed
       // （实际标记延后到事务外，先过产物校验门，防止 update-step 成为绕过 validator 的后门）
       if (status === 'completed') {
         // 获取 stage_id
-        const stRow = tDb.exec('SELECT stage_id FROM steps WHERE id = ?', [stepId]);
-        if (stRow && stRow.length > 0 && stRow[0].values.length > 0) {
-          const stId = stRow[0].values[0][0];
-          const pendingRows = tDb.exec('SELECT COUNT(*) FROM steps WHERE stage_id = ? AND status != "completed"', [stId]);
-          if (pendingRows && pendingRows.length > 0 && pendingRows[0].values[0][0] === 0) {
+        const stRow = tDb.prepare('SELECT stage_id FROM steps WHERE id = ?').get(stepId);
+        if (stRow !== undefined) {
+          const stId = stRow.stage_id;
+          const pendingRow = tDb.prepare("SELECT COUNT(*) AS cnt FROM steps WHERE stage_id = ? AND status NOT IN ('completed','skipped')").get(stId);
+          if (pendingRow.cnt === 0) {
             stageCompletionCandidateId = stId;
           }
         }
       }
 
-      tDb.run('UPDATE changes SET last_active = ? WHERE name = ?', [now, cn]);
+      tDb.prepare('UPDATE changes SET last_active = ? WHERE name = ?').run(now, cn);
+      // 本地脏度（D-013 / task-04）：更新步骤是本地推进
+      this.pm._touchLocalModified(cwd, cn, now);
     });
 
     if (stageCompletionCandidateId !== null) {
       const { force = false } = options;
-      const validation = await this.pm._validateStageArtifacts(cwd, stage, cn);
+      const validation = this.pm._validateStageArtifacts(cwd, stage, cn);
       if (!validation.ok && !force) {
         console.error(`⚠️  阶段 ${stage} 所有步骤已完成，但产物校验未通过，阶段不标记为 completed：`);
         for (const err of validation.errors) console.error(`   - ${err}`);
@@ -194,8 +195,9 @@ export class StepStore {
             validationErrors: validation.errors,
           });
         }
-        db.transaction((tDb) => {
-          tDb.run('UPDATE stages SET status = "completed", completed_at = ? WHERE id = ?', [new Date().toISOString(), stageCompletionCandidateId]);
+        db.transaction(() => {
+          const tDb = db.getDb();
+          tDb.prepare(`UPDATE stages SET status = 'completed', completed_at = ? WHERE id = ?`).run(new Date().toISOString(), stageCompletionCandidateId);
         });
         console.log(`✅ 阶段 ${stage} 所有步骤已完成，阶段已标记为 completed`);
       }
@@ -204,39 +206,42 @@ export class StepStore {
     console.log(`✅ 步骤已更新: ${stage}/${stepName} → ${status || '（仅更新 output）'}`);
   }
 
-  async updateBatchProgress(cwd, batchData, changeName = null) {
+  updateBatchProgress(cwd, batchData, changeName = null) {
     const cn = changeName || null;
 
-    const db = await this.pm._ensureDB(cwd);
-    db.transaction((sqlDb) => {
+    const db = this.pm._ensureDB(cwd);
+    db.transaction(() => {
+      const sqlDb = db.getDb();
       // 获取 change_id
       let changeId = null;
       if (cn) {
-        const row = sqlDb.exec('SELECT id FROM changes WHERE name = ?', [cn]);
-        if (row && row.length > 0 && row[0].values.length > 0) changeId = row[0].values[0][0];
+        const row = sqlDb.prepare('SELECT id FROM changes WHERE name = ?').get(cn);
+        if (row !== undefined) changeId = row.id;
       }
       if (!changeId) {
         // 尝试从唯一活跃变更获取
-        const rows = sqlDb.exec("SELECT id FROM changes WHERE status = 'active'");
-        if (rows && rows.length > 0 && rows[0].values.length === 1) changeId = rows[0].values[0][0];
+        const rows = sqlDb.prepare("SELECT id FROM changes WHERE status = 'active'").all();
+        if (rows.length === 1) changeId = rows[0].id;
       }
       if (!changeId) return;
 
-      sqlDb.run(
+      sqlDb.prepare(
         `INSERT INTO batch_progress (change_id, total, completed, failed, skipped)
          VALUES (?, ?, ?, ?, ?)
          ON CONFLICT(change_id) DO UPDATE SET
            total = excluded.total,
            completed = excluded.completed,
            failed = excluded.failed,
-           skipped = excluded.skipped`,
-        [changeId, batchData.total || 0, batchData.completed || 0, batchData.failed || 0, batchData.skipped || 0]
-      );
+           skipped = excluded.skipped`
+      ).run(changeId, batchData.total || 0, batchData.completed || 0, batchData.failed || 0, batchData.skipped || 0);
+      // 本地脏度（D-013 / task-04）：批量进度更新是本地推进
+      const nameRow = sqlDb.prepare('SELECT name FROM changes WHERE id = ?').get(changeId);
+      if (nameRow) this.pm._touchLocalModified(cwd, nameRow.name);
     });
   }
 
-  async readBatchProgress(cwd, changeName = null) {
-    const data = await this.pm.read(cwd, changeName);
+  readBatchProgress(cwd, changeName = null) {
+    const data = this.pm.read(cwd, changeName);
     return data?.batchProgress || null;
   }