sillyspec 3.27.5 → 3.27.6

package/.worktrees/8d2d0392/src/progress/consistency-doctor.js

@@ -0,0 +1,355 @@
+// W6 Step9a: Revision v1 状态一致性检查 + 修复 + --force 审计日志。
+// 从 src/progress.js 单体 ProgressManager 抽出。持有 pm 引用（构造注入），调 pm.read / pm._write /
+// pm._ensureRuntimeDir / pm._runtimePath（persistence-core 留 facade 本体）。
+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) {
+    this.pm = pm;
+  }
+
+  /**
+   * 强制状态变更的审计记录（--force 逃生口专用）。
+   * 追加到 .runtime/audit.log，供人工/doctor 追溯"谁在什么时候绕过了校验"。
+   */
+  _appendAuditLog(cwd, entry) {
+    try {
+      this.pm._ensureRuntimeDir(cwd);
+      const auditPath = this.pm._runtimePath(cwd, 'audit.log');
+      const line = JSON.stringify({ at: new Date().toISOString(), ...entry });
+      appendFileSync(auditPath, line + '\n');
+    } catch (e) {
+      console.warn(`⚠️  审计日志写入失败: ${e.message}`);
+    }
+  }
+
+  /**
+   * Revision v1 状态一致性检查
+   * 只报告，不自动修复。
+   * @param {string} cwd
+   * @param {string|null} changeName
+   * @returns {{ ok: boolean, issues: string[], warnings: string[] }}
+   */
+  checkConsistency(cwd, changeName = null) {
+    const data = this.pm.read(cwd, changeName);
+    if (!data) {
+      return { ok: false, issues: ['无法读取进度数据'], warnings: [] };
+    }
+
+    const issues = [];
+    const warnings = [];
+
+    for (const stageName of STAGE_ORDER) {
+      const sd = data.stages[stageName];
+      if (!sd) continue;
+
+      // a. completed stage 不能有 pending/stale steps
+      if (sd.status === 'completed' && sd.steps) {
+        const badSteps = sd.steps.filter(s => ['pending', 'stale', 'in-progress'].includes(s.status));
+        for (const step of badSteps) {
+          issues.push(`${stageName}/${step.name}: step 状态为 ${step.status}，但 stage 状态为 completed`);
+        }
+      }
+
+      // b. revising stage 应有 revision > 0 或 reopenedFromStep
+      if (sd.status === 'revising') {
+        if (!sd.revision || sd.revision < 1) {
+          issues.push(`${stageName}: 状态为 revising 但 revision 缺失或为 0`);
+        }
+        if (!sd.reopenedFromStep) {
+          warnings.push(`${stageName}: 状态为 revising 但未记录 reopenedFromStep`);
+        }
+      }
+
+      // c. stale stage 应有 staleReason
+      if (sd.status === 'stale') {
+        if (!sd.staleReason) {
+          warnings.push(`${stageName}: 状态为 stale 但缺少 staleReason`);
+        }
+      }
+
+      // d. 下游 completed 不能出现在上游 stale/revising 之后
+      // 用 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 = MAIN_FLOW_ORDER[i];
+        const upData = data.stages[upstream];
+        if (upData && (upData.status === 'stale' || upData.status === 'revising')) {
+          if (sd.status === 'completed') {
+            issues.push(`${stageName}: 状态为 completed，但上游 ${upstream} 状态为 ${upData.status}（下游不应在上游修订/失效时保持 completed）`);
+          }
+        }
+      }
+
+      // e. step stale 时 stage 不应是 completed
+      if (sd.status === 'completed' && sd.steps) {
+        const staleSteps = sd.steps.filter(s => s.status === 'stale');
+        for (const step of staleSteps) {
+          issues.push(`${stageName}/${step.name}: step 状态为 stale，但 stage 状态为 completed`);
+        }
+      }
+    }
+
+    // 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('  ═══════════════════════════════════════');
+    console.log('  状态一致性检查');
+    console.log('  ═══════════════════════════════════════');
+
+    if (issues.length === 0 && warnings.length === 0) {
+      console.log('  ✅ 未发现一致性问题');
+    } else {
+      if (issues.length > 0) {
+        console.log(`\n  ❌ 问题 (${issues.length}):`);
+        for (const issue of issues) console.log(`     - ${issue}`);
+      }
+      if (warnings.length > 0) {
+        console.log(`\n  ⚠️ 警告 (${warnings.length}):`);
+        for (const w of warnings) console.log(`     - ${w}`);
+      }
+    }
+    console.log('');
+
+    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。
+   * 只修安全项，不碰产物文件、不 reset/reopen stage。
+   *
+   * @param {string} cwd
+   * @param {object} opts
+   * @param {boolean} [opts.apply=false]
+   * @param {string|null} [opts.changeName]
+   * @returns {{ fixable: object[], manual: string[], applied: object[] }}
+   */
+  repairConsistency(cwd, opts = {}) {
+    const { apply = false, changeName = null } = opts;
+
+    const data = this.pm.read(cwd, changeName);
+    if (!data) {
+      console.log('❌ 无法读取进度数据');
+      return { fixable: [], manual: ['无法读取进度数据'], applied: [] };
+    }
+
+    const fixable = []; // { stage, action, description, apply: (data) => void }
+    const manual = [];  // string
+
+    const now = new Date().toLocaleString('zh-CN', { hour12: false });
+
+    for (const stageName of STAGE_ORDER) {
+      const sd = data.stages[stageName];
+      if (!sd) continue;
+
+      // Fix a: stale stage 缺 staleReason → 补默认原因
+      if (sd.status === 'stale' && !sd.staleReason) {
+        const reason = stageName === 'archive'
+          ? 'upstream stage revised; existing archive artifacts are preserved but no longer trusted'
+          : 'unknown upstream revision';
+        fixable.push({
+          stage: stageName,
+          action: 'set_stale_reason',
+          description: `${stageName}: stale 缺 staleReason → 补 "${reason}"`,
+          apply: (d) => { d.stages[stageName].staleReason = reason; },
+        });
+      }
+
+      // 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 = MAIN_FLOW_ORDER[i];
+        const upData = data.stages[upstream];
+        if (upData && (upData.status === 'stale' || upData.status === 'revising')) {
+          if (sd.status === 'completed') {
+            const upStatus = upData.status;
+            const reason = `upstream ${upstream} is ${upStatus}`;
+            fixable.push({
+              stage: stageName,
+              action: 'cascade_stale',
+              description: `${stageName}: completed → stale（上游 ${upstream} 为 ${upStatus}）`,
+              apply: (d) => {
+                d.stages[stageName].status = 'stale';
+                d.stages[stageName].staleReason = reason;
+                d.stages[stageName].completedAt = null;
+              },
+            });
+          }
+        }
+      }
+
+      // Fix c: archive stale 缺 staleReason（专用文案）
+      if (stageName === 'archive' && sd.status === 'stale' && !sd.staleReason) {
+        // 已在 Fix a 中处理，这里不重复
+      }
+
+      // Fix d: revising stage 缺 reopenedAt → 补当前时间
+      if (sd.status === 'revising' && !sd.reopenedAt) {
+        fixable.push({
+          stage: stageName,
+          action: 'set_reopened_at',
+          description: `${stageName}: revising 缺 reopenedAt → 补当前时间`,
+          apply: (d) => { d.stages[stageName].reopenedAt = now; },
+        });
+      }
+
+      // Fix e: execute 阶段 completed stage 有 pending/stale/in-progress step，但 review.json 客观产出已全通过 → 状态脱钩自动修
+      // （坑 verify-archive-flow-pitfalls 坑1+坑5：plan 加 Wave / execute Wave step 未走 --done，但 task 实际有 review.json verdict 且非 fail）
+      // 安全边界：仅当 changeName 有效、source=review.json（客观源可用）且 pending=0（所有 task verdict 通过）才自动修，
+      // 否则回落到 Manual a（保守不动）。不碰非 execute 阶段。
+      let executeAutoFixed = false;
+      if (stageName === 'execute' && changeName && sd.status === 'completed' && sd.steps) {
+        const badSteps = sd.steps.filter(st => ['pending', 'stale', 'in-progress'].includes(st.status));
+        if (badSteps.length > 0) {
+          try {
+            const changeDir = this.pm._changePath(cwd, changeName);
+            if (changeDir && existsSync(changeDir)) {
+              const runtimeRoot = this.pm._runtimePath(cwd);
+              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`;
+                fixable.push({
+                  stage: stageName,
+                  action: 'align_execute_steps_to_reviews',
+                  description: desc,
+                  apply: (d) => {
+                    for (const st of d.stages[stageName].steps) {
+                      if (['pending', 'stale', 'in-progress'].includes(st.status)) {
+                        st.status = 'completed';
+                        st.completedAt = st.completedAt || now;
+                      }
+                    }
+                  },
+                });
+                executeAutoFixed = true;
+              }
+            }
+          } catch (e) {
+            console.warn(`⚠️  execute 产出核验异常（回落 manual）: ${e.message}`);
+          }
+        }
+      }
+
+      // Manual a: completed stage 里有 pending/stale/in-progress steps（execute 已由 Fix e 自动修则跳过）
+      if (!executeAutoFixed && sd.status === 'completed' && sd.steps) {
+        const badSteps = sd.steps.filter(s => ['pending', 'stale', 'in-progress'].includes(s.status));
+        for (const step of badSteps) {
+          manual.push(`${stageName}/${step.name}: step 状态为 ${step.status}，但 stage 状态为 completed（需手动确认）`);
+        }
+      }
+
+      // Manual b: revising stage 缺 reopenedFromStep
+      if (sd.status === 'revising' && !sd.reopenedFromStep) {
+        manual.push(`${stageName}: revising 缺 reopenedFromStep（需手动确认修订起始步骤）`);
+      }
+
+      // Manual c: steps 为空但 stage completed
+      if (sd.status === 'completed' && (!sd.steps || sd.steps.length === 0)) {
+        manual.push(`${stageName}: completed 但 steps 为空（需手动确认）`);
+      }
+    }
+
+    // 输出报告
+    console.log('');
+    console.log('  ═══════════════════════════════════════');
+    console.log(`  状态修复 ${apply ? '（--apply 模式）' : '（dry-run 模式）'}`);
+    console.log('  ═══════════════════════════════════════');
+
+    if (fixable.length === 0 && manual.length === 0) {
+      console.log('  ✅ 未发现问题，无需修复');
+      console.log('');
+      return { fixable: [], manual: [], applied: [] };
+    }
+
+    const applied = [];
+
+    if (fixable.length > 0) {
+      console.log(`\n  🔧 可自动修复 (${fixable.length}):`);
+      for (const item of fixable) {
+        console.log(`     - ${item.description}`);
+        if (apply) {
+          item.apply(data);
+          applied.push({ stage: item.stage, action: item.action });
+        }
+      }
+      if (!apply) {
+        console.log('\n  💡 使用 --apply 执行修复');
+      }
+    }
+
+    if (manual.length > 0) {
+      console.log(`\n  👆 需手动处理 (${manual.length}):`);
+      for (const m of manual) console.log(`     - ${m}`);
+    }
+
+    if (apply && applied.length > 0) {
+      data.lastActive = now;
+      this.pm._write(cwd, data, changeName);
+      console.log(`\n  ✅ 已修复 ${applied.length} 项`);
+    }
+
+    console.log('');
+
+    return { fixable, manual, applied };
+  }
+}
+

package/.worktrees/8d2d0392/src/progress/shared.js

@@ -0,0 +1,36 @@
+// W6 Step9 共享常量：progress.js facade 与 src/progress/* 子模块共用，避免 facade↔子模块循环引用。
+// 9a: STAGE_ORDER/MAIN_FLOW_ORDER；9c: VALID_STAGES/STAGE_LABELS；9d: SPEC_DIR_NAME/CURRENT_VERSION/emptyStage。
+
+export const SPEC_DIR_NAME = '.sillyspec';
+
+// 合法阶段名（含辅助阶段 scan/quick/explore）
+export const VALID_STAGES = ['scan', 'brainstorm', 'plan', 'execute', 'verify', 'archive', 'quick', 'explore'];
+
+// 阶段展示文案
+export const STAGE_LABELS = {
+  brainstorm: '🧠 需求探索',
+  plan: '📐 实现计划',
+  execute: '⚡ 波次执行',
+  verify: '🔍 验证确认',
+  scan: '🔍 代码扫描',
+  quick: '⚡ 快速任务',
+  explore: '🧭 自由探索',
+  archive: '📦 归档变更',
+};
+
+// 完整阶段顺序（含 scan），仅用于展示/迭代顺序
+export const STAGE_ORDER = ['scan', 'brainstorm', 'plan', 'execute', 'verify', 'archive'];
+// 主流程阶段（不含 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；v4 = changes 加 base_ts / 本地脏度两列，platform-sync §8）
+export const CURRENT_VERSION = 5;
+
+// 空阶段骨架
+export function emptyStage() {
+  return { status: 'pending', steps: [], startedAt: null, completedAt: null };
+}
+