@haaaiawd/loom 0.10.0 → 1.0.0

package/cli/src/activate.js

@@ -1,73 +1,302 @@
-// activate — 输出角色激活提示词
-// 把角色文件 + 哲学锚点 + 底线拼成激活上下文，供上层编排器使用。
-
-import { readFileSync, existsSync } from 'node:fs';
-import { join, resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { getLoomRoot } from './shared/paths.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-/** 合法角色名 */
-const VALID_ROLES = ['weaver', 'visionary', 'architect', 'forge', 'keeper'];
-
-/** 角色文件映射 */
-const ROLE_FILES = {
-  weaver: 'meta/PHILOSOPHY_WEAVER.md',
-  visionary: 'roles/visionary.md',
-  architect: 'roles/architect.md',
-  forge: 'roles/forge.md',
-  keeper: 'roles/keeper.md',
-};
-
-/**
- * 输出角色激活提示词。
- * @param {string} role — 角色名
- * @param {string} versionDir — .loom/v{N} 目录（可选，weaver 不需要）
- * @returns {string} 激活提示词
- */
-export function activateRole(role, versionDir) {
-  if (!VALID_ROLES.includes(role)) {
-    throw new Error(`未知角色: ${role}\n合法角色: ${VALID_ROLES.join(', ')}`);
-  }
-
-  const loomRoot = getLoomRoot();
-  const parts = [];
-
-  // 1. 角色文件
-  const roleFile = join(loomRoot, ROLE_FILES[role]);
-  if (!existsSync(roleFile)) {
-    throw new Error(`角色文件不存在: ${roleFile}`);
-  }
-  parts.push(readFileSync(roleFile, 'utf-8'));
-
-  // 2. BASELINE 摘要（不重复全文——全文见 meta/BASELINE.md）
-  //    5 条底线压缩成摘要，角色需要知道底线存在 + 一句话内容。
-  //    如果角色需要底线细节（如 Weaver 织造哲学时），自行 readFileSync 全文。
-  parts.push('\n---\n\n## 强制加载：BASELINE 摘要\n\n');
-  parts.push('> 完整底线见 `meta/BASELINE.md`。以下是 5 条底线的摘要——\n');
-  parts.push('> 角色激活时必须知道这些底线存在，违反任何一条必须立即停止。\n');
-  parts.push('> Philosophy Weaver 织造哲学时必须读取完整 BASELINE.md 作为硬约束输入。\n\n');
-  parts.push('| 编号 | 底线 | 一句话 |\n');
-  parts.push('|------|------|--------|\n');
-  parts.push('| B1 | 必须有结构设计 | 编码前必须有明确的目录结构 + 模块职责边界 + 显式依赖关系 |\n');
-  parts.push('| B2 | 禁止硬编码 | 密钥/配置/环境特定值/魔法数字不进代码，用环境变量或集中配置 |\n');
-  parts.push('| B3 | 接口契约必须显式 | API/CLI/配置/错误语义/跨系统协议必须有显式定义，变更可追溯 |\n');
-  parts.push('| B4 | 决策必须可追溯 | 影响架构/接口/技术栈/依赖的决策必须记录（ADR 或等效格式） |\n');
-  parts.push('| B5 | 意图必须可回溯 | 每个实现单元有意图叙事（"为什么存在"），可被 Keeper 引用对照 |\n');
-  parts.push('\n> 底线不可被哲学覆盖。如果织造的哲学与底线冲突，底线优先。\n');
-
-  // 3. 项目特定底线（如果有 versionDir）
-  if (versionDir) {
-    const projectBaseline = join(versionDir, '00_PHILOSOPHY/PROJECT_BASELINE.md');
-    if (existsSync(projectBaseline)) {
-      parts.push('\n---\n\n## 强制加载：项目特定底线\n\n' + readFileSync(projectBaseline, 'utf-8'));
-    }
-
-    // 4. 角色激活协议
-    const activationFile = join(loomRoot, 'meta/ROLE_ACTIVATION.md');
-    parts.push('\n---\n\n## 角色激活协议\n\n' + readFileSync(activationFile, 'utf-8'));
-  }
-
-  return parts.join('\n');
-}
+// activate — compile a role- and intent-scoped Context Pack.
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { getLoomRoot } from './shared/paths.js';
+import { getIntent, getNarrative } from './intent-map.js';
+import { getIntentDraft } from './intent-draft.js';
+import { getPhilosophy } from './philosophy.js';
+import { getVerificationContract } from './verify.js';
+import { extractMdSection } from './shared/md-utils.js';
+
+const VALID_ROLES = ['weaver', 'visionary', 'architect', 'forge', 'keeper'];
+
+const ROLE_FILES = {
+  weaver: 'meta/PHILOSOPHY_WEAVER.md',
+  visionary: 'roles/visionary.md',
+  architect: 'roles/architect.md',
+  forge: 'roles/forge.md',
+  keeper: 'roles/keeper.md',
+};
+
+const ROLE_PHILOSOPHY_FILES = {
+  visionary: ['PRODUCT_PHILOSOPHY.md', 'DECISION_RUBRIC.md'],
+  architect: ['ENGINEERING_CREED.md', 'DECISION_RUBRIC.md'],
+  forge: ['ENGINEERING_CREED.md'],
+  keeper: ['PRODUCT_PHILOSOPHY.md', 'DECISION_RUBRIC.md'],
+};
+
+const BASELINE_SUMMARY = [
+  '- B1：实质修改前理解真实结构，不创建平行体系。',
+  '- B2：秘密、环境值和可变配置不写死。',
+  '- B3：用户或系统可观察的行为具有显式契约。',
+  '- B4：重要且会影响未来的判断可追溯。',
+  '- B5：完成关联原始意图和当前 revision 证据；质量提升具有基线相对证据。',
+].join('\n');
+
+function section(title, body) {
+  const content = String(body || '').trim();
+  return `## ${title}\n\n${content || '无。'}`;
+}
+
+function readRole(role) {
+  const filePath = join(getLoomRoot(), ROLE_FILES[role]);
+  if (!existsSync(filePath)) throw new Error(`角色文件不存在: ${filePath}`);
+  return readFileSync(filePath, 'utf-8');
+}
+
+function getVerificationMethod(intent) {
+  return intent?.verification_method || intent?._optional?.verification_method || null;
+}
+
+function resolveContractReference(versionDir, value, label) {
+  if (!value) return null;
+  if (typeof value !== 'string') return JSON.stringify(value, null, 2);
+  const match = value.trim().match(/^(?:see\s+)?([^#]+)#([\w-]+)$/i);
+  if (!match) return value;
+  const [, file, anchor] = match;
+  if (file.includes('/') || file.includes('\\') || file !== '05_VERIFICATION.md') {
+    throw new Error(`${label}引用必须位于 05_VERIFICATION.md: ${value}`);
+  }
+  const filePath = join(versionDir, file);
+  if (!existsSync(filePath)) throw new Error(`${label}引用的文件不存在: ${filePath}`);
+  return extractMdSection(readFileSync(filePath, 'utf-8'), anchor, label);
+}
+
+function compileEnvelope(role, intentId) {
+  const scope = intentId ? `仅 ${intentId}` : '当前角色的项目阶段';
+  const lines = [
+    `- role: ${role}`,
+    `- scope: ${scope}`,
+    '- 本 Context Pack 不会清除现有会话记忆。',
+    '- system、developer 与用户指令优先；项目事实冲突时报告，不静默混用。',
+    '- 只在当前角色权限和明确作用域内行动。',
+  ];
+  if (role === 'keeper') {
+    lines.push('- Keeper 必须在新的 Agent thread 中运行；同一会话切换角色不构成独立验证。');
+    lines.push('- 无法获得独立上下文时降低声明，关键判断使用 pending_human。');
+  }
+  return lines.join('\n');
+}
+
+function compileObjective(role, versionDir, intentId) {
+  if (!intentId) {
+    return {
+      body: role === 'weaver'
+        ? '织造当前项目的 Project Doctrine。先读取真实项目与完整 BASELINE，不预写产品或架构。'
+        : `履行 ${role} 的当前项目阶段职责；未指定 Intent，不得自行选择并处理实现任务。`,
+      intent: null,
+      draft: null,
+      narrative: null,
+    };
+  }
+
+  if (role === 'visionary' || role === 'architect') {
+    const draft = getIntentDraft(versionDir, intentId);
+    const match = draft.narrative_ref.match(/^([^#]+)#([\w-]+)$/);
+    if (!match || match[1] !== '01_VISION.md') throw new Error(`draft narrative_ref 非法: ${draft.narrative_ref}`);
+    const narrative = extractMdSection(
+      readFileSync(join(versionDir, match[1]), 'utf-8'),
+      match[2],
+      'draft 意图叙事',
+    );
+    const visibleDraft = role === 'visionary'
+      ? {
+          id: draft.id,
+          revision: draft.revision,
+          title: draft.title,
+          narrative_ref: draft.narrative_ref,
+          depends_on: draft.depends_on,
+        }
+      : draft;
+    return {
+      body: [
+        '只处理下面这个 draft。不要修改官方 Intent Map，不要处理其他 Intent，不要自行 finalize。',
+        '',
+        '### Draft',
+        '',
+        '```json',
+        JSON.stringify(visibleDraft, null, 2),
+        '```',
+        '',
+        '### Narrative',
+        '',
+        narrative,
+      ].join('\n'),
+      intent: null,
+      draft,
+      narrative,
+    };
+  }
+
+  const intent = getIntent(versionDir, intentId);
+  const narrative = getNarrative(versionDir, intentId);
+  const objectiveView = {
+    id: intent.id,
+    revision: intent.revision,
+    title: intent.title,
+    status: intent.status,
+    narrative_ref: intent.narrative_ref,
+    depends_on: intent.depends_on,
+  };
+  return {
+    body: [
+      '只实现或验证下面这个官方 Intent。不得加载或顺便处理其他 Intent。',
+      '',
+      '### Intent',
+      '',
+      '```json',
+      JSON.stringify(objectiveView, null, 2),
+      '```',
+      '',
+      '### Narrative',
+      '',
+      narrative,
+    ].join('\n'),
+    intent,
+    draft: null,
+    narrative,
+  };
+}
+
+function compileInvariants(role, versionDir) {
+  const blocks = [];
+  const baselinePath = join(getLoomRoot(), 'meta/BASELINE.md');
+  blocks.push(role === 'weaver' ? readFileSync(baselinePath, 'utf-8') : BASELINE_SUMMARY);
+  if (versionDir) {
+    const projectBaseline = join(versionDir, '00_PHILOSOPHY', 'PROJECT_BASELINE.md');
+    if (existsSync(projectBaseline)) {
+      blocks.push(`### Project Baseline\n\n${readFileSync(projectBaseline, 'utf-8')}`);
+    }
+  }
+  return blocks.join('\n\n');
+}
+
+function compileContracts(role, versionDir, objective) {
+  const subject = objective.intent || objective.draft;
+  if (!subject || role === 'visionary') {
+    return role === 'visionary'
+      ? 'Visionary 只定义目标、非目标和 narrative；不要编写 acceptance 或架构。'
+      : '按当前角色 Output Contract 交付。';
+  }
+
+  const blocks = [];
+  if (subject.acceptance) {
+    const acceptance = objective.intent
+      ? getVerificationContract(versionDir, subject.id)
+      : resolveContractReference(versionDir, subject.acceptance, 'draft 完成契约');
+    blocks.push(`### Acceptance / Reliability Floor\n\n${acceptance}`);
+  }
+  if (subject.quality_contract) {
+    blocks.push(
+      `### Quality Contract / Distinctive Ceiling\n\n` +
+      resolveContractReference(versionDir, subject.quality_contract, '质量契约'),
+    );
+  }
+  const verificationMethod = getVerificationMethod(subject);
+  blocks.push(`### Verification Method\n\n${verificationMethod || '未声明：Keeper 使用适当的静态检查；需要运行时或人类判断却缺少入口时回流 Architect。'}`);
+  const continuity = subject.continuity_required
+    ? '此 Intent 已启用状态守恒门：通过前必须证明“旧状态 → 本轮操作 → 新状态”的完整序列中，未获明确授权删除或替换的既有价值、数据和可见结果仍被保留。'
+    : '默认不启用状态守恒门；若本 Intent 会变更既有用户数据、持久状态、迁移结果或既有工作流，Architect 必须把 continuity_required 设为 true，并在 acceptance 写出保留项与时序验证。';
+  blocks.push(
+    '### Completion Gate / Codex Goal Alignment\n\n' +
+    '将当前 Intent 视为本轮 Codex goal 的可闭合单元。goal 保持 active，直到结果达成、适用的状态守恒和可复现证据同时成立；goal/status 只是运行记录，不能替代验证证据。\n\n' +
+    continuity,
+  );
+  return blocks.join('\n\n');
+}
+
+function compileProjectJudgment(role, versionDir, objective) {
+  if (!versionDir || role === 'weaver') {
+    return role === 'weaver'
+      ? '从用户目标、仓库事实与决策相关证据建立 Project Doctrine。'
+      : '当前版本目录不可用。';
+  }
+
+  const philosophyDir = join(versionDir, '00_PHILOSOPHY');
+  const blocks = [];
+  const missing = [];
+  const anchors = (objective.intent || objective.draft)?.philosophy_anchors || [];
+
+  if (anchors.length > 0) {
+    for (const anchor of anchors) {
+      blocks.push(`### ${anchor}\n\n${getPhilosophy(philosophyDir, anchor)}`);
+    }
+  } else {
+    for (const file of ROLE_PHILOSOPHY_FILES[role] || []) {
+      const filePath = join(philosophyDir, file);
+      if (!existsSync(filePath)) {
+        missing.push(file);
+        continue;
+      }
+      blocks.push(`### ${file}\n\n${readFileSync(filePath, 'utf-8')}`);
+    }
+    if (missing.length) {
+      blocks.push(
+        `### Context Warning\n\n缺少: ${missing.join(', ')}。` +
+        '不要用通用偏好伪造项目判断；回流 Weaver 或向用户索取必要决定。',
+      );
+    }
+  }
+  return blocks.join('\n\n');
+}
+
+function compileExpertiseInputs(role, objective) {
+  const subject = objective.intent || objective.draft;
+  if (!subject || !['architect', 'forge', 'keeper'].includes(role)) {
+    return '当前阶段不编译任务级 Expertise Pack。';
+  }
+  const needs = Array.isArray(subject.capability_needs) ? subject.capability_needs : [];
+  const lines = [
+    `- capability_needs: ${needs.length ? needs.join(', ') : '未声明；按当前任务发现必要能力'}`,
+    `- creative_scope: ${subject.creative_scope || '未声明；遵循最小完整干预'}`,
+    '- Skill、工具和资产名称只代表可发现入口；实际检查并加载后才进入 Expertise Pack。',
+  ];
+  if (role === 'keeper') {
+    lines.push('- 不继承 Forge Expertise Pack；按契约独立准备验证能力。');
+  }
+  return lines.join('\n');
+}
+
+function compileWorkingFacts(versionDir, objective) {
+  if (!versionDir) return '检查当前仓库、用户输入和可用工具。';
+  const subject = objective.intent || objective.draft;
+  const refs = [
+    '- architecture: `.loom/.../02_ARCHITECTURE.md`（只读取与当前决定相关部分）',
+    '- artifacts: 从真实工作区检查，不从会话记忆猜测。',
+  ];
+  const systemId = subject?._optional?.system_id || subject?.system_id;
+  if (systemId) refs.push(`- system_id: ${systemId}`);
+  if (subject?.quality_contract) refs.push('- baseline: 声明相对提升时，修改前证据必须在实现前保存。');
+  return refs.join('\n');
+}
+
+/**
+ * Compile a role-scoped Context Pack.
+ * @param {string} role
+ * @param {string | null} versionDir
+ * @param {string | null} intentId
+ */
+export function activateRole(role, versionDir, intentId = null) {
+  if (!VALID_ROLES.includes(role)) {
+    throw new Error(`未知角色: ${role}\n合法角色: ${VALID_ROLES.join(', ')}`);
+  }
+  if (intentId && !versionDir) throw new Error('--intent 需要当前 LOOM 版本');
+  if (intentId && !['visionary', 'architect', 'forge', 'keeper'].includes(role)) {
+    throw new Error(`角色 ${role} 不支持 --intent；draft 用 visionary/architect，官方 Intent 用 forge/keeper`);
+  }
+
+  const objective = compileObjective(role, versionDir, intentId);
+  const parts = [
+    '# LOOM Context Pack',
+    section('1. Execution Envelope', compileEnvelope(role, intentId)),
+    section('2. Active Objective', objective.body),
+    section('3. Hard Invariants', compileInvariants(role, versionDir)),
+    section('4. Success Contracts', compileContracts(role, versionDir, objective)),
+    section('5. Project Judgment', compileProjectJudgment(role, versionDir, objective)),
+    section('6. Expertise Inputs', compileExpertiseInputs(role, objective)),
+    section('7. Working Facts', compileWorkingFacts(versionDir, objective)),
+    section('8. Role Contract / Output / Reflow / Stop', readRole(role)),
+  ];
+  return `${parts.join('\n\n---\n\n')}\n`;
+}

package/cli/src/diagnostics.js

@@ -3,10 +3,14 @@
 // 全部是只读的数据聚合，不做决策、不修改文件。
 
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { basename, dirname, 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';
+import { getPhilosophy, validateInspirationSources } from './philosophy.js';
+import { getVerificationHistory, getPendingVerifications, getVerificationContract, getLatestPassedVerification, getVerificationIntentRevision, isVerificationCurrent, hasCurrentPassedVerification } from './verify.js';
+import { validatePatches } from './patch.js';
+import { formatIntentRef } from './shared/intent-ref.js';
+import { commandCoversVerificationMethod, getIntentVerificationMethod } from './shared/verification-method.js';
+import { resolveQualityProofReference } from './shared/proof-reference.js';
 
 function readIntentMapRaw(versionDir) {
   const filePath = join(versionDir, '04_INTENT_MAP.json');
@@ -75,10 +79,6 @@ function intentMapDiagnostics(versionDir) {
   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, '')
@@ -143,7 +143,8 @@ const FIX_HINTS = {
   intent_map_missing: '运行 loom init 或 loom activate architect 产出 04_INTENT_MAP.json',
   intent_map_template: '运行 loom activate architect，Architect 填充真实 Intent Map 后删除 _meta._template 标记',
   intent_map_invalid: '按报错信息修正 04_INTENT_MAP.json 里对应字段（补 title / 加长 acceptance / 填必填字段）',
-  completed_no_record: '在 .loom/v{N}/verifications/ 下补验证记录，或运行 loom verify pass {id} --summary "..."',
+  completed_no_record: '在 .loom/v{N}/verifications/ 下补验证记录，或运行 loom verify pass {id} --summary "..."',
+  completed_verification_not_passed: '最新验证不是当前 revision 的 passed；重新运行 loom verify pass {id} --summary "..."，再用 loom intent done {id} 闭合。',
   in_progress_no_record: '运行 loom verify pass {id} --summary "..." 写入验证记录，或 loom intent update {id} --status pending 回退',
   orphan_philosophy_ref: '检查 04_INTENT_MAP.json 里 {id} 的 philosophy_anchors，移除或修正不存在的哲学文件引用',
   orphan_dependency: '检查 04_INTENT_MAP.json 里 {id} 的 depends_on，移除或修正不存在的 Intent ID',
@@ -152,9 +153,14 @@ const FIX_HINTS = {
   completed_depends_blocked: '检查依赖 {dep} 为什么 blocked——解决阻塞或把 {id} 回退到 in_progress',
   test_script_missing: '在 package.json 里加 test 脚本，或修正 verification_method 指向实际存在的测试命令',
   verification_method_unverified: '运行 loom verify pass {id} --summary "..." --reproduction-command "..." 覆盖声明的验证方式',
-  verification_method_drift: '验证记录的 reproduction_command 要覆盖 verification_method 声明的命令（支持 npm/pnpm/bun 互相等价）',
-  inspiration_source: '在哲学文档的"灵感来源"章节填入至少 3 个源（- **源名** — 理由。来源：URL 或 file:// 或 local:./path）',
-  part_decomposition: '在哲学文档加"实现部分清单"章节，按 PART_DECOMPOSITION.md 拆解实现部分（- **部分名** 格式）',
+  verification_method_drift: '验证记录的 reproduction_command 要覆盖 verification_method 声明的命令（支持 npm/pnpm/bun 互相等价）',
+  stale_verification: '重新验证当前 Intent revision：loom verify pass {id} --summary "..."，通过后再闭合 Intent',
+  inspiration_source: '在哲学文档的"证据地图/灵感来源"中写入实际使用的来源、选择理由和可追溯位置；数量由判断所需决定',
+  quality_dimension_missing: '为带 quality_contract 的 Intent 补写并通过 quality_achievement；相对提升声明在该维度中链接 Quality Proof',
+  quality_proof_invalid: '将 quality_proof_ref 改为项目内真实存在且含锚点的 Markdown 证据，例如 verifications/INT-001-quality-proof.md#int-001',
+  preservation_dimension_missing: '为 continuity_required 的 Intent 补写并通过 preservation_achievement，证据必须覆盖旧状态到新操作后的完整序列',
+  patch_changelog_invalid: '运行 loom patch validate 查看具体错误；修正 06_CHANGELOG.json 后重新生成 Markdown 投影',
+  patch_projection_drift: '不要手工编辑 06_CHANGELOG.md；重新运行 loom init 或下一次 loom patch record 生成投影',
 };
 
 /**
@@ -192,16 +198,49 @@ export function doctor(versionDir, verificationsDir, philosophyDir) {
 
   const { intents } = mapState.validMap;
 
-  // 1. 状态一致性：in_progress/completed 但无验证记录
-  for (const [id, intent] of Object.entries(intents)) {
-    const hasRecord = existsSync(join(verificationsDir, `${id}.json`));
-    if (intent.status === 'completed' && !hasRecord) {
-      issues.push({ id, type: 'completed_no_record', severity: 'high', msg: `${id} 状态为 completed 但无验证记录` });
-    }
-    if (intent.status === 'in_progress' && !hasRecord) {
-      issues.push({ id, type: 'in_progress_no_record', severity: 'medium', msg: `${id} 状态为 in_progress 但无验证记录（可能上次中断）` });
-    }
-  }
+  // 1. 状态一致性：completed 必须由当前 revision 的最后一条 passed 验证支撑。
+  for (const [id, intent] of Object.entries(intents)) {
+    const history = getVerificationHistory(verificationsDir, id);
+    const hasRecord = Boolean(history?.records?.length);
+    const latest = history?.records?.[history.records.length - 1];
+    if (intent.status === 'completed' && !hasRecord) {
+      issues.push({ id, type: 'completed_no_record', severity: 'high', msg: `${id} 状态为 completed 但无验证记录` });
+    } else if (intent.status === 'completed' && !hasCurrentPassedVerification(intent, history)) {
+      issues.push({ id, type: 'completed_verification_not_passed', severity: 'high', msg: `${id} 状态为 completed，但最后一条验证不是当前 revision 的 passed` });
+    }
+    if (intent.status === 'in_progress' && !hasRecord) {
+      issues.push({ id, type: 'in_progress_no_record', severity: 'medium', msg: `${id} 状态为 in_progress 但无验证记录（可能上次中断）` });
+    }
+    if (intent.quality_contract && latest?.verdict === 'passed') {
+      const quality = latest.dimensions?.quality_achievement;
+      if (!quality || quality.verdict !== 'passed') {
+        issues.push({
+          id,
+          type: 'quality_dimension_missing',
+          severity: 'high',
+          msg: `${id} 声明了 quality_contract，但最新 passed 记录缺少通过的 quality_achievement`,
+        });
+      }
+      if (quality?.quality_proof_ref) {
+        try {
+          resolveQualityProofReference(versionDir, quality.quality_proof_ref);
+        } catch (error) {
+          issues.push({ id, type: 'quality_proof_invalid', severity: 'high', msg: `${id} 的 Quality Proof 无效: ${error.message}` });
+        }
+      }
+    }
+    if (intent.continuity_required && latest?.verdict === 'passed') {
+      const preservation = latest.dimensions?.preservation_achievement;
+      if (!preservation || preservation.verdict !== 'passed') {
+        issues.push({
+          id,
+          type: 'preservation_dimension_missing',
+          severity: 'high',
+          msg: `${id} 声明了 continuity_required，但最新 passed 记录缺少通过的 preservation_achievement`,
+        });
+      }
+    }
+  }
 
   // 2. 孤儿引用：哲学锚点指向不存在的文件
   for (const [id, intent] of Object.entries(intents)) {
@@ -312,12 +351,42 @@ export function doctor(versionDir, verificationsDir, philosophyDir) {
       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)) {
+    } else if (!commandCoversVerificationMethod(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);
+  const patchJsonPath = join(versionDir, '06_CHANGELOG.json');
+  if (existsSync(patchJsonPath)) {
+    try {
+      validatePatches(versionDir);
+    } catch (error) {
+      const projectionDrift = String(error.message).includes('最新确定性投影') || String(error.message).includes('Markdown 投影不存在');
+      issues.push({
+        id: 'patch_changelog',
+        type: projectionDrift ? 'patch_projection_drift' : 'patch_changelog_invalid',
+        severity: projectionDrift ? 'medium' : 'high',
+        msg: error.message,
+      });
+    }
+  }
+
+  // completed/needs_review 的旧 revision 验证不能证明当前 Intent 仍然成立。
+  for (const [id, intent] of Object.entries(intents)) {
+    if (intent.status !== 'completed' && intent.status !== 'needs_review') continue;
+    const history = getVerificationHistory(verificationsDir, id);
+    const latestPassed = getLatestPassedVerification(history);
+    if (!latestPassed || isVerificationCurrent(intent, latestPassed)) continue;
+    const verifiedRevision = getVerificationIntentRevision(intent, latestPassed);
+    issues.push({
+      id,
+      type: 'stale_verification',
+      severity: 'high',
+      msg: `${id} 最新 passed 验证 revision ${verifiedRevision ?? 'legacy/unknown'} 早于当前 Intent revision ${intent.revision ?? 1}`,
+    });
+  }
+
+  appendPhilosophyDiagnostics(issues, philosophyDir);
   const issuesWithHints = issues.map(addFixHint);
   return { issues: issuesWithHints, summary: summarizeIssues(issuesWithHints) };
 }
@@ -331,11 +400,6 @@ function appendPhilosophyDiagnostics(issues, philosophyDir) {
     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) {
@@ -403,7 +467,7 @@ export function contextSummary(versionDir, verificationsDir, philosophyDir) {
   const { issues } = doctor(versionDir, verificationsDir, philosophyDir);
 
   // 区分模板阶段问题（待填充）和真实损坏
-  const templateIssues = issues.filter((i) => i.is_template || i.type === 'intent_map_template' || i.type === 'inspiration_source' || i.type === 'part_decomposition');
+  const templateIssues = issues.filter((i) => i.is_template || i.type === 'intent_map_template' || i.type === 'inspiration_source');
   const realIssues = issues.filter((i) => !templateIssues.includes(i));
 
   const risks = [];
@@ -416,11 +480,12 @@ export function contextSummary(versionDir, verificationsDir, philosophyDir) {
 
   return {
     intent_map_valid: mapState.valid === true,
-    progress: {
+    progress: {
       completed: status.counts.completed,
       total: status.counts.total,
-      rate: `${status.counts.completed}/${status.counts.total}`,
-    },
+      rate: `${status.counts.completed}/${status.counts.total}`,
+    },
+    deprecated_intents: status.deprecated || [],
     next_intent: next ? next.id : null,
     pending_verifications: pending,
     inconsistent_states: issues.filter((i) => i.type === 'in_progress_no_record' || i.type === 'completed_no_record').map((i) => i.id),
@@ -440,7 +505,7 @@ export function contextSummary(versionDir, verificationsDir, philosophyDir) {
  * @param {string} intentId
  * @returns {object}
  */
-export function traceIntent(versionDir, verificationsDir, philosophyDir, intentId) {
+export function traceIntent(versionDir, verificationsDir, philosophyDir, intentId) {
   const intent = getIntent(versionDir, intentId);
   if (!intent) throw new Error(`Intent 不存在: ${intentId}`);
 
@@ -482,19 +547,51 @@ export function traceIntent(versionDir, verificationsDir, philosophyDir, intentI
       walkDeps(dep, depth + 1);
     }
   }
-  walkDeps(intentId, 0);
-
-  return {
-    intent,
+  walkDeps(intentId, 0);
+
+  const version = basename(versionDir);
+  const ref = formatIntentRef(version, intentId);
+  const loomRoot = dirname(versionDir);
+  const predecessors = (intent.lineage?.predecessors || []).map((item) => {
+    let revision = null;
+    try { revision = getIntent(join(loomRoot, item.version), item.intent_id).revision ?? 1; }
+    catch { /* Validation is structural; a referenced version may not be locally available. */ }
+    return { ...item, ref: formatIntentRef(item.version, item.intent_id), revision };
+  });
+  const successors = [];
+  for (const candidateVersion of readdirSync(loomRoot).filter((name) => /^v\d+$/.test(name))) {
+    const candidateDir = join(loomRoot, candidateVersion);
+    if (!statSync(candidateDir).isDirectory() || !existsSync(join(candidateDir, '04_INTENT_MAP.json'))) continue;
+    let candidateMap;
+    try { candidateMap = loadIntentMap(candidateDir); }
+    catch { continue; }
+    for (const [candidateId, candidate] of Object.entries(candidateMap.intents)) {
+      if (candidate.lineage?.predecessors?.some((item) => item.version === version && item.intent_id === intentId)) {
+        successors.push({
+          ref: formatIntentRef(candidateVersion, candidateId),
+          version: candidateVersion,
+          intent_id: candidateId,
+          revision: candidate.revision ?? 1,
+        });
+      }
+    }
+  }
+
+  return {
+    ref,
+    version,
+    revision: intent.revision ?? 1,
+    intent,
     narrative,
     narrative_error: narrativeError,
     acceptance,
     acceptance_error: acceptanceError,
     verification_history: verificationHistory,
-    philosophy_anchors_content: philosophyContent,
-    dependency_chain: dependencyChain,
-  };
-}
+    philosophy_anchors_content: philosophyContent,
+    dependency_chain: dependencyChain,
+    lineage: { predecessors, successors },
+  };
+}
 
 // ─── reverse-dep ───────────────────────────────────────
 // 反向依赖：哪些 Intent 依赖这个 Intent