@haaaiawd/loom 0.1.0 → 0.8.0

package/cli/src/intent-map.js

@@ -3,85 +3,22 @@
 
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { resolve, dirname, join } from 'node:path';
-
-/**
- * 从 heading 文本中提取显式锚点（和 philosophy.js 一致的逻辑）。
- */
-function extractExplicitAnchor(headingText) {
-  const match = headingText.match(/\{#([\w-]+)\}\s*$/);
-  return match ? match[1] : null;
-}
-
-/**
- * slugify — strip \r、支持显式锚点、ASCII fallback。
- */
-function slugify(text) {
-  return text
-    .replace(/\r/g, '')
-    .replace(/\{#[\w-]+\}\s*$/, '')
-    .toLowerCase()
-    .replace(/[^\w\s-]/g, '')
-    .replace(/\s+/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '')
-    .trim();
-}
-
-/**
- * 从 MD 内容中提取指定 section（和 philosophy.js 一致的逻辑）。
- */
-function extractMdSection(content, sectionSlug) {
-  if (!sectionSlug) return content;
-  const lines = content.split('\n');
-  let capturing = false;
-  let targetLevel = 0;
-  const captured = [];
-  for (const line of lines) {
-    const cleanLine = line.replace(/\r$/, '');
-    const headingMatch = cleanLine.match(/^(#{1,6})\s+(.+)$/);
-    if (headingMatch) {
-      const level = headingMatch[1].length;
-      const headingText = headingMatch[2];
-      const slug = extractExplicitAnchor(headingText) || slugify(headingText);
-      if (capturing && level <= targetLevel) break;
-      if (slug === sectionSlug) {
-        capturing = true;
-        targetLevel = level;
-        captured.push(cleanLine);
-        continue;
-      }
-    }
-    if (capturing) captured.push(cleanLine);
-  }
-  if (captured.length === 0) {
-    throw new Error(`意图叙事章节未找到: #${sectionSlug}`);
-  }
-  return captured.join('\n').trim();
-}
+import { extractMdSection, readJsonFile } from './shared/md-utils.js';
 
 /** 必填字段（INTENT_LOOP.md 底线） */
-const REQUIRED_FIELDS = ['id', 'narrative_ref', 'depends_on', 'acceptance', 'philosophy_anchors', 'status'];
+const REQUIRED_FIELDS = ['id', 'title', 'narrative_ref', 'depends_on', 'acceptance', 'philosophy_anchors', 'status'];
 
 /** 合法 status 值 */
 const VALID_STATUS = ['pending', 'in_progress', 'completed', 'blocked', 'needs_review'];
 
 /**
  * 加载 Intent Map 文件。
- * @param {string} loomDir — .loom/v{N}/ 目录的绝对路径
+ * @param {string} versionDir — .loom/v{N}/ 目录的绝对路径
  * @returns {{ _meta: object, intents: Record<string, object>, topo_order: string[] }}
  */
-export function loadIntentMap(loomDir) {
-  const filePath = join(loomDir, '04_INTENT_MAP.json');
-  if (!existsSync(filePath)) {
-    throw new Error(`Intent Map 不存在: ${filePath}`);
-  }
-  const raw = readFileSync(filePath, 'utf-8');
-  let data;
-  try {
-    data = JSON.parse(raw);
-  } catch (e) {
-    throw new Error(`Intent Map JSON 解析失败: ${e.message}`);
-  }
+export function loadIntentMap(versionDir) {
+  const filePath = join(versionDir, '04_INTENT_MAP.json');
+  const data = readJsonFile(filePath, 'Intent Map');
   validateIntentMap(data);
   return data;
 }
@@ -126,6 +63,16 @@ export function validateIntentMap(data) {
         }
       }
     }
+    // acceptance 质量底线（IM-2）：必须具体到可验证，不能是占位符
+    if (intent.acceptance && typeof intent.acceptance === 'string') {
+      const acc = intent.acceptance.trim();
+      if (acc === '...' || acc === '' || acc.length < 20) {
+        errors.push(
+          `intents["${id}"].acceptance 太短（${acc.length}字符）——必须是具体可验证的契约，不能是占位符。\n` +
+          `    acceptance 应包含功能承诺 + 防御承诺（见 INTENT_LOOP.md IM-2 "acceptance 承诺分层"）。`
+        );
+      }
+    }
   }
 
   // topo_order 必须覆盖所有 Intent
@@ -148,8 +95,8 @@ export function validateIntentMap(data) {
  * status=pending 且 depends_on 全部 completed，按 topo_order 取第一个。
  * @returns {object|null} Intent 对象，或 null（没有可执行的）
  */
-export function getNextIntent(loomDir) {
-  const { intents, topo_order } = loadIntentMap(loomDir);
+export function getNextIntent(versionDir) {
+  const { intents, topo_order } = loadIntentMap(versionDir);
   for (const id of topo_order) {
     const intent = intents[id];
     if (intent.status !== 'pending') continue;
@@ -164,12 +111,14 @@ export function getNextIntent(loomDir) {
 /**
  * 返回进度概览：各状态的 Intent 数量 + ID 列表。
  */
-export function getStatus(loomDir) {
-  const { intents } = loadIntentMap(loomDir);
+export function getStatus(versionDir) {
+  const { intents } = loadIntentMap(versionDir);
   const summary = { pending: [], in_progress: [], completed: [], blocked: [] };
+  const titles = {};
   for (const [id, intent] of Object.entries(intents)) {
     const s = intent.status;
     if (summary[s]) summary[s].push(id);
+    titles[id] = intent.title || '';
   }
   return {
     counts: {
@@ -180,14 +129,15 @@ export function getStatus(loomDir) {
       total: Object.keys(intents).length,
     },
     ids: summary,
+    titles,
   };
 }
 
 /**
  * 输出 Mermaid 依赖图。
  */
-export function getDependencyGraph(loomDir) {
-  const { intents, topo_order } = loadIntentMap(loomDir);
+export function getDependencyGraph(versionDir) {
+  const { intents, topo_order } = loadIntentMap(versionDir);
   const lines = ['```mermaid', 'graph TD'];
   for (const id of topo_order) {
     const intent = intents[id];
@@ -209,8 +159,8 @@ export function getDependencyGraph(loomDir) {
 /**
  * 按 ID 返回单个 Intent 的完整信息。
  */
-export function getIntent(loomDir, intentId) {
-  const { intents } = loadIntentMap(loomDir);
+export function getIntent(versionDir, intentId) {
+  const { intents } = loadIntentMap(versionDir);
   if (!(intentId in intents)) {
     throw new Error(`Intent 不存在: ${intentId}`);
   }
@@ -220,18 +170,18 @@ export function getIntent(loomDir, intentId) {
 /**
  * 更新 Intent 的运行时 status。
  * 只允许合法的状态转换，防止跳变（如 completed→pending）。
- * @param {string} loomDir — .loom/v{N}/ 目录
+ * @param {string} versionDir — .loom/v{N}/ 目录
  * @param {string} intentId — Intent ID
  * @param {string} newStatus — pending | in_progress | completed | blocked
  * @returns {object} 更新后的 Intent
  */
-export function updateIntentStatus(loomDir, intentId, newStatus) {
+export function updateIntentStatus(versionDir, intentId, newStatus) {
   if (!VALID_STATUS.includes(newStatus)) {
     throw new Error(`非法 status: "${newStatus}" (合法: ${VALID_STATUS.join('|')})`);
   }
 
-  const filePath = join(loomDir, '04_INTENT_MAP.json');
-  const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+  const filePath = join(versionDir, '04_INTENT_MAP.json');
+  const data = readJsonFile(filePath, 'Intent Map');
 
   if (!(intentId in data.intents)) {
     throw new Error(`Intent 不存在: ${intentId}`);
@@ -253,6 +203,13 @@ export function updateIntentStatus(loomDir, intentId, newStatus) {
     );
   }
 
+  // 收敛趟计数：completed → needs_review 时 _meta.pass_count++
+  // 这是变更回流的信号——一个已完成 Intent 需要重新验证，进入新一轮收敛
+  if (oldStatus === 'completed' && newStatus === 'needs_review') {
+    if (!data._meta) data._meta = {};
+    data._meta.pass_count = (data._meta.pass_count || 0) + 1;
+  }
+
   data.intents[intentId].status = newStatus;
   writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
   return data.intents[intentId];
@@ -263,8 +220,8 @@ export function updateIntentStatus(loomDir, intentId, newStatus) {
  * narrative_ref 格式: "01_VISION.md#int-001" 或 "01_VISION.md#int-001"
  * @returns {string} 意图叙事内容
  */
-export function getNarrative(loomDir, intentId) {
-  const { intents } = loadIntentMap(loomDir);
+export function getNarrative(versionDir, intentId) {
+  const { intents } = loadIntentMap(versionDir);
   if (!(intentId in intents)) {
     throw new Error(`Intent 不存在: ${intentId}`);
   }
@@ -275,10 +232,10 @@ export function getNarrative(loomDir, intentId) {
 
   // 解析 "FILE.md#section" 格式
   const [file, section] = ref.split('#');
-  const filePath = join(loomDir, file.trim());
+  const filePath = join(versionDir, file.trim());
   if (!existsSync(filePath)) {
     throw new Error(`愿景文档不存在: ${filePath}`);
   }
   const content = readFileSync(filePath, 'utf-8');
-  return extractMdSection(content, section ? section.trim() : null);
+  return extractMdSection(content, section ? section.trim() : null, '意图叙事');
 }

package/cli/src/philosophy.js

@@ -1,9 +1,11 @@
 // philosophy.js — 按锚点加载哲学文档的特定章节
 // 哲学文档是 MD，锚点格式: "PRODUCT_PHILOSOPHY.md#core-belief"
 // 这个库按锚点提取对应章节，不返回整个文件。
+// 另含灵感来源校验——防止 Weaver 从训练数据"背"几个名字就交差。
 
 import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { extractMdSection } from './shared/md-utils.js';
 
 /**
  * 解析锚点字符串。
@@ -16,102 +18,257 @@ export function parseAnchor(anchor) {
 }
 
 /**
- * 从 heading 文本中提取显式锚点。
- * 支持 Pandoc/MDX 风格语法: "## 核心信念 {#core-belief}"
- * @returns {string|null} 显式锚点 slug，或 null（无显式锚点时）
+ * 按锚点加载哲学文档内容。
+ * @param {string} philosophyDir — 00_PHILOSOPHY/ 目录路径
+ * @param {string} anchor — "PRODUCT_PHILOSOPHY.md#core-belief"
+ * @returns {string} MD 文本（章节或整个文件）
  */
-function extractExplicitAnchor(headingText) {
-  const match = headingText.match(/\{#([\w-]+)\}\s*$/);
-  return match ? match[1] : null;
+export function getPhilosophy(philosophyDir, anchor) {
+  const { file, section } = parseAnchor(anchor);
+  const filePath = join(philosophyDir, file);
+
+  if (!existsSync(filePath)) {
+    throw new Error(`哲学文档不存在: ${filePath}`);
+  }
+
+  const content = readFileSync(filePath, 'utf-8');
+  return extractMdSection(content, section, '哲学');
 }
 
 /**
- * 从 heading 文本生成 slug（fallback，无显式锚点时用）。
- * 规则：小写、去除 \r、空格转连字符、去除非 [a-z0-9_-] 字符。
- * 注意：\w 不匹配中文，所以中文标题的 slug 会是空的——
- * 这就是为什么哲学文档应该用显式锚点 {#anchor} 标注中文标题。
+ * 列出哲学目录下所有 .md 文件名。
  */
-function slugify(text) {
-  return text
-    .replace(/\r/g, '')           // strip CRLF 的 \r
-    .replace(/\{#[\w-]+\}\s*$/, '') // 去掉显式锚点标记
-    .toLowerCase()
-    .replace(/[^\w\s-]/g, '')     // \w = [a-zA-Z0-9_]
-    .replace(/\s+/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '')
-    .trim();
+export function listPhilosophyFiles(philosophyDir) {
+  if (!existsSync(philosophyDir)) {
+    throw new Error(`哲学目录不存在: ${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 = ['萃取', '理由', '为什么', '因为', '启发', '借鉴', '参考理由', '选取理由', '转译'];
+
 /**
- * 从 MD 内容中提取指定 section 的内容（到下一个同级或更高级 heading 为止）。
- * 如果 section 为 null，返回整个文件。
- * 支持显式锚点 {#slug} 和自动 slugify 两种方式匹配。
+ * 从哲学文档内容中提取"灵感来源"章节的条目。
+ * @param {string} content — MD 全文
+ * @returns {Array<{ raw: string, name: string, urls: string[], hasReason: boolean }>}
  */
-function extractSection(content, sectionSlug) {
-  if (!sectionSlug) return content;
+function parseInspirationSources(content) {
+  // 匹配 "## 灵感来源" 或 "## Inspiration" 章节
+  const sectionMatch = content.match(/^##\s+(?:灵感来源|Inspiration|参考来源|References)/m);
+  if (!sectionMatch) return [];
 
-  const lines = content.split('\n');
-  let capturing = false;
-  let targetLevel = 0;
-  const captured = [];
+  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) {
-    // strip \r 以兼容 Windows CRLF
-    const cleanLine = line.replace(/\r$/, '');
-    const headingMatch = cleanLine.match(/^(#{1,6})\s+(.+)$/);
-    if (headingMatch) {
-      const level = headingMatch[1].length;
-      const headingText = headingMatch[2];
-      // 优先用显式锚点，没有再 fallback 到 slugify
-      const slug = extractExplicitAnchor(headingText) || slugify(headingText);
-
-      if (capturing && level <= targetLevel) {
-        break;
+    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 (slug === sectionSlug) {
-        capturing = true;
-        targetLevel = level;
-        captured.push(cleanLine);
-        continue;
-      }
-    }
-    if (capturing) {
-      captured.push(cleanLine);
     }
   }
+  if (currentItem) items.push(currentItem);
+  return items;
+}
 
-  if (captured.length === 0) {
-    throw new Error(`章节未找到: #${sectionSlug}`);
-  }
-  return captured.join('\n').trim();
+/**
+ * 判断 URL 是否为 Wikipedia 链接。
+ */
+function isWikipediaUrl(url) {
+  return /wikipedia\.org/i.test(url);
 }
 
 /**
- * 按锚点加载哲学文档内容。
+ * 校验哲学文档的灵感来源质量。
  * @param {string} philosophyDir — 00_PHILOSOPHY/ 目录路径
- * @param {string} anchor — "PRODUCT_PHILOSOPHY.md#core-belief"
- * @returns {string} MD 文本（章节或整个文件）
+ * @returns {{ passed: boolean, issues: Array<{severity: string, msg: string}>, sources: Array }}
  */
-export function getPhilosophy(philosophyDir, anchor) {
-  const { file, section } = parseAnchor(anchor);
-  const filePath = join(philosophyDir, file);
+export function validateInspirationSources(philosophyDir) {
+  const issues = [];
+  const allSources = [];
 
-  if (!existsSync(filePath)) {
-    throw new Error(`哲学文档不存在: ${filePath}`);
+  // 扫描目录下所有 .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 content = readFileSync(filePath, 'utf-8');
-  return extractSection(content, section);
+  // 全局校验：所有文件的灵感来源加起来，源类型不能单一
+  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 要求产出"实现部分清单"。
+
 /**
- * 列出哲学目录下所有 .md 文件名。
+ * 校验哲学文档是否包含实现部分拆解清单。
+ * Weaver 按 PART_DECOMPOSITION.md 拆解后，必须在哲学文档里显式列出拆解出的部分。
+ * @param {string} philosophyDir — 00_PHILOSOPHY/ 目录路径
+ * @returns {{ passed: boolean, issues: Array<{severity: string, msg: string}>, parts: string[] }}
  */
-export function listPhilosophyFiles(philosophyDir) {
-  if (!existsSync(philosophyDir)) {
-    throw new Error(`哲学目录不存在: ${philosophyDir}`);
+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;
+      }
+    }
   }
-  const dir = readdirSync(philosophyDir);
-  return dir.filter((f) => f.endsWith('.md'));
+
+  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-prompt.md

@@ -160,6 +160,7 @@ SVG 折线，横轴时间，纵轴剩余数。
 - **不可妥协的价值**：清单，每条一句话 + 一句话理由
 - **反模式**：红色警告卡，每张一句
 - **决策原则**：对比表或清单，遇到冲突时怎么取舍
+- **灵感来源**：哲学文档里的"灵感来源"章节——展示参考的艺术家、机构、流派、著作。这是 LOOM 哲学织造的核心机制：从真实思想体系萃取核心思想。每个来源用卡片或标签展示：名字（如 Dieter Rams / Stripe / Unix Philosophy / Anthropic）+ 一句话说明"从这个体系萃取了什么原则" + 来源引用（著作/URL）。这些名字是"思想压缩包的索引"——人类看到名字就能激活对这套哲学的理解。不要把灵感来源藏在正文里，要作为独立视觉块展示。
 
 ### 愿景区域
 

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',
+  };
+}