@cloud411716/fancy-webnovel 2.2.0 → 3.0.3

package/plugins/fancy-story-builder/scripts/graph-utils.js

@@ -183,7 +183,10 @@ export const RELATION_KIND_META = {
   '对立': { direction: 'symmetric', group: 'attitude' },
   '敌对': { direction: 'symmetric', group: 'attitude' },
   '竞争': { direction: 'symmetric', group: 'attitude' },
-  '中立': { direction: 'symmetric', group: 'attitude' }
+  '中立': { direction: 'symmetric', group: 'attitude' },
+  // 扩展出口：具体语义由 relation_label 说明（附身/寄生/契约/共生…）。
+  // 单列为 other 维度，避免和既有立场关系互斥。
+  '其他': { direction: 'directed', group: 'other' }
 };
 
 // 有向关系：同一对角色上双向互指同一个值即自相矛盾（互相服从/互相提携/互为师徒）
@@ -401,9 +404,18 @@ export const FIELD_CN = {
   // 通用（跨阶段通用）
   id: 'ID', name: '名称', description: '描述', type: '类型', notes: '备注', meta: '元数据',
   kind: '种类', level: '层级', scale: '范围', pattern: '正则',
-  // 选题输入（input_snapshot）
-  book_name: '书名', genre: '题材', core_summary: '一句话故事', core_conflict: '核心冲突',
+  // 选题输入（input_snapshot）—— 字段清单与 fancy-topic 同源
+  // （本文件会被复制到项目 references/ 下独立运行，不能 import #topic-fields；
+  //   字段清单的漂移由 topic-direction 用例里的渲染断言兜住。）
+  book_name: '书名', genre: '题材', target_words: '目标字数', target_chapters: '目标章节',
+  positioning: '一句话定位', direction_title: '选题方向', core_conflict: '核心冲突',
   hard_constraints: '硬门禁', anti_tropes: '反套路',
+  reader_value: '读者与情绪价值', golden_finger: '金手指', core_setting: '核心设定',
+  payoff_model: '爽点模式', emotion_curve: '情绪价值曲线', opening_hook: '开篇切入点',
+  pacing_plan: '节奏规划', character_design: '人物设定', differentiation: '差异化策略',
+  risk_validation: '风险与验证',
+  // 旧版字段（读旧骨架产物时仍能显示中文名）
+  core_summary: '一句话故事', direction_design: '方向设计',
   // 容量（capacity）
   target_chapters: '目标章节', target_words: '目标字数', avg_words_per_chapter: '平均每章字数',
   // 角色数量（character_counts）
@@ -597,10 +609,18 @@ export const FIELD_CN = {
   stance: '立场', personality_tone: '性格基调', relationship_stage_tone: '关系阶段语气',
   mirror_type: '镜像类型', stage: '阶段', personality: '性格',
   presentation_method: '呈现方式',
+  // 题材扩展 / 关系阶段
+  traits: '独有特征', extensions: '题材扩展', other_entities: '其他实体',
+  other_relations: '其他关系', relation_label: '关系标签',
+  relationship_timeline: '关系阶段时序', state: '关系状态', trigger: '触发事件',
+  trigger_event: '触发事件', timing: '时间位置', abilities: '能力', limits: '限制',
+  start_chapter: '阶段开始章', end_chapter: '阶段结束章',
   // 骨架 · 层级
   volumes: '卷列表',
   // 节奏 · 时序映射
-  character_timeline: '角色时序', conflict_timeline: '冲突时序',
+  character_timeline: '角色时序', relationship_timeline: '关系阶段时序',
+  faction_relationship_timeline: '势力关系时序',
+  other_entities: '其他实体', other_relations: '其他关系', conflict_timeline: '冲突时序',
   foreshadow_timeline: '伏笔时序', climax_timeline: '高潮时序',
   pleasure_timeline: '爽点时序', hook_timeline: '钩子时序',
   main_line_timeline: '主线时序', branch_timeline: '支线时序',
@@ -616,7 +636,14 @@ export const FIELD_CN = {
   faction_relations: '势力关系',
   function_detail: '功能详情',      // 旧键名 functional_detail
   info_gaps: '信息差',              // 旧键名 information_gaps
-  related_conflicts: '涉及冲突'     // 旧键名 related_conflict
+  related_conflicts: '涉及冲突',    // 旧键名 related_conflict
+  // 新档案/每章细纲字段（wiki 正文渲染用）
+  title: '标题', status: '状态', pov: '视角', pov_name: '视角人物', relationship_type: '关系类型',
+  elements: '要素', how_to_write: '写作方法', must_write: '必须写',
+  must_not_write: '绝对不能写', information_boundaries: '信息边界',
+  timeline_events: '时间线事件', hooks: '钩子', cast: '出场角色',
+  foreshadow_actions: '伏笔动作', participants: '参与方',
+  participant_names: '参与方名称', mandatory: '必须满足', forbidden: '禁止内容'
 };
 
 // 上下文相关的 key→label（不同父 key 同一字段名有不同语义）
@@ -918,6 +945,7 @@ export function renderArray(arr, indent, parentKey, indexOffset = 0) {
 // （历史缺陷：势力的 faction_relations 并不存在；世界观规则漏了 rule_conflict_plan。）
 export const FLESH_DISPATCH = {
   '角色': ['characters'],
+  '其他实体': ['other_entities'],
   '冲突': ['conflicts'],
   '势力': ['factions'],
   '剧情': ['main_lines', 'branches'],
@@ -934,7 +962,7 @@ export const FLESH_DISPATCH = {
 export const RHYTHM_DISPATCH = {
   '章节规划': ['chapters'],
   '节奏参数': [],
-  '时序映射': ['character_timeline', 'conflict_timeline', 'foreshadow_timeline',
+  '时序映射': ['character_timeline', 'relationship_timeline', 'faction_relationship_timeline', 'conflict_timeline', 'foreshadow_timeline',
               'climax_timeline', 'pleasure_timeline', 'hook_timeline',
               'main_line_timeline', 'branch_timeline', 'location_timeline',
               'item_timeline', 'ending_timeline'],
@@ -950,7 +978,10 @@ const ARR_CN = {
   core_items: '核心道具', branch_items: '支线道具', symbolic_items: '象征道具', details: '道具详情',
   chapters: '章节数组', metrics: '节奏指标', feasibility: '可行性约束', coverage: '覆盖校验',
   outlines: '章节细纲',
-  character_timeline: '角色时序', conflict_timeline: '冲突时序',
+  other_entities: '其他实体', other_relations: '其他关系', relationship_timeline: '关系阶段时序',
+  character_timeline: '角色时序', relationship_timeline: '关系阶段时序',
+  faction_relationship_timeline: '势力关系时序',
+  other_entities: '其他实体', other_relations: '其他关系', conflict_timeline: '冲突时序',
   foreshadow_timeline: '伏笔时序', climax_timeline: '高潮时序',
   pleasure_timeline: '爽点时序', hook_timeline: '钩子时序',
   main_line_timeline: '主线时序', branch_timeline: '支线时序',
@@ -1012,6 +1043,7 @@ export function summarizeStage(stageDir) {
     '关系': ['关系.json'],
     '层级': ['层级.json'],
     '角色': ['角色.json'],
+    '其他实体': ['其他实体.json'],
     '冲突': ['冲突.json'],
     '势力': ['势力.json'],
     '剧情': ['剧情.json'],
@@ -1141,6 +1173,78 @@ export function summarizeRhythm(rhythmDir) {
  * 返回 null 表示"骨架还没产出框架.json 或没有 input_snapshot"，
  * 调用方需要自己决定兜底策略（不能静默当成空输入）。
  */
+const INPUT_RENDER_FIELDS = [
+  ['book_name', '书名', 'text'],
+  ['genre', '题材', 'text'],
+  ['target_words', '目标字数', 'text'],
+  ['target_chapters', '目标章节', 'text'],
+  ['direction_title', '选题方向', 'text'],
+  ['positioning', '一句话定位', 'design'],
+  ['core_conflict', '核心冲突', 'text'],
+  ['hard_constraints', '硬门禁', 'list'],
+  ['anti_tropes', '反套路', 'list'],
+  ['reader_value', '读者与情绪价值', 'design'],
+  ['golden_finger', '金手指', 'design'],
+  ['core_setting', '核心设定', 'design'],
+  ['payoff_model', '爽点模式', 'design'],
+  ['emotion_curve', '情绪价值曲线', 'design'],
+  ['opening_hook', '开篇切入点', 'design'],
+  ['pacing_plan', '节奏规划', 'design'],
+  ['character_design', '人物设定', 'design'],
+  ['differentiation', '差异化策略', 'design'],
+  ['risk_validation', '风险与验证', 'design'],
+];
+
+/** 旧版 direction_design 标签 → 新字段 ID（本文件要独立运行，不能 import） */
+const LEGACY_DESIGN_LABELS = [
+  ['定位', 'positioning'],
+  ['读者与情绪价值', 'reader_value'],
+  ['金手指', 'golden_finger'],
+  ['核心设定', 'core_setting'],
+  ['爽点模式', 'payoff_model'],
+  ['情绪价值曲线', 'emotion_curve'],
+  ['开篇切入点', 'opening_hook'],
+  ['节奏规划', 'pacing_plan'],
+  ['人物设定', 'character_design'],
+  ['差异化策略', 'differentiation'],
+  ['风险与验证', 'risk_validation'],
+];
+
+function escapeRegExp(text) {
+  return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * 本文件会被复制到项目 references/ 下独立执行，不能依赖包的 import alias。
+ * 这里保留一份最小的旧格式迁移逻辑；字段清单的漂移由用例里的渲染断言兜住。
+ */
+function normalizeLegacyTopicData(data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return data;
+  const out = { ...data };
+  if (typeof out.direction_design === 'string' && out.direction_design.trim()) {
+    for (const [label, id] of LEGACY_DESIGN_LABELS) {
+      if (typeof out[id] === 'string' && out[id].trim()) continue;
+      const re = new RegExp('^\\s*(?:[-*+]\\s+)?\\*{0,2}' + escapeRegExp(label)
+        + '\\*{0,2}\\s*[:：]\\s*(.*)$', 'm');
+      const hit = re.exec(out.direction_design);
+      if (hit && hit[1].trim()) out[id] = hit[1].trim();
+    }
+  }
+  if ((!out.positioning || !String(out.positioning).trim())
+    && typeof out.core_summary === 'string' && out.core_summary.trim()) {
+    out.positioning = out.core_summary;
+  }
+  delete out.direction_design;
+  delete out.core_summary;
+  return out;
+}
+
+/**
+ * 读取骨架阶段的 input_snapshot（任务输入快照）。
+ *
+ * 返回 null 表示"骨架还没产出框架.json 或没有 input_snapshot"，
+ * 调用方需要自己决定兜底策略（不能静默当成空输入）。
+ */
 export function readInputSnapshot(skeletonDir) {
   const p = _join(skeletonDir, '框架.json');
   if (!_existsSync(p)) return null;
@@ -1151,63 +1255,58 @@ export function readInputSnapshot(skeletonDir) {
     return null;
   }
   if (!data || typeof data !== 'object') return null;
-  const snap = data.input_snapshot;
-  if (!snap || typeof snap !== 'object' || Array.isArray(snap)) return null;
+  const rawSnap = data.input_snapshot;
+  if (!rawSnap || typeof rawSnap !== 'object' || Array.isArray(rawSnap)) return null;
+  const snap = normalizeLegacyTopicData(rawSnap);
   const cap = (data.capacity && typeof data.capacity === 'object') ? data.capacity : {};
-  return {
-    book_name: snap.book_name,
-    genre: snap.genre,
-    core_summary: snap.core_summary,
-    core_conflict: snap.core_conflict,
-    hard_constraints: Array.isArray(snap.hard_constraints) ? snap.hard_constraints : [],
-    anti_tropes: Array.isArray(snap.anti_tropes) ? snap.anti_tropes : [],
-    target_chapters: cap.target_chapters,
-    target_words: cap.target_words
-  };
-}
 
-// 任务输入里各字段的中文名（渲染成提示词里的清单）
-const INPUT_FIELD_CN = {
-  book_name: '书名', genre: '题材', core_summary: '一句话故事', core_conflict: '核心冲突',
-  target_chapters: '目标章节', target_words: '目标字数'
-};
-// 列表型字段（渲染成编号清单）
-const INPUT_LIST_CN = {
-  hard_constraints: '硬门禁',
-  anti_tropes: '反套路'
-};
+  const out = {};
+  for (const [id] of INPUT_RENDER_FIELDS) out[id] = snap[id];
+  if (cap.target_chapters !== undefined) out.target_chapters = cap.target_chapters;
+  if (cap.target_words !== undefined) out.target_words = cap.target_words;
+  for (const key of ['hard_constraints', 'anti_tropes']) {
+    out[key] = Array.isArray(out[key]) ? out[key] : [];
+  }
+  return out;
+}
 
 /**
  * 把任务输入快照渲染成提示词里的一节 markdown。
  *
  * 输出形如：
  *   - 书名：XXX
- *   - 题材：XXX
- *   - 目标章节：800
- *   - 目标字数：2400000
- *   - 一句话故事：XXX
- *   - 核心冲突：XXX
+ *   - 一句话定位：
+ *     以家族为经营单元的长线修仙群像文……
+ *   - 金手指：
+ *     铜镜式家族传承……
  *   - 硬门禁：
  *     1. ...
- *   - 反套路：
- *     1. ...
  */
 export function renderInputSnapshot(snapshot) {
   if (!snapshot || typeof snapshot !== 'object') return '_(任务输入快照缺失)_\n';
+  const snap = normalizeLegacyTopicData(snapshot);
   const lines = [];
-  for (const [k, label] of Object.entries(INPUT_FIELD_CN)) {
-    const v = snapshot[k];
+  for (const [id, label, type] of INPUT_RENDER_FIELDS) {
+    const v = snap[id];
     if (v === undefined || v === null || v === '') continue;
+    if (type === 'list') {
+      if (!Array.isArray(v) || v.length === 0) continue;
+      lines.push('- ' + label + '：');
+      v.forEach((item, i) => {
+        lines.push('  ' + (i + 1) + '. ' + String(item).replace(/\n/g, ' '));
+      });
+      continue;
+    }
+    if (type === 'design') {
+      lines.push('- ' + label + '：');
+      String(v).split(/\r?\n/).forEach((ln) => {
+        if (ln.trim() === '') return;
+        lines.push('  ' + ln.trim());
+      });
+      continue;
+    }
     lines.push('- ' + label + '：' + String(v).replace(/\n/g, ' '));
   }
-  for (const [k, label] of Object.entries(INPUT_LIST_CN)) {
-    const v = snapshot[k];
-    if (!Array.isArray(v) || v.length === 0) continue;
-    lines.push('- ' + label + '：');
-    v.forEach((item, i) => {
-      lines.push('  ' + (i + 1) + '. ' + String(item).replace(/\n/g, ' '));
-    });
-  }
   return lines.length ? lines.join('\n') + '\n' : '_(任务输入快照为空)_\n';
 }
 

package/plugins/fancy-story-builder/scripts/reference-log.js

@@ -0,0 +1,110 @@
+/**
+ * reference-log.js —— 参考决策台账
+ *
+ * 目的：LLM 每做一个会进入产物的设计决策，都要留下“依据了哪份参考、
+ * 具体哪一条、为什么这么用”的可追溯记录。
+ *
+ * 文件放在 `设定/.reference-decisions.md`：
+ *   - 不属于阶段产物，不参与 schema/ingest；
+ *   - 人类可读的 Markdown 表格；
+ *   - 只追加，不覆盖已有行。
+ *
+ * 这里只负责初始化、计数和生成提示词块；真正的“读取参考并做决策”
+ * 由 LLM 执行。插件在阶段收尾时把行数报给用户，缺失时给出警告。
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const REFERENCE_LOG_PATH = '设定/.reference-decisions.md';
+export const REFERENCE_LOG_COLUMNS = ['阶段', '批次', '决策对象', '决策内容', '参考文件', '参考条目', '备注'];
+
+export const REFERENCE_LOG_HEADER = [
+  '# 参考决策记录',
+  '',
+  '> 本文件由 LLM 在每次设计决策后追加。只追加，不覆盖。',
+  '> 参考文件可以是 `references` 目录下的方法论，也可以是 `对标/wiki/` 下的总结。',
+  '',
+  '| ' + REFERENCE_LOG_COLUMNS.join(' | ') + ' |',
+  '|' + REFERENCE_LOG_COLUMNS.map(() => '---').join('|') + '|',
+  '',
+].join('\n');
+
+/** 确保 `设定/.reference-decisions.md` 存在；不覆盖已有内容。 */
+export function ensureReferenceDecisionLog(projectRoot) {
+  if (!projectRoot) return false;
+  const dir = join(projectRoot, '设定');
+  if (!existsSync(dir)) return false;
+  const file = join(projectRoot, REFERENCE_LOG_PATH);
+  if (existsSync(file)) return true;
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(file, REFERENCE_LOG_HEADER, { encoding: 'utf-8', flag: 'wx' });
+    return true;
+  } catch {
+    // 并发创建时另一个批次可能已经写了；文件存在就算成功。
+    return existsSync(file);
+  }
+}
+
+/** 解析参考决策台账里的数据行。 */
+export function parseReferenceDecisionRows(projectRoot) {
+  const file = join(projectRoot, REFERENCE_LOG_PATH);
+  if (!existsSync(file)) return [];
+  let text = '';
+  try { text = readFileSync(file, 'utf-8'); } catch { return []; }
+  const rows = [];
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|')) continue;
+    if (/^\|\s*---/.test(trimmed)) continue;
+    if (trimmed.startsWith('| ' + REFERENCE_LOG_COLUMNS[0] + ' |')) continue;
+    const cells = trimmed.replace(/^\|/, '').replace(/\|$/, '').split('|').map((x) => x.trim());
+    if (cells.length < REFERENCE_LOG_COLUMNS.length) continue;
+    rows.push(Object.fromEntries(REFERENCE_LOG_COLUMNS.map((c, i) => [c, cells[i] || ''])));
+  }
+  return rows;
+}
+
+export function countReferenceDecisionRows(projectRoot) {
+  return parseReferenceDecisionRows(projectRoot).length;
+}
+
+/** 阶段收尾提示：把台账行数报给用户，空台账必须显眼。 */
+export function referenceLogNote(projectRoot) {
+  const count = countReferenceDecisionRows(projectRoot);
+  if (count > 0) {
+    return '📚 参考决策记录：' + count + ' 条（' + REFERENCE_LOG_PATH + '）';
+  }
+  return '⚠️ 参考决策记录为空：本次 LLM 没有按契约把“决策依据了哪份参考”写入 `' +
+    REFERENCE_LOG_PATH + '`。';
+}
+
+/**
+ * 批次提示词里的强制记录块。
+ *
+ * 这里不把“参考文件”限死在 对标/wiki：方法论 references 目录也是参考。
+ */
+export function referenceLogPromptBlock(stageLabel, batch, options = {}) {
+  const batchName = (batch && (batch.type || batch.groupKey || batch.file)) || '本批';
+  const allowed = options.allowedFileText || ('除本批分片外，`' + REFERENCE_LOG_PATH + '` 是本批唯一允许写的额外文件；不要修改 wiki、模板、references 目录或其它阶段。');
+  return [
+    '## 参考决策记录（必须）',
+    '',
+    '本批开始前必须实际读取本批参考清单中的 `references` 目录指导文档和 `对标/wiki` 目录总结；',
+    '插件注入的摘要只用于快速定位，**不能替代原文件**。本批列出的“本批优先参考”必须逐份核对；阶段级清单用于全局判断，不要求逐篇通读。',
+    '',
+    '每完成一个会进入产物的独立设计决策，就要向 `' + REFERENCE_LOG_PATH + '` 追加一行：',
+    '',
+    '| 阶段 | 批次 | 决策对象 | 决策内容 | 参考文件 | 参考条目 | 备注 |',
+    '|---|---|---|---|---|---|---|',
+    '| ' + stageLabel + ' | ' + batchName + ' | 例如 FS004 | 例如 设计“反向验证”式伏笔 | 例如 对标/wiki 下的伏笔布局总结 | 例如 用反向验证排除“整体替换”式解释 | 例如 让读者先看到结果再反推原因 |',
+    '',
+    '记录规则：',
+    '1. **每个独立决策至少一行**：每个实体、每条关系、每个伏笔/爽点/冲突节点、每章规划、每章细纲、每章正文都算独立决策；同一对象的多个字段如果依据不同参考，拆成多行。',
+    '2. `参考文件` 必须写实际读过的路径；`参考条目` 必须写原文里的标题/原则名，不能只写文件名；原文有“来源章节 / 来源实体”时，把对应章节或实体一并写进 `参考条目`。',
+    '3. `备注` 写清“为什么用、怎么用、哪些地方没有采用”，不要写“参考了”。',
+    '4. **只追加数据行**，不要重复写表头，不要覆盖或删除已有行；备注里的 `|` 写成 `\\|`。',
+    '5. ' + allowed,
+    '',
+  ].join('\n');
+}

package/plugins/fancy-story-builder/scripts/rhythm-validate.js

@@ -240,7 +240,9 @@ const TIMELINE_KEY_FIELD = {
   branch_timeline: 'branch_id',
   location_timeline: 'loc_id',
   item_timeline: 'item_id',
-  ending_timeline: 'ending_id'
+  ending_timeline: 'ending_id',
+  relationship_timeline: 'from',
+  faction_relationship_timeline: 'from'
 };
 
 /**
@@ -390,7 +392,7 @@ function buildIdSets(skeleton, flesh) {
 // ============================================================
 // 时序映射完整性
 // ============================================================
-function checkTimelineIntegrity(timeline, idSets, errors) {
+function checkTimelineIntegrity(timeline, idSets, errors, flesh) {
   const check = (id, set, label, p) => {
     if (!id) return;
     if (!set.has(id)) {
@@ -398,6 +400,100 @@ function checkTimelineIntegrity(timeline, idSets, errors) {
     }
   };
 
+
+  // 角色关系的阶段变化：同一对角色按 start_chapter 递增，且不能倒回上一阶段。
+  const relationRows = timeline.relationship_timeline || [];
+  const relationByPair = new Map();
+  for (const [i, r] of relationRows.entries()) {
+    check(r.from, idSets.char, '角色', 'relationship_timeline[' + i + '].from');
+    check(r.to, idSets.char, '角色', 'relationship_timeline[' + i + '].to');
+    if (typeof r.start_chapter === 'number' && typeof r.end_chapter === 'number' && r.start_chapter > r.end_chapter) {
+      errors.push({
+        code: 'RHYTHM_CHAP_ORDER',
+        path: 'relationship_timeline[' + i + ']',
+        message: '关系阶段 start_chapter(' + r.start_chapter + ') > end_chapter(' + r.end_chapter + ')',
+        hint: '阶段结束章必须不早于开始章'
+      });
+    }
+    if (!r.from || !r.to) continue;
+    const key = [r.from, r.to].sort().join('↔');
+    if (!relationByPair.has(key)) relationByPair.set(key, []);
+    relationByPair.get(key).push(r);
+  }
+  for (const [pair, rows] of relationByPair) {
+    const starts = rows.map((r) => r.start_chapter).filter((n) => typeof n === 'number');
+    for (let i = 1; i < starts.length; i++) {
+      if (starts[i] <= starts[i - 1]) {
+        errors.push({
+          code: 'RHYTHM_RELATION_ORDER',
+          path: 'relationship_timeline[' + pair + ']',
+          message: '关系 ' + pair + ' 的阶段开始章必须严格递增：' + starts.join(' → '),
+          hint: '每个阶段只写自己的开始章；后一阶段必须晚于前一阶段'
+        });
+        break;
+      }
+    }
+  }
+
+  // 势力关系的阶段变化：与角色关系同一套口径。
+  const factionRows = timeline.faction_relationship_timeline || [];
+  const factionByPair = new Map();
+  for (const [i, r] of factionRows.entries()) {
+    check(r.from, idSets.faction, '势力', 'faction_relationship_timeline[' + i + '].from');
+    check(r.to, idSets.faction, '势力', 'faction_relationship_timeline[' + i + '].to');
+    if (typeof r.start_chapter === 'number' && typeof r.end_chapter === 'number' && r.start_chapter > r.end_chapter) {
+      errors.push({
+        code: 'RHYTHM_CHAP_ORDER',
+        path: 'faction_relationship_timeline[' + i + ']',
+        message: '势力关系阶段 start_chapter(' + r.start_chapter + ') > end_chapter(' + r.end_chapter + ')',
+        hint: '阶段结束章必须不早于开始章'
+      });
+    }
+    if (!r.from || !r.to) continue;
+    const key = [r.from, r.to].sort().join('↔');
+    if (!factionByPair.has(key)) factionByPair.set(key, []);
+    factionByPair.get(key).push(r);
+  }
+  for (const [pair, rows] of factionByPair) {
+    const starts = rows.map((r) => r.start_chapter).filter((n) => typeof n === 'number');
+    for (let i = 1; i < starts.length; i++) {
+      if (starts[i] <= starts[i - 1]) {
+        errors.push({
+          code: 'RHYTHM_RELATION_ORDER',
+          path: 'faction_relationship_timeline[' + pair + ']',
+          message: '势力关系 ' + pair + ' 的阶段开始章必须严格递增：' + starts.join(' → '),
+          hint: '每个阶段只写自己的开始章；后一阶段必须晚于前一阶段'
+        });
+        break;
+      }
+    }
+  }
+
+  // 血肉里写了 changes[] 的关系，节奏必须给它至少一个阶段落点。
+  const changedPairs = new Set();
+  const fleshChars = (flesh && flesh.characters && flesh.characters.characters) || [];
+  const idByName = new Map(fleshChars.filter((c) => c && c.id && c.name).map((c) => [c.name, c.id]));
+  for (const c of fleshChars) {
+    if (!c || !Array.isArray(c.relationships)) continue;
+    for (const rel of c.relationships) {
+      if (!rel || !Array.isArray(rel.changes) || rel.changes.length === 0) continue;
+      const targetId = idByName.get(rel.target_name);
+      // 没有 name→id 表时跳过覆盖检查；引用错误由血肉阶段负责。
+      if (!c.id || !targetId) continue;
+      changedPairs.add([c.id, targetId].sort().join('↔'));
+    }
+  }
+  for (const pair of changedPairs) {
+    if (!relationByPair.has(pair)) {
+      errors.push({
+        code: 'RHYTHM_RELATION_TIMELINE_MISSING',
+        path: 'relationship_timeline',
+        message: '血肉阶段写了 ' + pair + ' 的关系变化，但时序映射没有对应阶段',
+        hint: '在 relationship_timeline 里为这对角色补 start_chapter；章节落点属于节奏阶段'
+      });
+    }
+  }
+
   for (const [i, r] of (timeline.character_timeline || []).entries()) {
     check(r.char_id, idSets.char, '角色', 'character_timeline[' + i + '].char_id');
     if (typeof r.appear_start === 'number' && typeof r.appear_end === 'number' && r.appear_start > r.appear_end) {
@@ -1068,7 +1164,7 @@ function validateSingle(args) {
   if (file === '章节规划') {
     safeCheck('checkChapterPlan', () => checkChapterPlan(data.chapters, T, skeleton.hierarchy, skeleton.framework.volume_ratio, errors, warnings), errors);
   } else if (file === '时序映射') {
-    safeCheck('checkTimelineIntegrity', () => checkTimelineIntegrity(data, idSets, errors), errors);
+    safeCheck('checkTimelineIntegrity', () => checkTimelineIntegrity(data, idSets, errors, skeleton.flesh), errors);
   } else if (file === '节奏参数') {
     safeCheck('checkRhythmInfeasible', () => checkRhythmInfeasible(data, skeleton.framework, fm.constraints, errors), errors);
     safeCheck('checkRhythmDerivations', () => checkRhythmDerivations(data, fm.constraints, errors, warnings), errors);
@@ -1162,7 +1258,7 @@ function validateAll(args) {
     if (f.type === '章节规划') {
       safeCheck('checkChapterPlan', () => checkChapterPlan(data.chapters, T, skeleton.hierarchy, skeleton.framework.volume_ratio, errors, warnings), errors);
     } else if (f.type === '时序映射') {
-      safeCheck('checkTimelineIntegrity', () => checkTimelineIntegrity(data, idSets, errors), errors);
+      safeCheck('checkTimelineIntegrity', () => checkTimelineIntegrity(data, idSets, errors, skeleton.flesh), errors);
     } else if (f.type === '节奏参数') {
       safeCheck('checkRhythmInfeasible', () => checkRhythmInfeasible(data, skeleton.framework, fm.constraints, errors), errors);
       safeCheck('checkRhythmDerivations', () => checkRhythmDerivations(data, fm.constraints, errors, warnings), errors);