@cloud411716/fancy-webnovel 2.2.0 → 3.0.3

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

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+/**
+ * brief-validate.js —— 校验“每章一份细纲”是否齐全、引用是否成立
+ *
+ * 这一层不是替代 rhythm-validate.js：聚合 JSON 仍由 rhythm-validate 判结构。
+ * 这里只判**写作阶段真正会读的每章细纲**：
+ *   - 1..T 每章是否都有文件；
+ *   - 必须字段是否存在；
+ *   - cast/地点/道具/冲突/伏笔/高潮/爽点/信息差引用是否都能在上游找到；
+ *   - must_write / must_not_write 是否为空。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+const SRC = ['设定', 'raw', 'sources'];
+
+function readJson(file, fallback = null) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf-8')); } catch { return fallback; }
+}
+
+function idsOf(list) {
+  return new Set((list || []).filter((x) => x && x.id).map((x) => x.id));
+}
+
+export function validateChapterBriefs(projectRoot) {
+  const skeletonDir = path.join(projectRoot, ...SRC, '骨架');
+  const fleshDir = path.join(projectRoot, ...SRC, '血肉');
+  const rhythmDir = path.join(projectRoot, ...SRC, '节奏');
+  const briefDir = path.join(rhythmDir, '细纲');
+  const framework = readJson(path.join(skeletonDir, '框架.json'), {}) || {};
+  const entities = readJson(path.join(skeletonDir, '实体.json'), {}) || {};
+  const flesh = readJson(path.join(fleshDir, '冲突.json'), {}) || {};
+  const plan = readJson(path.join(rhythmDir, '章节规划.json'), {}) || {};
+  const T = Number(framework?.capacity?.target_chapters) || (plan.chapters || []).length || 0;
+  const errors = [];
+  const warnings = [];
+
+  const ids = {
+    characters: idsOf(entities.characters),
+    locations: idsOf(entities.locations),
+    items: idsOf(entities.items),
+    conflicts: idsOf(entities.conflicts),
+    foreshadows: idsOf(entities.foreshadows),
+    climaxes: idsOf(entities.climaxes),
+    pleasures: idsOf(entities.pleasures),
+    endings: idsOf(entities.endings),
+  };
+  const infoGapIds = new Set();
+  const gapDir = path.join(projectRoot, ...SRC, '档案', '信息差');
+  try {
+    for (const name of fs.readdirSync(gapDir)) {
+      if (name.endsWith('.json')) infoGapIds.add(name.slice(0, -5));
+    }
+  } catch { /* ignore */ }
+
+  const files = new Map();
+  try {
+    for (const name of fs.readdirSync(briefDir)) {
+      const match = /^第(\d+)章\.json$/.exec(name);
+      if (!match) continue;
+      files.set(Number(match[1]), path.join(briefDir, name));
+    }
+  } catch {
+    errors.push('细纲目录不存在：设定/raw/sources/节奏/细纲');
+  }
+
+  if (T > 0) {
+    for (let ch = 1; ch <= T; ch += 1) {
+      if (!files.has(ch)) errors.push('缺第 ' + ch + ' 章细纲文件');
+    }
+  }
+  for (const ch of files.keys()) {
+    if (T > 0 && (ch < 1 || ch > T)) warnings.push('细纲章号越界：第 ' + ch + ' 章');
+  }
+
+  for (const [ch, file] of [...files.entries()].sort((a, b) => a[0] - b[0])) {
+    const brief = readJson(file);
+    if (!brief) {
+      errors.push('第 ' + ch + ' 章细纲不是合法 JSON');
+      continue;
+    }
+    for (const key of ['ch', 'title', 'volume', 'scene_focus', 'pov', 'cast', 'must_write', 'must_not_write']) {
+      if (brief[key] === undefined || brief[key] === null || brief[key] === '') {
+        errors.push('第 ' + ch + ' 章缺字段：' + key);
+      }
+    }
+    if (!Array.isArray(brief.cast) || brief.cast.length === 0) {
+      warnings.push('第 ' + ch + ' 章没有 cast（可能只剩主角或上游时间线过窄）');
+    }
+    for (const c of (brief.cast || [])) {
+      if (c && c.id && !ids.characters.has(c.id)) errors.push('第 ' + ch + ' 章 cast 引用了不存在的人物：' + c.id);
+    }
+    if (brief.location && brief.location.id && !ids.locations.has(brief.location.id)) {
+      errors.push('第 ' + ch + ' 章地点引用了不存在的地点：' + brief.location.id);
+    }
+    for (const item of (brief.items || [])) {
+      if (item && item.id && !ids.items.has(item.id)) errors.push('第 ' + ch + ' 章道具引用了不存在的道具：' + item.id);
+    }
+    for (const conflict of (brief.conflicts || [])) {
+      if (conflict && conflict.id && !ids.conflicts.has(conflict.id)) {
+        errors.push('第 ' + ch + ' 章冲突引用了不存在的冲突：' + conflict.id);
+      }
+    }
+    for (const rel of (brief.relationship_changes || [])) {
+      if (rel && rel.from && !ids.characters.has(rel.from)) {
+        errors.push('第 ' + ch + ' 章关系变化引用了不存在的人物：' + rel.from);
+      }
+      if (rel && rel.to && !ids.characters.has(rel.to)) {
+        errors.push('第 ' + ch + ' 章关系变化引用了不存在的人物：' + rel.to);
+      }
+    }
+    for (const f of (brief.foreshadow_actions || [])) {
+      if (f && f.id && !ids.foreshadows.has(f.id)) errors.push('第 ' + ch + ' 章伏笔引用了不存在的伏笔：' + f.id);
+    }
+    if (brief.climax && brief.climax.id && !ids.climaxes.has(brief.climax.id)) {
+      errors.push('第 ' + ch + ' 章高潮引用了不存在的高潮：' + brief.climax.id);
+    }
+    if (brief.pleasure && brief.pleasure.id && !ids.pleasures.has(brief.pleasure.id)) {
+      errors.push('第 ' + ch + ' 章爽点引用了不存在的爽点：' + brief.pleasure.id);
+    }
+    if (brief.ending && brief.ending.id && !ids.endings.has(brief.ending.id)) {
+      errors.push('第 ' + ch + ' 章结局引用了不存在的结局：' + brief.ending.id);
+    }
+    for (const gap of (brief.information_gaps || [])) {
+      if (gap && gap.id && !infoGapIds.has(gap.id)) {
+        errors.push('第 ' + ch + ' 章信息差引用了不存在的档案：' + gap.id);
+      }
+    }
+    if (Array.isArray(brief.must_write) && brief.must_write.length === 0) {
+      warnings.push('第 ' + ch + ' 章 must_write 为空');
+    }
+    if (Array.isArray(brief.must_not_write) && brief.must_not_write.length === 0) {
+      warnings.push('第 ' + ch + ' 章 must_not_write 为空');
+    }
+  }
+
+  return {
+    status: errors.length ? 1 : 0,
+    stage: '章节细纲',
+    total: T,
+    files: files.size,
+    errors: errors.slice(0, 200),
+    warnings: warnings.slice(0, 200),
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const rootArg = args.find((a) => a.startsWith('--project-root='));
+  const dirArg = args.find((a) => a.startsWith('--stage-dir='));
+  let projectRoot = rootArg ? rootArg.slice('--project-root='.length) : '';
+  if (!projectRoot && dirArg) {
+    projectRoot = path.resolve(dirArg.slice('--stage-dir='.length), '..', '..', '..', '..');
+  }
+  if (!projectRoot) {
+    process.stderr.write('需要 --project-root=<项目根> 或 --stage-dir=<节奏目录>\n');
+    process.exit(2);
+  }
+  const result = validateChapterBriefs(projectRoot);
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  process.exitCode = result.status;
+}
+
+if (process.argv[1] && process.argv[1].endsWith('brief-validate.js')) main();

package/plugins/fancy-story-builder/scripts/content-quality.js

@@ -69,7 +69,8 @@ const SHORT_VALUE_EXEMPT_FIELDS = new Set(['exception', 'limit']);
 // 这条错就永远修不好、还挂在报告里（tt5 实测 2026-10-25：
 // "genre 字段内容过短（有效字符 2，要求至少 3）：'历史'"）。
 const LENGTH_CHECK_EXEMPT_FIELDS = new Set([
-  'name', 'target_name', 'id', 'type', 'stage', 'gender', 'age_group',
+  'name', 'target_name', 'id', 'type', 'stage', 'timing', 'gender', 'age_group',
+  'kind', 'relation_label', 'state', 'traits', 'abilities', 'limits',
   'catchphrase', 'behavior_repeat_points',
   'position_level', 'theme_short', 'stance', 'core_emotion', 'info_name',
   'focus_points', 'key_event_descriptions', 'memorable_scenes', 'epilogue_hints',
@@ -83,6 +84,8 @@ const LENGTH_CHECK_EXEMPT_FIELDS = new Set([
 // 这些字段承载的是叙述性内容，几个字表达不了一个完整信息。
 const LONG_PROSE_FIELDS = new Set([
   'description', 'content', 'core_summary', 'core_conflict', 'conflict_summary',
+  'positioning', 'reader_value', 'core_setting', 'payoff_model', 'emotion_curve',
+  'opening_hook', 'pacing_plan', 'character_design', 'differentiation', 'risk_validation',
   'conflict_solution', 'core_goal', 'core_drive', 'influence_scope',
   'surface_contradiction', 'deep_contradiction', 'ultimate_contradiction',
   'internal_structure', 'suppression_method', 'resource_seizure_path',

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

@@ -136,6 +136,98 @@ function fleshSelfRelationCheck(data, fileType, errors) {
   }
 }
 
+// ============================================================
+// 个性化特征与关系阶段检查
+// ============================================================
+// `traits` 是角色的"独有特征"，不是性格形容词堆砌。
+// 模板只能要求字段存在，数量和重复要靠这里兜住。
+function traitsAndChangesCheck(data, fileType, errors, warnings) {
+  const checkTraits = (item, path, label, min, max) => {
+    if (!item || item.traits === undefined) {
+      if (label === '角色') {
+        errors.push({
+          code: 'FLESH_TRAITS_MISSING',
+          path: path + '.traits',
+          message: '角色缺少 traits（独有特征/习惯）',
+          hint: '写 3-5 条能直接写进场景的具体特征，例如"紧张时反复摸腕环"'
+        });
+      }
+      return;
+    }
+    if (!Array.isArray(item.traits)) return; // TYPE 已报
+    const values = item.traits.map((x) => (typeof x === 'string' ? x.trim() : '')).filter(Boolean);
+    if (values.length < min || values.length > max) {
+      errors.push({
+        code: 'FLESH_TRAITS_COUNT',
+        path: path + '.traits',
+        message: label + '的 traits 应为 ' + min + '-' + max + ' 条，实际 ' + values.length + ' 条',
+        hint: '特征要少而准：每条都能在场景里演出来，不要用"善良""勇敢"这类评价词凑数'
+      });
+    }
+    if (new Set(values).size !== values.length) {
+      errors.push({
+        code: 'FLESH_TRAITS_DUPLICATE',
+        path: path + '.traits',
+        message: label + '的 traits 有重复条目',
+        hint: '删掉重复项，换成不同的习惯/感官锚点'
+      });
+    }
+  };
+
+  const checkChanges = (rel, path, label) => {
+    if (!rel || !Array.isArray(rel.changes) || rel.changes.length === 0) return;
+    for (const [k, ch] of rel.changes.entries()) {
+      if (!ch || typeof ch !== 'object') continue;
+      for (const key of ['stage', 'from', 'to', 'trigger', 'description']) {
+        const v = ch[key];
+        if (typeof v !== 'string' || !v.trim()) {
+          errors.push({
+            code: 'REL_CHANGE_INCOMPLETE',
+            path: path + '.changes[' + k + '].' + key,
+            message: label + '的关系变化缺少 ' + key + '，无法判断这一阶段到底发生了什么',
+            hint: '每条变化至少写清：阶段名、变化前状态、变化后状态、触发事件、变化描述'
+          });
+        }
+      }
+      for (const key of ['stage', 'from', 'to', 'trigger', 'description', 'timing']) {
+        if (typeof ch[key] === 'string' && /第\s*(?:\d+|[一二三四五六七八九十百千万]+)\s*章/.test(ch[key])) {
+          errors.push({
+            code: 'FLESH_FREETEXT_CHAPTER_REF',
+            path: path + '.changes[' + k + '].' + key,
+            message: '关系变化里出现"第 N 章"引用；章节号属于节奏阶段',
+            hint: '这里只写"前期/转折/后期/某卷"或事件本身，章节落点由节奏阶段 relationship_timeline 决定'
+          });
+        }
+      }
+    }
+  };
+
+  if (fileType === '角色') {
+    for (const [i, c] of (data.characters || []).entries()) {
+      if (!c) continue;
+      checkTraits(c, 'characters[' + i + ']', '角色', 3, 5);
+      for (const [j, rel] of (c.relationships || []).entries()) {
+        if (!rel) continue;
+        if (rel.relationship_type === '其他' && !String(rel.relation_label || '').trim()) {
+          errors.push({
+            code: 'REL_LABEL_REQUIRED',
+            path: 'characters[' + i + '].relationships[' + j + '].relation_label',
+            message: 'relationship_type="其他" 时必须填 relation_label，写清具体关系（如 附身/寄生/契约/共生）',
+            hint: 'relation_label 是词表外关系的唯一语义来源'
+          });
+        }
+        checkChanges(rel, 'characters[' + i + '].relationships[' + j + ']', c.name || c.id);
+      }
+    }
+  }
+  if (fileType === '其他实体') {
+    for (const [i, o] of (data.other_entities || []).entries()) {
+      if (!o) continue;
+      checkTraits(o, 'other_entities[' + i + ']', '其他实体', 2, 6);
+    }
+  }
+}
+
 // ============================================================
 // 跨阶段：血肉关系 ↔ 骨架关系一致性
 // ============================================================
@@ -169,11 +261,14 @@ function skeletonRelationConsistencyCheck(fleshData, sk, errors, warnings, opts)
   }
   const resolve = (v) => (v && idByKey.has(v) ? idByKey.get(v) : null);
 
-  // 骨架关系：'A→B' → relation_kind
+  // 骨架关系：'A→B' → { kind, label }
   const skRel = new Map();
   for (const r of (sk.relations.character_relations || [])) {
     if (!r || !r.from || !r.to) continue;
-    skRel.set(r.from + '→' + r.to, r.relation_kind);
+    skRel.set(r.from + '→' + r.to, {
+      kind: r.relation_kind,
+      label: typeof r.relation_label === 'string' ? r.relation_label.trim() : ''
+    });
   }
 
   // 血肉关系：有序对 → { kind, path }，并记录血肉已覆盖的无序对
@@ -194,19 +289,36 @@ function skeletonRelationConsistencyCheck(fleshData, sk, errors, warnings, opts)
 
       const fwd = skRel.get(key);
       if (fwd !== undefined) {
-        if (r.relationship_type !== fwd) {
+        if (r.relationship_type !== fwd.kind) {
           errors.push({
             code: 'REL_TYPE_MISMATCH',
             path: p + '.relationship_type',
-            message: '骨架 ' + srcId + '→' + tgtId + ' 的关系类型是 "' + fwd + '"，血肉写的是 "' + r.relationship_type + '"',
+            message: '骨架 ' + srcId + '→' + tgtId + ' 的关系类型是 "' + fwd.kind + '"，血肉写的是 "' + r.relationship_type + '"',
             hint: '血肉阶段的关系类型必须与骨架一致；若语义确实变了，请在 description 里写清"关系在剧情中如何演变"，而不是换掉类型'
           });
         }
+        const fleshLabel = typeof r.relation_label === 'string' ? r.relation_label.trim() : '';
+        if (fwd.label && fleshLabel && fwd.label !== fleshLabel) {
+          errors.push({
+            code: 'REL_LABEL_MISMATCH',
+            path: p + '.relation_label',
+            message: '骨架 ' + srcId + '→' + tgtId + ' 的关系标签是 "' + fwd.label + '"，血肉写的是 "' + fleshLabel + '"',
+            hint: '关系标签必须与骨架完全一致'
+          });
+        }
+        if (fwd.kind === '其他' && !fleshLabel) {
+          errors.push({
+            code: 'REL_LABEL_REQUIRED',
+            path: p + '.relation_label',
+            message: '骨架把 ' + srcId + '→' + tgtId + ' 标为"其他"，血肉必须写 relation_label',
+            hint: '照抄骨架的 relation_label，或补齐具体关系名'
+          });
+        }
         continue;
       }
 
-      const rev = skRel.get(tgtId + '→' + srcId);
-      if (rev === undefined) {
+      const revRow = skRel.get(tgtId + '→' + srcId);
+      if (revRow === undefined) {
         errors.push({
           code: 'REL_NOT_IN_SKELETON',
           path: p,
@@ -216,6 +328,7 @@ function skeletonRelationConsistencyCheck(fleshData, sk, errors, warnings, opts)
         continue;
       }
 
+      const rev = revRow.kind;
       const meta = RELATION_KIND_META[rev];
       if (meta && meta.direction === 'symmetric') {
         if (r.relationship_type !== rev) {
@@ -246,7 +359,7 @@ function skeletonRelationConsistencyCheck(fleshData, sk, errors, warnings, opts)
     warnings.push({
       code: 'REL_UNDECLARED',
       path: '骨架关系 ' + key,
-      message: '骨架 ' + key + '（"' + kind + '"）在血肉阶段没有对应的 relationships 条目',
+      message: '骨架 ' + key + '（"' + kind.kind + '"）在血肉阶段没有对应的 relationships 条目',
       hint: '该对角色的关系尚未血肉化；若刻意留白可忽略'
     });
   }
@@ -459,6 +572,7 @@ function charsetAndForbiddenCheck(data, errors) {
 // ============================================================
 const FLESH_ID_ARRAYS = {
   '角色': ['characters'],
+  '其他实体': ['other_entities'],
   '冲突': ['conflicts'],
   '势力': ['factions'],
   '剧情': ['main_lines', 'branches'],
@@ -488,6 +602,7 @@ function idUniquenessCheck(data, fileType, errors) {
 // ============================================================
 const FLESH_TO_SKELETON = {
   '角色': { fleshKey: 'characters', skeletonKey: 'characters' },
+  '其他实体': { fleshKey: 'other_entities', skeletonKey: 'other_entities' },
   '冲突': { fleshKey: 'conflicts', skeletonKey: 'conflicts' },
   '势力': { fleshKey: 'factions', skeletonKey: 'factions' },
   '地点': { fleshKey: 'locations', skeletonKey: 'locations' },
@@ -545,7 +660,7 @@ function foreshadowRefCheck(data, skeletonEntity, errors) {
           code: 'FLESH_FORESHADOW_REF_MISSING',
           path: 'endings[' + i + '].foreshadow_recovery_plan[' + j + '].foreshadow_id',
           message: '伏笔 id "' + fid + '" 不存在于骨架的 foreshadows',
-          hint: '伏笔 id 必须来自骨架 实体.json 的 foreshadows（可用 upstream-query.js --stage=骨架 --file=实体 查）'
+          hint: '伏笔 id 必须来自骨架 实体.json 的 foreshadows（可用 node references/upstream-query.js --stage=骨架 --file=实体 --list 查全部 id 名单）'
         });
       }
     }
@@ -733,7 +848,7 @@ function xrefCheck(data, fileType, skeletonEntity, errors) {
         message: '引用' + label + ' "' + name + '" 不存在于骨架',
         hint: guess
           ? '疑似拼错：骨架里有 "' + guess.name + '"，请改成它'
-          : '引用必须用骨架里已有的' + label + '名字；可用 upstream-query.js --stage=骨架 --file=实体 查全量名单'
+          : '引用必须用骨架里已有的' + label + '名字；可用 node references/upstream-query.js --stage=骨架 --file=实体 --list 查全量名单'
       });
     }
   };
@@ -843,6 +958,7 @@ function checkEntityCoverage(skeletonIds, fleshIds, label, errors, warnings) {
 // P0-3：数组名 → 文件类型 的映射
 const DIRECT_FILE_TYPE_MAP = {
   characters: '角色',
+  other_entities: '其他实体',
   conflicts: '冲突',
   factions: '势力',
   locations: '地点',
@@ -852,6 +968,7 @@ const DIRECT_FILE_TYPE_MAP = {
 function completenessCheck(fleshData, skeletonEntity, errors, warnings) {
   const directChecks = [
     { fleshKey: 'characters', skKey: 'characters', label: 'character' },
+    { fleshKey: 'other_entities', skKey: 'other_entities', label: 'other_entity' },
     { fleshKey: 'conflicts', skKey: 'conflicts', label: 'conflict' },
     { fleshKey: 'factions', skKey: 'factions', label: 'faction' },
     { fleshKey: 'locations', skKey: 'locations', label: 'location' },
@@ -1017,7 +1134,7 @@ function validateSingle(args) {
   safeCheck('freeTextChapterCheck', () => freeTextChapterCheck(data, warnings), errors);
   safeCheck('idUniquenessCheck', () => idUniquenessCheck(data, file, errors), errors);
 
-  if (file === '角色' || file === '冲突' || file === '势力' || file === '地点' || file === '结局') {
+  if (file === '角色' || file === '其他实体' || file === '冲突' || file === '势力' || file === '地点' || file === '结局') {
     safeCheck('entityRefCheck', () => entityRefCheck(data, file, sk.entity, errors), errors);
   } else if (file === '剧情') {
     safeCheck('storyRefCheck', () => storyRefCheck(data, sk.entity, errors), errors);
@@ -1035,6 +1152,7 @@ function validateSingle(args) {
   safeCheck('xrefCheck', () => xrefCheck(data, file, sk.entity, errors), errors);
   safeCheck('fleshSelfRelationCheck', () => fleshSelfRelationCheck(data, file, errors), errors);
   safeCheck('contentQualityCheck', () => runContentQualityChecks(data, errors, { enumLeaves: collectEnumLeaves(tplRes.data.structure) }), errors);
+  safeCheck('traitsAndChangesCheck', () => traitsAndChangesCheck(data, file, errors, warnings), errors);
 
   if (file === '角色') {
     safeCheck('arcConsistencyCheck', () => arcConsistencyCheck(data, warnings, sk.hierarchy), errors);
@@ -1091,6 +1209,7 @@ function validateAll(args) {
     return emit(2, 'ALL', [{ code: 'UPSTREAM_NOT_PASSED', path: '', message: gate.reason, hint: '请先对骨架阶段执行全量校验并通过' }], []);
   }
 
+  const otherEntityCount = Array.isArray(sk.entity.other_entities) ? sk.entity.other_entities.length : 0;
   const FILES = [
     { type: '角色', name: '角色.json', tpl: '角色模板.json' },
     { type: '冲突', name: '冲突.json', tpl: '冲突模板.json' },
@@ -1099,7 +1218,10 @@ function validateAll(args) {
     { type: '地点', name: '地点.json', tpl: '地点模板.json' },
     { type: '结局', name: '结局.json', tpl: '结局模板.json' },
     { type: '世界观规则', name: '世界观规则.json', tpl: '世界观规则模板.json' },
-    { type: '关键道具', name: '关键道具.json', tpl: '关键道具模板.json' }
+    { type: '关键道具', name: '关键道具.json', tpl: '关键道具模板.json' },
+    ...(otherEntityCount > 0 || fs.existsSync(path.join(stageDir, '其他实体.json'))
+      ? [{ type: '其他实体', name: '其他实体.json', tpl: '其他实体模板.json' }]
+      : [])
   ];
 
   const loaded = {};
@@ -1128,7 +1250,7 @@ function validateAll(args) {
     safeCheck('freeTextChapterCheck', () => freeTextChapterCheck(data, warnings), errors);
     safeCheck('idUniquenessCheck', () => idUniquenessCheck(data, f.type, errors), errors);
 
-    if (f.type === '角色' || f.type === '冲突' || f.type === '势力' || f.type === '地点' || f.type === '结局') {
+    if (f.type === '角色' || f.type === '其他实体' || f.type === '冲突' || f.type === '势力' || f.type === '地点' || f.type === '结局') {
       safeCheck('entityRefCheck', () => entityRefCheck(data, f.type, sk.entity, errors), errors);
     } else if (f.type === '剧情') {
       safeCheck('storyRefCheck', () => storyRefCheck(data, sk.entity, errors), errors);
@@ -1146,6 +1268,7 @@ function validateAll(args) {
     safeCheck('xrefCheck', () => xrefCheck(data, f.type, sk.entity, errors), errors);
     safeCheck('fleshSelfRelationCheck', () => fleshSelfRelationCheck(data, f.type, errors), errors);
     safeCheck('contentQualityCheck', () => runContentQualityChecks(data, errors, { enumLeaves: collectEnumLeaves(tplRes.data.structure) }), errors);
+    safeCheck('traitsAndChangesCheck', () => traitsAndChangesCheck(data, f.type, errors, warnings), errors);
 
     if (f.type === '角色') safeCheck('arcConsistencyCheck', () => arcConsistencyCheck(data, warnings, sk.hierarchy), errors);
   }