@haaaiawd/loom 0.7.0 → 0.8.0

package/cli/src/diagnostics.js

@@ -2,11 +2,102 @@
 // 提供 doctor / context / trace / reverse-dep / reverse-ref 五个聚合命令。
 // 全部是只读的数据聚合，不做决策、不修改文件。
 
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { loadIntentMap, getStatus, getNextIntent, getNarrative, getIntent } from './intent-map.js';
-import { getPhilosophy } from './philosophy.js';
-import { getVerificationHistory, getPendingVerifications, getVerificationContract } from './verify.js';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadIntentMap, getStatus, getNextIntent, getNarrative, getIntent } from './intent-map.js';
+import { getPhilosophy, validateInspirationSources, validatePartDecomposition } from './philosophy.js';
+import { getVerificationHistory, getPendingVerifications, getVerificationContract } from './verify.js';
+
+function readIntentMapRaw(versionDir) {
+  const filePath = join(versionDir, '04_INTENT_MAP.json');
+  if (!existsSync(filePath)) return null;
+  return JSON.parse(readFileSync(filePath, 'utf-8'));
+}
+
+function summarizeRawIntentMap(data) {
+  const intents = data?.intents && typeof data.intents === 'object' ? data.intents : {};
+  const ids = { pending: [], in_progress: [], completed: [], blocked: [], needs_review: [] };
+  const titles = {};
+
+  for (const [id, intent] of Object.entries(intents)) {
+    const status = intent?.status;
+    if (ids[status]) ids[status].push(id);
+    titles[id] = intent?.title || '';
+  }
+
+  return {
+    counts: {
+      pending: ids.pending.length,
+      in_progress: ids.in_progress.length,
+      completed: ids.completed.length,
+      blocked: ids.blocked.length,
+      needs_review: ids.needs_review.length,
+      total: Object.keys(intents).length,
+    },
+    ids,
+    titles,
+  };
+}
+
+function intentMapDiagnostics(versionDir) {
+  const issues = [];
+  let raw = null;
+  let valid = null;
+  let validMap = null;
+
+  try {
+    raw = readIntentMapRaw(versionDir);
+  } catch (e) {
+    issues.push({ id: 'intent_map', type: 'intent_map_unreadable', severity: 'fatal', msg: `Intent Map 无法读取或 JSON 损坏: ${e.message}` });
+    return { raw, valid, issues, validMap: null };
+  }
+
+  if (!raw) {
+    issues.push({ id: 'intent_map', type: 'intent_map_missing', severity: 'fatal', msg: '缺少 04_INTENT_MAP.json' });
+    return { raw, valid, issues, validMap: null };
+  }
+
+  if (raw._meta?._template === true) {
+    issues.push({ id: 'intent_map', type: 'intent_map_template', severity: 'high', msg: 'Intent Map 仍是模板，尚未由 Architect 产出真实意图图' });
+  }
+
+  try {
+    validMap = loadIntentMap(versionDir);
+    valid = true;
+  } catch (e) {
+    valid = false;
+    issues.push({ id: 'intent_map', type: 'intent_map_invalid', severity: 'fatal', msg: e.message });
+  }
+
+  return { raw, valid, issues, validMap };
+}
+
+function getIntentVerificationMethod(intent) {
+  return intent.verification_method || intent._optional?.verification_method || null;
+}
+
+function normalizeVerificationCommand(command) {
+  return String(command || '')
+    .replace(/^\s*run\s+/i, '')
+    .replace(/^\s*exec\s+/i, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function commandCoversMethod(actualCommand, expectedMethod) {
+  const actual = normalizeVerificationCommand(actualCommand);
+  const expected = normalizeVerificationCommand(expectedMethod);
+  if (!actual || !expected) return false;
+
+  return expected.split('&&').every((part) => {
+    const expectedPart = normalizeVerificationCommand(part);
+    if (!expectedPart) return true;
+    if (actual.includes(expectedPart)) return true;
+    // npm test is an acceptable broader reproduction for node --test based methods.
+    if (expectedPart.startsWith('node --test') && actual.includes('npm test')) return true;
+    return false;
+  });
+}
 
 // ─── doctor ────────────────────────────────────────────
 // 全面健康检查：一致性 + 孤儿引用 + 循环依赖 + 僵尸 Intent
@@ -18,9 +109,16 @@ import { getVerificationHistory, getPendingVerifications, getVerificationContrac
  * @param {string} philosophyDir — 哲学目录
  * @returns {{ issues: object[], summary: object }}
  */
-export function doctor(versionDir, verificationsDir, philosophyDir) {
-  const { intents, topo_order } = loadIntentMap(versionDir);
-  const issues = [];
+export function doctor(versionDir, verificationsDir, philosophyDir) {
+  const mapState = intentMapDiagnostics(versionDir);
+  const issues = [...mapState.issues];
+
+  if (!mapState.validMap) {
+    appendPhilosophyDiagnostics(issues, philosophyDir);
+    return { issues, summary: summarizeIssues(issues) };
+  }
+
+  const { intents } = mapState.validMap;
 
   // 1. 状态一致性：in_progress/completed 但无验证记录
   for (const [id, intent] of Object.entries(intents)) {
@@ -90,13 +188,13 @@ export function doctor(versionDir, verificationsDir, philosophyDir) {
     }
   }
 
-  // 7. 验证脚本可执行性：检查 verification_method 引用的脚本/目录是否存在
-  const projectDir = join(versionDir, '..', '..');
-  for (const [id, intent] of Object.entries(intents)) {
-    if (!intent.verification_method) continue;
-    const vm = intent.verification_method;
-    // 检测 npm test 引用
-    if (vm.includes('npm test') || vm.includes('npm run test')) {
+  // 7. 验证脚本可执行性：检查 verification_method 引用的脚本/目录是否存在
+  const projectDir = join(versionDir, '..', '..');
+  for (const [id, intent] of Object.entries(intents)) {
+    const vm = getIntentVerificationMethod(intent);
+    if (!vm) continue;
+    // 检测 npm test 引用
+    if (vm.includes('npm test') || vm.includes('npm run test')) {
       const pkgPath = join(projectDir, 'package.json');
       if (!existsSync(pkgPath)) {
         issues.push({ id, type: 'test_script_missing', severity: 'medium', msg: `${id} verification_method 要求 npm test 但项目根没有 package.json` });
@@ -120,20 +218,61 @@ export function doctor(versionDir, verificationsDir, philosophyDir) {
         } catch {
           // package.json 解析失败，不报——不是 doctor 的职责
         }
-      }
-    }
-  }
-
-  const summary = {
-    total_issues: issues.length,
-    fatal: issues.filter((i) => i.severity === 'fatal').length,
-    high: issues.filter((i) => i.severity === 'high').length,
-    medium: issues.filter((i) => i.severity === 'medium').length,
-    healthy: issues.length === 0,
-  };
-
-  return { issues, summary };
-}
+      }
+    }
+  }
+
+  // 8. completed Intent 的 verification_method 必须被最新验证记录覆盖，防止契约命令漂移。
+  for (const [id, intent] of Object.entries(intents)) {
+    if (intent.status !== 'completed') continue;
+    const method = getIntentVerificationMethod(intent);
+    if (!method) continue;
+
+    const expected = normalizeVerificationCommand(method);
+    if (!expected || expected === 'human_review') continue;
+
+    const history = getVerificationHistory(verificationsDir, id);
+    const latest = history?.records?.[history.records.length - 1];
+    const actual = normalizeVerificationCommand(latest?.reproduction_command);
+
+    if (!latest) {
+      issues.push({ id, type: 'verification_method_unverified', severity: 'high', msg: `${id} 声明了 verification_method 但没有验证记录覆盖: ${method}` });
+    } else if (!actual) {
+      issues.push({ id, type: 'verification_method_unverified', severity: 'high', msg: `${id} 最新验证记录缺少 reproduction_command，无法复现 verification_method: ${method}` });
+    } else if (!commandCoversMethod(actual, expected)) {
+      issues.push({ id, type: 'verification_method_drift', severity: 'high', msg: `${id} verification_method 未被最新 reproduction_command 覆盖。method="${method}" reproduction_command="${latest.reproduction_command}"` });
+    }
+  }
+
+  appendPhilosophyDiagnostics(issues, philosophyDir);
+  return { issues, summary: summarizeIssues(issues) };
+}
+
+function appendPhilosophyDiagnostics(issues, philosophyDir) {
+  // 哲学灵感来源校验（防止 Weaver 从训练数据"背"几个名字就交差）
+  if (!existsSync(philosophyDir)) return;
+
+  const inspirationCheck = validateInspirationSources(philosophyDir);
+  for (const issue of inspirationCheck.issues) {
+    issues.push({ id: 'philosophy', type: 'inspiration_source', severity: issue.severity, msg: issue.msg });
+  }
+
+  // 实现部分拆解校验（防止 Weaver 跳过拆解步骤）
+  const decompositionCheck = validatePartDecomposition(philosophyDir);
+  for (const issue of decompositionCheck.issues) {
+    issues.push({ id: 'philosophy', type: 'part_decomposition', severity: issue.severity, msg: issue.msg });
+  }
+}
+
+function summarizeIssues(issues) {
+  return {
+    total_issues: issues.length,
+    fatal: issues.filter((i) => i.severity === 'fatal').length,
+    high: issues.filter((i) => i.severity === 'high').length,
+    medium: issues.filter((i) => i.severity === 'medium').length,
+    healthy: issues.length === 0,
+  };
+}
 
 /**
  * DFS 检测循环依赖。
@@ -182,24 +321,26 @@ function detectCycles(intents) {
  * @param {string} philosophyDir
  * @returns {object}
  */
-export function contextSummary(versionDir, verificationsDir, philosophyDir) {
-  const status = getStatus(versionDir);
-  const next = getNextIntent(versionDir);
-  const pending = getPendingVerifications(versionDir, verificationsDir);
-  const { issues } = doctor(versionDir, verificationsDir, philosophyDir);
+export function contextSummary(versionDir, verificationsDir, philosophyDir) {
+  const mapState = intentMapDiagnostics(versionDir);
+  const status = mapState.valid ? getStatus(versionDir) : summarizeRawIntentMap(mapState.raw);
+  const next = mapState.valid ? getNextIntent(versionDir) : null;
+  const pending = mapState.valid ? getPendingVerifications(versionDir, verificationsDir) : [];
+  const { issues } = doctor(versionDir, verificationsDir, philosophyDir);
 
   const risks = [];
   const fatalCount = issues.filter((i) => i.severity === 'fatal').length;
   const highCount = issues.filter((i) => i.severity === 'high').length;
-  if (fatalCount > 0) risks.push(`${fatalCount} 个致命问题（循环依赖）`);
-  if (highCount > 0) risks.push(`${highCount} 个高严重度问题（状态不一致/孤儿引用）`);
-  if (status.counts.blocked > 0) risks.push(`${status.counts.blocked} 个阻塞 Intent`);
-
-  return {
-    progress: {
-      completed: status.counts.completed,
-      total: status.counts.total,
-      rate: `${status.counts.completed}/${status.counts.total}`,
+  if (fatalCount > 0) risks.push(`${fatalCount} 个致命问题（Intent Map 损坏/循环依赖）`);
+  if (highCount > 0) risks.push(`${highCount} 个高严重度问题（状态不一致/孤儿引用）`);
+  if (status.counts.blocked > 0) risks.push(`${status.counts.blocked} 个阻塞 Intent`);
+
+  return {
+    intent_map_valid: mapState.valid === true,
+    progress: {
+      completed: status.counts.completed,
+      total: status.counts.total,
+      rate: `${status.counts.completed}/${status.counts.total}`,
     },
     next_intent: next ? next.id : null,
     pending_verifications: pending,

package/cli/src/guide.js

@@ -36,17 +36,17 @@ function isTemplate(filePath) {
 /**
  * 诊断项目当前阶段。
  * @param {string} projectDir — 项目根目录
- * @returns {{ stage: string, stage_num: number, details: object, auto: boolean, next_action: string, next_command: string, message: string, needs_human_review: boolean }}
- */
-export function guideProject(projectDir) {
-  const cwd = projectDir || process.cwd();
-  const loomRoot = join(cwd, '.loom');
-  const auto = isAutoOn(loomRoot);
-  const result = diagnoseStage(cwd, loomRoot, auto);
-  // 统一后处理：写心跳 + 加 AUTO 提示词 + 判断是否需要人类 review
-  if (existsSync(loomRoot)) {
-    try {
-      writeHeartbeat(loomRoot, {
+ * @returns {{ stage: string, stage_num: number, details: object, auto: boolean, next_action: string, next_command: string, message: string, needs_human_review: boolean }}
+ */
+export function guideProject(projectDir, options = {}) {
+  const cwd = projectDir || process.cwd();
+  const loomRoot = join(cwd, '.loom');
+  const auto = isAutoOn(loomRoot);
+  const result = diagnoseStage(cwd, loomRoot, auto);
+  // 统一后处理：写心跳 + 加 AUTO 提示词 + 判断是否需要人类 review
+  if (existsSync(loomRoot) && !options.dryRun) {
+    try {
+      writeHeartbeat(loomRoot, {
         stage: result.stage,
         stage_num: result.stage_num,
         next_command: result.next_command,
@@ -145,9 +145,11 @@ function diagnoseStage(cwd, loomRoot, auto) {
   }
 
   // 状态 4-7: Intent Map 已设计，根据 Intent 状态判断
-  let intents;
-  try {
-    intents = loadIntentMap(versionDir).intents;
+  let intentMap;
+  let intents;
+  try {
+    intentMap = loadIntentMap(versionDir);
+    intents = intentMap.intents;
   } catch (e) {
     return {
       stage: 'intent_map_broken',
@@ -218,7 +220,7 @@ function diagnoseStage(cwd, loomRoot, auto) {
   if (counts.needs_review > 0) {
     const reviewIds = allIntents.filter((i) => i.status === 'needs_review').map((i) => i.id);
     // 读 _meta.pass_count 收敛趟计数（最大 3 趟）
-    const passCount = intents._meta?.pass_count || 1;
+    const passCount = intentMap._meta?.pass_count || 1;
     const MAX_PASSES = 3;
     const isOverLimit = passCount > MAX_PASSES;
     const passMsg = ` [Pass ${passCount}/${MAX_PASSES}]`;

package/cli/src/philosophy.js

@@ -1,6 +1,7 @@
 // philosophy.js — 按锚点加载哲学文档的特定章节
 // 哲学文档是 MD，锚点格式: "PRODUCT_PHILOSOPHY.md#core-belief"
 // 这个库按锚点提取对应章节，不返回整个文件。
+// 另含灵感来源校验——防止 Weaver 从训练数据"背"几个名字就交差。
 
 import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
@@ -44,3 +45,230 @@ export function listPhilosophyFiles(philosophyDir) {
   const dir = readdirSync(philosophyDir);
   return dir.filter((f) => f.endsWith('.md'));
 }
+
+// ─── 灵感来源校验 ───────────────────────────────────────
+// 防止 Weaver 从训练数据"背"几个名字就交差。
+// 校验规则：
+//   1. 至少 3 个独立源
+//   2. 至少 2 个非 Wikipedia 链接（Wikipedia 是常识入口，不是深度源）
+//   3. 每个源必须有"为什么选它"的理由（萃取/理由/为什么 等关键词）
+//   4. 源不能全是同一类型（如全是 Wikipedia、全是博客）
+
+const MIN_SOURCES = 3;
+const MIN_NON_WIKI = 2;
+const REASON_KEYWORDS = ['萃取', '理由', '为什么', '因为', '启发', '借鉴', '参考理由', '选取理由', '转译'];
+
+/**
+ * 从哲学文档内容中提取"灵感来源"章节的条目。
+ * @param {string} content — MD 全文
+ * @returns {Array<{ raw: string, name: string, urls: string[], hasReason: boolean }>}
+ */
+function parseInspirationSources(content) {
+  // 匹配 "## 灵感来源" 或 "## Inspiration" 章节
+  const sectionMatch = content.match(/^##\s+(?:灵感来源|Inspiration|参考来源|References)/m);
+  if (!sectionMatch) return [];
+
+  const startIdx = sectionMatch.index + sectionMatch[0].length;
+  // 找到下一个 ## 或文件末尾
+  const nextSection = content.slice(startIdx).match(/\n##\s/m);
+  const sectionText = nextSection
+    ? content.slice(startIdx, startIdx + nextSection.index)
+    : content.slice(startIdx);
+
+  // 解析每个 list item（- 或 * 开头）
+  const items = [];
+  const lines = sectionText.split('\n');
+  let currentItem = null;
+
+  for (const line of lines) {
+    if (/^\s*[-*]\s/.test(line)) {
+      // 新条目
+      if (currentItem) items.push(currentItem);
+      const raw = line.replace(/^\s*[-*]\s/, '').trim();
+      const urls = [...raw.matchAll(/https?:\/\/[^\s）)]+/g)].map((m) => m[0]);
+      const name = raw.replace(/\*\*/g, '').split(/[（(——]/)[0].trim();
+      const hasReason = REASON_KEYWORDS.some((kw) => raw.includes(kw));
+      currentItem = { raw, name, urls, hasReason };
+    } else if (currentItem && line.trim()) {
+      // 多行条目的续行
+      currentItem.raw += ' ' + line.trim();
+      const newUrls = [...line.matchAll(/https?:\/\/[^\s）)]+/g)].map((m) => m[0]);
+      currentItem.urls.push(...newUrls);
+      if (REASON_KEYWORDS.some((kw) => line.includes(kw))) {
+        currentItem.hasReason = true;
+      }
+    }
+  }
+  if (currentItem) items.push(currentItem);
+  return items;
+}
+
+/**
+ * 判断 URL 是否为 Wikipedia 链接。
+ */
+function isWikipediaUrl(url) {
+  return /wikipedia\.org/i.test(url);
+}
+
+/**
+ * 校验哲学文档的灵感来源质量。
+ * @param {string} philosophyDir — 00_PHILOSOPHY/ 目录路径
+ * @returns {{ passed: boolean, issues: Array<{severity: string, msg: string}>, sources: Array }}
+ */
+export function validateInspirationSources(philosophyDir) {
+  const issues = [];
+  const allSources = [];
+
+  // 扫描目录下所有 .md 文件，找"灵感来源"章节
+  const files = listPhilosophyFiles(philosophyDir);
+
+  for (const file of files) {
+    const content = readFileSync(join(philosophyDir, file), 'utf-8');
+    const sources = parseInspirationSources(content);
+    if (sources.length === 0) continue;
+
+    allSources.push({ file, sources });
+
+    // 校验每个文件的灵感来源
+    if (sources.length < MIN_SOURCES) {
+      issues.push({
+        severity: 'high',
+        msg: `${file}: 灵感来源仅 ${sources.length} 条，要求至少 ${MIN_SOURCES} 条。可能从训练数据"背"了几个名字就交差。`,
+      });
+    }
+
+    const nonWikiUrls = sources.filter((s) => s.urls.length > 0 && !s.urls.every(isWikipediaUrl));
+    if (nonWikiUrls.length < MIN_NON_WIKI) {
+      issues.push({
+        severity: 'high',
+        msg: `${file}: 非 Wikipedia 链接仅 ${nonWikiUrls.length} 个，要求至少 ${MIN_NON_WIKI} 个。Wikipedia 是常识入口，不是深度源——需要原著、论文、工程博客、标准文档等。`,
+      });
+    }
+
+    for (const src of sources) {
+      if (!src.hasReason) {
+        issues.push({
+          severity: 'medium',
+          msg: `${file}: 灵感来源 "${src.name}" 缺乏选取理由。必须说明"为什么选这个源"——萃取/转译/启发关系。`,
+        });
+      }
+      if (src.urls.length === 0) {
+        issues.push({
+          severity: 'medium',
+          msg: `${file}: 灵感来源 "${src.name}" 没有 URL。必须附可验证的来源链接。`,
+        });
+      }
+    }
+  }
+
+  // 全局校验：所有文件的灵感来源加起来，源类型不能单一
+  const totalUrls = allSources.flatMap((s) => s.sources).flatMap((s) => s.urls);
+  if (totalUrls.length > 0) {
+    const wikiCount = totalUrls.filter(isWikipediaUrl).length;
+    if (wikiCount / totalUrls.length > 0.7) {
+      issues.push({
+        severity: 'medium',
+        msg: `全部灵感来源中 Wikipedia 占比 ${Math.round((wikiCount / totalUrls.length) * 100)}%——源类型过于单一。需要原著、论文、标准文档、工程博客等多元源。`,
+      });
+    }
+  }
+
+  // 如果没有任何文件包含灵感来源章节
+  if (allSources.length === 0) {
+    issues.push({
+      severity: 'high',
+      msg: '所有哲学文档都没有"灵感来源"章节。PHILOSOPHY_WEAVER.md 要求哲学文档必须包含灵感来源（参考了哪些机构、人物、流派——附 URL 和理由）。',
+    });
+  }
+
+  return {
+    passed: issues.length === 0,
+    issues,
+    sources: allSources,
+  };
+}
+
+// ─── 实现部分清单校验 ───────────────────────────────────
+// 检查哲学文档是否包含"实现部分清单"——Weaver 是否走了拆解流程。
+// PHILOSOPHY_WEAVER.md Step 2 要求产出"实现部分清单"。
+
+/**
+ * 校验哲学文档是否包含实现部分拆解清单。
+ * Weaver 按 PART_DECOMPOSITION.md 拆解后，必须在哲学文档里显式列出拆解出的部分。
+ * @param {string} philosophyDir — 00_PHILOSOPHY/ 目录路径
+ * @returns {{ passed: boolean, issues: Array<{severity: string, msg: string}>, parts: string[] }}
+ */
+export function validatePartDecomposition(philosophyDir) {
+  const issues = [];
+  const parts = [];
+
+  const files = listPhilosophyFiles(philosophyDir);
+
+  // 搜索"实现部分"相关章节——可能叫"实现部分清单""部分拆解""Part Decomposition"等
+  const PART_SECTION_PATTERNS = [
+    /^##\s+实现部分清单/m,
+    /^##\s+部分拆解/m,
+    /^##\s+实现部分/m,
+    /^##\s+Part Decomposition/m,
+    /^##\s+Implementation Parts/m,
+    /^##\s+拆解出的部分/m,
+  ];
+
+  // 搜索部分条目——通常是 "- **部分名**" 或 "├── 部分名" 或 "| 部分名 |"
+  const PART_ITEM_PATTERNS = [
+    /^\s*[-*]\s+\*\*(.+?)\*\*/gm,  // - **CLI 交互设计**
+    /^\s*├──\s+(.+)/gm,              // ├── CLI 交互设计
+    /^\s*└──\s+(.+)/gm,              // └── 产物设计
+  ];
+
+  let foundSection = false;
+
+  for (const file of files) {
+    const content = readFileSync(join(philosophyDir, file), 'utf-8');
+
+    // 检查是否有实现部分章节
+    for (const pattern of PART_SECTION_PATTERNS) {
+      if (pattern.test(content)) {
+        foundSection = true;
+        // 提取该章节的部分条目
+        const sectionMatch = content.match(pattern);
+        if (sectionMatch) {
+          const startIdx = sectionMatch.index + sectionMatch[0].length;
+          const nextSection = content.slice(startIdx).match(/\n##\s/m);
+          const sectionText = nextSection
+            ? content.slice(startIdx, startIdx + nextSection.index)
+            : content.slice(startIdx);
+
+          for (const itemPattern of PART_ITEM_PATTERNS) {
+            const matches = [...sectionText.matchAll(itemPattern)];
+            for (const m of matches) {
+              const partName = m[1].trim().replace(/[—\-–].*$/, '').trim();
+              if (partName && !parts.includes(partName)) {
+                parts.push(partName);
+              }
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  if (!foundSection) {
+    issues.push({
+      severity: 'high',
+      msg: '哲学文档没有"实现部分清单"章节。PHILOSOPHY_WEAVER.md Step 2 要求按 PART_DECOMPOSITION.md 拆解实现部分，并在哲学文档中显式列出。可能 Weaver 跳过了拆解步骤。',
+    });
+  } else if (parts.length < 2) {
+    issues.push({
+      severity: 'medium',
+      msg: `实现部分清单仅识别到 ${parts.length} 个部分。PART_DECOMPOSITION.md 建议小项目 3-5 个部分，大项目 6-10 个。可能拆解不充分。`,
+    });
+  }
+
+  return {
+    passed: issues.length === 0,
+    issues,
+    parts,
+  };
+}

package/cli/src/preview.js

@@ -1,15 +1,72 @@
-// preview — 输出提示词，让 AI 读 .loom/ 文件并生成 HTML
-// CLI 不收集数据、不生成 HTML。AI 自己读文件、重组信息、生成 HTML。
-// 因为都是同一个 Agent 负责的，它就在项目目录里，能直接读文件。
-
-import { readFileSync } from 'node:fs';
-
-const PROMPT_PATH = new URL('./preview-prompt.md', import.meta.url);
+// preview — 输出提示词，让 AI 读 .loom/ 文件并生成 HTML，并检查投影新鲜度。
+// CLI 不生成 HTML。AI 自己读文件、重组信息、生成 HTML。
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { readCurrentPointer } from './shared/paths.js';
+
+const PROMPT_PATH = new URL('./preview-prompt.md', import.meta.url);
+const SOURCE_FILE_NAMES = new Set([
+  '01_VISION.md',
+  '02_ARCHITECTURE.md',
+  '04_INTENT_MAP.json',
+  '05_VERIFICATION.md',
+  '06_CHANGELOG.md',
+]);
 
 /**
  * 输出 preview 提示词。
  * @returns {string}
  */
-export function generatePreviewPrompt() {
-  return readFileSync(PROMPT_PATH, 'utf-8');
-}
+export function generatePreviewPrompt() {
+  return readFileSync(PROMPT_PATH, 'utf-8');
+}
+
+function shouldIncludeSource(filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  const fileName = normalized.split('/').pop();
+  if (SOURCE_FILE_NAMES.has(fileName)) return true;
+  return normalized.includes('/00_PHILOSOPHY/')
+    || normalized.includes('/03_DECISIONS/')
+    || normalized.includes('/verifications/');
+}
+
+function collectSourceFiles(dir, files = []) {
+  if (!existsSync(dir)) return files;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectSourceFiles(fullPath, files);
+    } else if (shouldIncludeSource(fullPath)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+export function getPreviewStatus(projectDir) {
+  const previewPath = join(projectDir, 'loom-preview.html');
+  const loomRoot = join(projectDir, '.loom');
+  const current = readCurrentPointer(loomRoot);
+  const versionDir = current ? join(loomRoot, current) : null;
+  const sourceFiles = versionDir ? collectSourceFiles(versionDir) : [];
+  const latestSource = sourceFiles
+    .map((filePath) => ({ filePath, mtimeMs: statSync(filePath).mtimeMs }))
+    .sort((a, b) => b.mtimeMs - a.mtimeMs)[0] || null;
+
+  const exists = existsSync(previewPath);
+  const previewMtimeMs = exists ? statSync(previewPath).mtimeMs : null;
+  const sourceLatestMtimeMs = latestSource?.mtimeMs ?? null;
+  const fresh = exists && sourceLatestMtimeMs !== null && previewMtimeMs >= sourceLatestMtimeMs;
+
+  return {
+    exists,
+    fresh,
+    version: current,
+    preview_path: previewPath,
+    preview_mtime: previewMtimeMs ? new Date(previewMtimeMs).toISOString() : null,
+    source_latest_mtime: sourceLatestMtimeMs ? new Date(sourceLatestMtimeMs).toISOString() : null,
+    latest_source_file: latestSource ? relative(projectDir, latestSource.filePath).replace(/\\/g, '/') : null,
+    next_command: fresh ? 'loom preview' : 'loom preview --regen',
+  };
+}

package/cli/src/verify.js

@@ -92,10 +92,14 @@ export function writeVerification(verificationsDir, record) {
     data = { intent_id: record.intent_id, records: [] };
   }
 
-  // 计算轮次和 deviated 计数
-  const round = data.records.length + 1;
-  const deviatedCount = data.records.filter(r => r.verdict === 'deviated').length
-    + (record.verdict === 'deviated' ? 1 : 0);
+  // 计算轮次和连续 deviated 计数。规范要求中间出现 passed/blocked 后重置。
+  const round = data.records.length + 1;
+  const recordsWithCurrent = [...data.records, record];
+  let deviatedCount = 0;
+  for (let i = recordsWithCurrent.length - 1; i >= 0; i--) {
+    if (recordsWithCurrent[i].verdict !== 'deviated') break;
+    deviatedCount++;
+  }
 
   // 追加新记录
   data.records.push({