@haaaiawd/loom 0.9.0 → 1.0.0

package/cli/src/patch.js

@@ -0,0 +1,214 @@
+// patch — authoritative Patch ledger and deterministic Markdown projection.
+// Validation is structural only: verification commands are recorded, never executed.
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { loadIntentMap } from './intent-map.js';
+
+const JSON_FILE = '06_CHANGELOG.json';
+const MARKDOWN_FILE = '06_CHANGELOG.md';
+const PATCH_ID = /^PATCH-(\d{3,})$/;
+const VERIFICATION_RESULTS = new Set(['passed', 'failed', 'skipped']);
+
+export function createEmptyChangelog() {
+  return {
+    _meta: { schema_version: '1.0', source: JSON_FILE },
+    patches: [],
+  };
+}
+
+function requireText(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`Patch ${field} 必须是非空字符串`);
+  }
+}
+
+function validateSafeFile(file, index) {
+  requireText(file, `files[${index}]`);
+  const normalized = file.replace(/\\/g, '/');
+  if (isAbsolute(file) || /^[A-Za-z]:/.test(normalized) || normalized === '.' || normalized.startsWith('/') || normalized.split('/').includes('..')) {
+    throw new Error(`Patch files[${index}] 必须是安全的项目相对路径: ${file}`);
+  }
+}
+
+function validateRecord(record, intents, { stored = false } = {}) {
+  if (!record || typeof record !== 'object' || Array.isArray(record)) {
+    throw new Error('Patch 记录必须是 JSON object');
+  }
+  requireText(record.summary, 'summary');
+  requireText(record.reason, 'reason');
+
+  if (!Array.isArray(record.files) || record.files.length === 0) {
+    throw new Error('Patch files 必须是非空数组');
+  }
+  record.files.forEach(validateSafeFile);
+
+  if (record.affects !== undefined) {
+    if (!Array.isArray(record.affects)) throw new Error('Patch affects 必须是 Intent ID 数组');
+    for (const id of record.affects) {
+      requireText(id, 'affects[]');
+      if (!intents.has(id)) throw new Error(`Patch affects 引用了不存在的 Intent: ${id}`);
+    }
+  }
+
+  if (!Array.isArray(record.verification) || record.verification.length === 0) {
+    throw new Error('Patch verification 必须是非空数组');
+  }
+  let hasPassed = false;
+  record.verification.forEach((item, index) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+      throw new Error(`Patch verification[${index}] 必须是 object`);
+    }
+    if (item.command === undefined && item.method === undefined) {
+      throw new Error(`Patch verification[${index}] 必须提供 command 或 method`);
+    }
+    if (item.command !== undefined) requireText(item.command, `verification[${index}].command`);
+    if (item.method !== undefined) requireText(item.method, `verification[${index}].method`);
+    if (item.evidence !== undefined) requireText(item.evidence, `verification[${index}].evidence`);
+    if (!VERIFICATION_RESULTS.has(item.result)) {
+      throw new Error(`Patch verification[${index}].result 必须是 passed | failed | skipped`);
+    }
+    if (item.result === 'passed') hasPassed = true;
+  });
+  if (!hasPassed) throw new Error('Patch verification 至少需要一个 passed 结果');
+
+  if (stored) {
+    if (!PATCH_ID.test(record.id)) throw new Error(`Patch id 格式无效: ${record.id ?? '(missing)'}`);
+    if (typeof record.timestamp !== 'string' || Number.isNaN(Date.parse(record.timestamp))) {
+      throw new Error(`Patch timestamp 无效: ${record.timestamp ?? '(missing)'}`);
+    }
+  } else if (record.id !== undefined || record.timestamp !== undefined) {
+    throw new Error('Patch id 和 timestamp 由 CLI 分配，请勿在输入中提供');
+  }
+}
+
+function loadIntents(versionDir) {
+  return loadIntentMap(versionDir).intents;
+}
+
+function loadIntentIds(versionDir) {
+  return new Set(Object.keys(loadIntents(versionDir)));
+}
+
+export function renderChangelogMarkdown(changelog) {
+  const lines = [
+    '<!-- GENERATED FILE. DO NOT EDIT. Source: 06_CHANGELOG.json -->',
+    '# Patch Changelog',
+    '',
+    '> Generated deterministically from `06_CHANGELOG.json`. Edit the JSON through `loom patch record`.',
+    '',
+  ];
+  if (changelog.patches.length === 0) {
+    lines.push('_No patches recorded._', '');
+    return lines.join('\n');
+  }
+  for (const patch of changelog.patches) {
+    lines.push(`## ${patch.id} - ${patch.summary}`, '', `- Timestamp: ${patch.timestamp}`, `- Reason: ${patch.reason}`);
+    lines.push(`- Affects: ${(patch.affects || []).map((id) => `\`${id}\``).join(', ') || 'none'}`);
+    lines.push('- Files:', ...patch.files.map((file) => `  - \`${file}\``), '- Verification:');
+    for (const item of patch.verification) {
+      const verification = item.command ? `\`${item.command}\`` : item.method;
+      lines.push(`  - ${item.result}: ${verification}`);
+      if (item.evidence) lines.push(`    - Evidence: ${item.evidence}`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function loadChangelog(versionDir) {
+  const path = join(versionDir, JSON_FILE);
+  if (!existsSync(path)) throw new Error(`Patch changelog 不存在: ${path}`);
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch (error) {
+    throw new Error(`Patch changelog JSON 解析失败: ${path}\n原因: ${error.message}`);
+  }
+}
+
+function validateChangelog(versionDir, changelog) {
+  if (!changelog || typeof changelog !== 'object' || Array.isArray(changelog)) {
+    throw new Error('Patch changelog 必须是 JSON object');
+  }
+  if (changelog._meta?.schema_version !== '1.0' || changelog._meta?.source !== JSON_FILE) {
+    throw new Error('Patch changelog _meta 无效：schema_version 必须为 1.0，source 必须为 06_CHANGELOG.json');
+  }
+  if (!Array.isArray(changelog.patches)) throw new Error('Patch changelog patches 必须是数组');
+  const intents = loadIntentIds(versionDir);
+  const ids = new Set();
+  changelog.patches.forEach((record, index) => {
+    validateRecord(record, intents, { stored: true });
+    const expected = `PATCH-${String(index + 1).padStart(3, '0')}`;
+    if (record.id !== expected) throw new Error(`Patch id 序列无效: 期望 ${expected}，实际 ${record.id}`);
+    if (ids.has(record.id)) throw new Error(`Patch id 重复: ${record.id}`);
+    ids.add(record.id);
+  });
+}
+
+function writeChangelog(versionDir, changelog) {
+  writeFileSync(join(versionDir, JSON_FILE), `${JSON.stringify(changelog, null, 2)}\n`, 'utf-8');
+  writeFileSync(join(versionDir, MARKDOWN_FILE), renderChangelogMarkdown(changelog), 'utf-8');
+}
+
+export function scaffoldChangelog(versionDir) {
+  const jsonPath = join(versionDir, JSON_FILE);
+  const markdownPath = join(versionDir, MARKDOWN_FILE);
+  if (!existsSync(jsonPath) && existsSync(markdownPath)) {
+    const legacyMarkdown = readFileSync(markdownPath, 'utf-8');
+    if (!legacyMarkdown.startsWith('<!-- GENERATED FILE. DO NOT EDIT. Source: 06_CHANGELOG.json -->')) {
+      throw new Error(
+        `检测到手工维护的旧版 ${MARKDOWN_FILE}，拒绝用空 Patch ledger 覆盖。\n` +
+        `请先把历史条目迁移到 ${JSON_FILE}，或备份并删除旧 Markdown 后重试。`
+      );
+    }
+  }
+  const changelog = existsSync(jsonPath) ? loadChangelog(versionDir) : createEmptyChangelog();
+  if (!existsSync(jsonPath)) writeFileSync(jsonPath, `${JSON.stringify(changelog, null, 2)}\n`, 'utf-8');
+  writeFileSync(markdownPath, renderChangelogMarkdown(changelog), 'utf-8');
+}
+
+export function recordPatch(versionDir, input, now = new Date()) {
+  const changelog = loadChangelog(versionDir);
+  validateChangelog(versionDir, changelog);
+  const intents = loadIntents(versionDir);
+  const unfinished = Object.values(intents).filter((intent) => intent.status !== 'completed');
+  if (unfinished.length > 0) {
+    throw new Error(`Patch 只能在全部 Intent 完成后记录；尚未完成: ${unfinished.map((intent) => intent.id).join(', ')}`);
+  }
+  validateRecord(input, new Set(Object.keys(intents)));
+  const record = {
+    id: `PATCH-${String(changelog.patches.length + 1).padStart(3, '0')}`,
+    timestamp: now.toISOString(),
+    summary: input.summary.trim(),
+    reason: input.reason.trim(),
+    affects: input.affects || [],
+    files: input.files.map((file) => file.replace(/\\/g, '/')),
+    verification: input.verification,
+  };
+  changelog.patches.push(record);
+  writeChangelog(versionDir, changelog);
+  return record;
+}
+
+export function listPatches(versionDir) {
+  const changelog = loadChangelog(versionDir);
+  validateChangelog(versionDir, changelog);
+  return changelog.patches;
+}
+
+export function getPatch(versionDir, id) {
+  const patch = listPatches(versionDir).find((record) => record.id === id);
+  if (!patch) throw new Error(`Patch 不存在: ${id}`);
+  return patch;
+}
+
+export function validatePatches(versionDir) {
+  const changelog = loadChangelog(versionDir);
+  validateChangelog(versionDir, changelog);
+  const markdownPath = join(versionDir, MARKDOWN_FILE);
+  if (!existsSync(markdownPath)) throw new Error(`Patch Markdown 投影不存在: ${markdownPath}`);
+  if (readFileSync(markdownPath, 'utf-8') !== renderChangelogMarkdown(changelog)) {
+    throw new Error('06_CHANGELOG.md 不是 06_CHANGELOG.json 的最新确定性投影');
+  }
+  return { valid: true, patches: changelog.patches.length };
+}

package/cli/src/philosophy.js

@@ -3,18 +3,23 @@
 // 这个库按锚点提取对应章节，不返回整个文件。
 // 另含灵感来源校验——防止 Weaver 从训练数据"背"几个名字就交差。
 
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { extractMdSection } from './shared/md-utils.js';
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, renameSync, unlinkSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { extractMdSection, readJsonFile } from './shared/md-utils.js';
+import { applyImpactReview, dependentClosure, validateImpactPartition, validateIntentMap } from './intent-map.js';
 
 /**
  * 解析锚点字符串。
  * @param {string} anchor — "FILE.md#section" 或 "FILE.md"
  * @returns {{ file: string, section: string|null }}
  */
-export function parseAnchor(anchor) {
-  const [file, section] = anchor.split('#');
-  return { file: file.trim(), section: section ? section.trim() : null };
+export function parseAnchor(anchor) {
+  const [file, section] = anchor.split('#');
+  const normalizedFile = file.trim();
+  if (!normalizedFile || basename(normalizedFile) !== normalizedFile || !normalizedFile.endsWith('.md')) {
+    throw new Error(`哲学锚点文件名非法: ${normalizedFile || '(empty)'}`);
+  }
+  return { file: normalizedFile, section: section ? section.trim() : null };
 }
 
 /**
@@ -38,25 +43,167 @@ export function getPhilosophy(philosophyDir, anchor) {
 /**
  * 列出哲学目录下所有 .md 文件名。
  */
-export function listPhilosophyFiles(philosophyDir) {
+export function listPhilosophyFiles(philosophyDir) {
   if (!existsSync(philosophyDir)) {
     throw new Error(`哲学目录不存在: ${philosophyDir}`);
   }
   const dir = readdirSync(philosophyDir);
   return dir.filter((f) => f.endsWith('.md'));
-}
+}
+
+const REVISION_CLASSIFICATIONS = ['clarification', 'minor', 'major'];
+
+function normalizeAnchor(anchor) {
+  if (typeof anchor !== 'string' || anchor.trim() === '') throw new Error('哲学锚点必须是非空文本');
+  const parts = anchor.trim().split('#');
+  if (parts.length > 2 || !parts[0].trim()) throw new Error(`哲学锚点格式非法: ${anchor}`);
+  const { file, section } = parseAnchor(anchor.trim());
+  return section ? `${file}#${section}` : file;
+}
+
+function impactEntry(intent) {
+  return {
+    id: intent.id,
+    title: intent.title || '',
+    status: intent.status,
+    revision: intent.revision ?? 1,
+    acceptance: intent.acceptance,
+  };
+}
+
+/** Resolve an anchor and report direct references plus their dependent closure without mutation. */
+export function assessPhilosophyImpact(versionDir, anchor) {
+  const resolvedAnchor = normalizeAnchor(anchor);
+  getPhilosophy(join(versionDir, '00_PHILOSOPHY'), resolvedAnchor);
+  const data = readJsonFile(join(versionDir, '04_INTENT_MAP.json'), 'Intent Map');
+  validateIntentMap(data);
+  const directIds = Object.values(data.intents)
+    .filter((intent) => (intent.philosophy_anchors || []).some((item) => normalizeAnchor(item) === resolvedAnchor))
+    .map((intent) => intent.id);
+  const directSet = new Set(directIds);
+  const impacted = new Set(directIds);
+  for (const id of directIds) {
+    for (const dependent of dependentClosure(data.intents, id).all) impacted.add(dependent);
+  }
+  const ordered = (data.topo_order || Object.keys(data.intents)).filter((id) => impacted.has(id));
+  const transitiveIds = ordered.filter((id) => !directSet.has(id));
+  const describe = (ids) => ids.map((id) => impactEntry(data.intents[id]));
+  return {
+    anchor: resolvedAnchor,
+    direct: describe(directIds),
+    transitive: describe(transitiveIds),
+    impacted: describe(ordered),
+    impacted_ids: ordered,
+  };
+}
+
+function nextRevisionAdr(decisionsDir) {
+  if (!existsSync(decisionsDir)) return 'PHIL-REV-001.md';
+  const numbers = readdirSync(decisionsDir)
+    .map((name) => name.match(/^PHIL-REV-(\d{3,})\.md$/)?.[1])
+    .filter(Boolean)
+    .map(Number);
+  return `PHIL-REV-${String((numbers.length ? Math.max(...numbers) : 0) + 1).padStart(3, '0')}.md`;
+}
+
+function revisionGuidance(anchor, classification, reason, impactedIds) {
+  const escapedReason = reason.replace(/"/g, '\\"');
+  const base = `loom philosophy revise ${anchor} --classification ${classification} --reason "${escapedReason}" --confirm`;
+  if (classification === 'clarification') {
+    return impactedIds.length ? `${base} --unaffected ${impactedIds.join(',')}` : base;
+  }
+  if (!impactedIds.length) return base;
+  return `${base} --review <review IDs from ${impactedIds.join(',')}> --unaffected <remaining IDs from ${impactedIds.join(',')}>`;
+}
+
+/** Assess or confirm a philosophy revision while leaving philosophy prose to Weaver/the user. */
+export function revisePhilosophy(versionDir, anchor, options) {
+  if (!REVISION_CLASSIFICATIONS.includes(options.classification)) {
+    throw new Error(`--classification 非法: ${options.classification || '(missing)'}（合法: ${REVISION_CLASSIFICATIONS.join('|')}）`);
+  }
+  if (typeof options.reason !== 'string' || options.reason.trim() === '') throw new Error('--reason 必须是非空文本');
+  const reason = options.reason.trim();
+  const impact = assessPhilosophyImpact(versionDir, anchor);
+
+  if (options.classification === 'major') {
+    return {
+      mode: 'assessment',
+      mutated: false,
+      classification: 'major',
+      reason,
+      ...impact,
+      follow_up: { command: 'loom version new', guidance: 'Major philosophy revisions never mutate the current version. Create a new version, then have Weaver weave its philosophy.' },
+    };
+  }
+  if (!options.confirm) {
+    return {
+      mode: 'assessment',
+      mutated: false,
+      classification: options.classification,
+      reason,
+      ...impact,
+      required_partition: impact.impacted_ids,
+      follow_up: {
+        command: revisionGuidance(impact.anchor, options.classification, reason, impact.impacted_ids),
+        guidance: options.classification === 'clarification'
+          ? 'Clarification requires an empty --review set; classify every impacted Intent as --unaffected because all acceptance remains valid.'
+          : 'Classify every impacted Intent exactly once between --review and --unaffected; omit an empty group.',
+      },
+    };
+  }
+
+  const review = options.review || [];
+  const unaffected = options.unaffected || [];
+  if (options.classification === 'clarification' && review.length) throw new Error('clarification 的 --review 必须为空；所有 acceptance 必须仍然有效');
+  validateImpactPartition(impact.impacted_ids, review, unaffected);
+  const reviewSet = new Set(review);
+  const unaffectedSet = new Set(unaffected);
+  const orderedReview = impact.impacted_ids.filter((id) => reviewSet.has(id));
+  const orderedUnaffected = impact.impacted_ids.filter((id) => unaffectedSet.has(id));
+
+  const mapPath = join(versionDir, '04_INTENT_MAP.json');
+  const data = readJsonFile(mapPath, 'Intent Map');
+  validateIntentMap(data);
+  const { reviewed } = applyImpactReview(data, orderedReview, { incrementPassOnce: options.classification === 'minor' });
+  const unchanged = orderedUnaffected.map((id) => ({ id, status_before: data.intents[id].status, status_after: data.intents[id].status }));
+  validateIntentMap(data);
+
+  const decisionsDir = join(versionDir, '03_DECISIONS');
+  mkdirSync(decisionsDir, { recursive: true });
+  const adrName = nextRevisionAdr(decisionsDir);
+  const adrPath = join(decisionsDir, adrName);
+  const timestamp = new Date().toISOString();
+  const list = (ids) => ids.length ? ids.map((id) => `- ${id}`).join('\n') : '- None';
+  const adr = `# Philosophy Revision ${adrName.slice(9, -3)}\n\n` +
+    `- Timestamp: ${timestamp}\n- Anchor: ${impact.anchor}\n- Classification: ${options.classification}\n- Reason: ${reason}\n\n` +
+    `## Reviewed\n\n${list(orderedReview)}\n\n## Unaffected\n\n${list(orderedUnaffected)}\n\n` +
+    '## Prose Ownership\n\nPhilosophy prose is edited by Weaver/user separately. This ADR is an impact audit record, not a second philosophy truth source.\n';
+  const token = `${process.pid}-${Date.now()}`;
+  const mapTemp = `${mapPath}.tmp-${token}`;
+  const adrTemp = `${adrPath}.tmp-${token}`;
+  writeFileSync(mapTemp, `${JSON.stringify(data, null, 2)}\n`, 'utf-8');
+  writeFileSync(adrTemp, adr, 'utf-8');
+  try {
+    renameSync(adrTemp, adrPath);
+    try {
+      renameSync(mapTemp, mapPath);
+    } catch (error) {
+      try { unlinkSync(adrPath); } catch {}
+      throw error;
+    }
+  } catch (error) {
+    try { unlinkSync(mapTemp); } catch {}
+    try { unlinkSync(adrTemp); } catch {}
+    throw error;
+  }
+  return { mode: 'confirmed', mutated: true, classification: options.classification, reason, ...impact, reviewed, unaffected: unchanged, audit_adr: `03_DECISIONS/${adrName}`, timestamp };
+}
 
 // ─── 灵感来源校验 ───────────────────────────────────────
 // 防止 Weaver 从训练数据"背"几个名字就交差。
-// 校验规则：
-//   1. 至少 3 个独立源
-//   2. 至少 2 个非 Wikipedia 链接（Wikipedia 是常识入口，不是深度源）
-//   3. 每个源必须有"为什么选它"的理由（萃取/理由/为什么 等关键词）
-//   4. 源不能全是同一类型（如全是 Wikipedia、全是博客）
-
-const MIN_SOURCES = 3;
-const MIN_NON_WIKI = 2;
-const REASON_KEYWORDS = ['萃取', '理由', '为什么', '因为', '启发', '借鉴', '参考理由', '选取理由', '转译'];
+// 校验原则：只检查证据能否追溯，以及为何影响了项目判断。
+// 来源数量与类型不设固定配额；一个直接证据可以胜过十个装饰性链接。
+const REASON_KEYWORDS = ['萃取', '理由', '为什么', '因为', '启发', '借鉴', '参考理由', '选取理由', '转译'];
 
 /**
  * 从哲学文档内容中提取"灵感来源"章节的条目。
@@ -68,7 +215,7 @@ const REASON_KEYWORDS = ['萃取', '理由', '为什么', '因为', '启发', '
 function parseInspirationSources(content) {
   // 匹配 "## 灵感来源" 或 "## Inspiration Sources" 等章节
   // 支持 {#anchor} 后缀和多种标题变体
-  const sectionMatch = content.match(/^##\s+(?:灵感来源|Inspiration|参考来源|References?|参考文献|参考资料|Sources|Bibliography)/m);
+  const sectionMatch = content.match(/^##\s+(?:灵感来源|Inspiration|参考来源|References?|参考文献|参考资料|Sources|Bibliography)/m);
   if (!sectionMatch) return [];
 
   const startIdx = sectionMatch.index + sectionMatch[0].length;
@@ -85,20 +232,22 @@ function parseInspirationSources(content) {
 
   // 匹配 - xxx / * xxx / 1. xxx / 2. xxx 等
   const ITEM_RE = /^\s*(?:[-*]|\d+\.)\s+/;
+  // URL 匹配：https:// / file:// / local:./path / local:/abs/path
+  const URL_RE = /(?:https?:|file:)[\/]+[^\s）)]+|local:[^\s）)]+/g;
 
   for (const line of lines) {
     if (ITEM_RE.test(line)) {
       // 新条目
       if (currentItem) items.push(currentItem);
       const raw = line.replace(ITEM_RE, '').trim();
-      const urls = [...raw.matchAll(/https?:\/\/[^\s）)]+/g)].map((m) => m[0]);
+      const urls = [...raw.matchAll(URL_RE)].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]);
+      const newUrls = [...line.matchAll(URL_RE)].map((m) => m[0]);
       currentItem.urls.push(...newUrls);
       if (REASON_KEYWORDS.some((kw) => line.includes(kw))) {
         currentItem.hasReason = true;
@@ -113,16 +262,9 @@ function parseInspirationSources(content) {
  * 检查哲学文档是否有"灵感来源"章节（不管有没有条目）。
  * 用来区分"没有章节"和"有章节但没条目"两种情况。
  */
-function hasInspirationSection(content) {
-  return /^##\s+(?:灵感来源|Inspiration|参考来源|References?|参考文献|参考资料|Sources|Bibliography)/m.test(content);
-}
-
-/**
- * 判断 URL 是否为 Wikipedia 链接。
- */
-function isWikipediaUrl(url) {
-  return /wikipedia\.org/i.test(url);
-}
+function hasInspirationSection(content) {
+  return /^##\s+(?:证据地图|Evidence Map|灵感来源|Inspiration|参考来源|References?|参考文献|参考资料|Sources|Bibliography)/m.test(content);
+}
 
 /**
  * 校验哲学文档的灵感来源质量。
@@ -143,23 +285,7 @@ export function validateInspirationSources(philosophyDir) {
 
     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) {
+    for (const src of sources) {
       if (!src.hasReason) {
         issues.push({
           severity: 'medium',
@@ -175,18 +301,6 @@ export function validateInspirationSources(philosophyDir) {
     }
   }
 
-  // 全局校验：所有文件的灵感来源加起来，源类型不能单一
-  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) {
     // 区分两种情况：完全没有章节 vs 有章节但没条目
@@ -199,108 +313,19 @@ export function validateInspirationSources(philosophyDir) {
     if (filesWithSection.length > 0) {
       issues.push({
         severity: 'high',
-        msg: `${filesWithSection.join(', ')} 有"灵感来源"章节但没有可识别的条目。章节里可能是模板占位符。需要 Weaver 真正走搜索漏斗，填入至少 ${MIN_SOURCES} 个源（- **源名** — 理由。来源：URL 格式）。`,
+        msg: `${filesWithSection.join(', ')} 有证据章节但没有可识别的条目。请只填入实际改变了原则或取舍的来源，并写明选择理由与可追溯位置。`,
       });
     } else {
       issues.push({
         severity: 'high',
-        msg: '所有哲学文档都没有"灵感来源"章节。PHILOSOPHY_WEAVER.md 要求哲学文档必须包含灵感来源（参考了哪些机构、人物、流派——附 URL 和理由）。支持的标题：灵感来源 / Inspiration / 参考来源 / References / 参考文献 / 参考资料 / Sources / Bibliography。',
+        msg: '所有哲学文档都没有证据地图或灵感来源。Doctrine 必须说明哪些项目事实或外部资料实际改变了原则与取舍，并提供理由和可追溯位置。',
       });
     }
   }
 
-  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);
-
-  // 搜索"实现部分"相关章节——支持 {#anchor} 后缀和多种标题变体
-  const PART_SECTION_PATTERNS = [
-    /^##\s+实现部分清单/m,
-    /^##\s+部分拆解/m,
-    /^##\s+实现部分/m,
-    /^##\s+Part Decomposition/m,
-    /^##\s+Implementation Parts/m,
-    /^##\s+拆解出的部分/m,
-    /^##\s+Implementation Decomposition/m,
-    /^##\s+Parts? /m,
-  ];
-
-  // 搜索部分条目——支持无序列表、有序列表、树形符号
-  const PART_ITEM_PATTERNS = [
-    /^\s*[-*]\s+\*\*(.+?)\*\*/gm,    // - **CLI 交互设计**
-    /^\s*\d+\.\s+\*\*(.+?)\*\*/gm,   // 1. **CLI 交互设计**
-    /^\s*\d+\.\s+(.+)/gm,            // 1. 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 拆解实现部分，并在哲学文档中显式列出。支持的标题：实现部分清单 / 部分拆解 / 实现部分 / Part Decomposition / Implementation Parts / 拆解出的部分。',
-    });
-  } 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,
-  };
-}
+  return {
+    passed: issues.length === 0,
+    issues,
+    sources: allSources,
+  };
+}