@cloud411716/fancy-webnovel 1.0.46 → 2.2.0

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

@@ -0,0 +1,413 @@
+/**
+ * content-quality.js
+ * 内容质量检查（骨架 / 血肉阶段共用）
+ *
+ * 补的是一个此前完全空白的校验面：所有既有检查都只管"结构对不对"，
+ * 不管"内容是不是空的"。实测能拿到 status 0 的数据集里，
+ * 实体名全是「主角1 / 核心配角1」这类占位名，自由文本字段全是
+ * 「很好」「很厉害」这类空话，而没有任何一条检查会报错。
+ *
+ * 四类检查：
+ *   NAME_PLACEHOLDER  泛化名：实体名是「主角1」「核心配角2」这类角色标签
+ *   TEXT_PLACEHOLDER  占位文本：待补充 / TBD / xxx / 纯标点
+ *   TEXT_TOO_SHORT    最短长度：叙述字段短到承载不了信息
+ *   TEXT_DUPLICATE    同质化：两个实体的同一字段几乎一字不差（复制粘贴）
+ *
+ * 阈值全部集中在下面的常量里，改阈值不用动检查逻辑。
+ * 源码中零反引号，避免 markdown 渲染问题。
+ */
+
+// ============================================================
+// 阈值配置
+// ============================================================
+
+// 泛化名的角色标签。命中即认为该实体名是占位名而非真正的名字。
+// 规则：标签本身，或标签 + 数字后缀（主角 / 主角1 / 主角12）。
+const GENERIC_NAME_LABELS = [
+  // 角色类型标签
+  '主角', '核心配角', '卷级配角', '贯穿级核心配角', '核心反派', '卷级反派',
+  '反派', '配角', '角色', '人物', '对手', '敌人', '朋友', '队友',
+  // 关系位置标签
+  '老师', '导师', '师父', '师兄', '师姐', '师妹', '师弟',
+  '哥哥', '姐姐', '弟弟', '妹妹', '丈夫', '妻子',
+  // 无信息量标签
+  '男人', '女人', '男子', '女子', '少年', '青年', '中年', '老年',
+  '无名氏', '路人', '群众', '龙套', '路人甲', '路人乙',
+  // 其它实体的类型标签
+  '冲突', '势力', '地点', '道具', '结局', '伏笔', '高潮', '爽点',
+  '规则', '主线', '支线', '卷', '幕', '幕结构',
+  '核心道具', '支线道具', '象征道具',
+  // 测试/占位标记
+  '测试', '测试角色', '测试人物', '测试数据', '样例', '示例', '例子', '占位'
+];
+
+// 占位文本。命中即认为该字段没有真正内容。
+const PLACEHOLDER_TEXTS = new Set([
+  '待补充', '待完善', '待细化', '待定', '待写', '待补', '待确认', '后续补充',
+  'TBD', 'TO DO', 'TODO', 'todo', 'tbd',
+  'N/A', 'n/a', 'null', 'undefined', 'none', 'None',
+  'xxx', 'XXX', 'xx', 'XX', '???', '???',
+  '略', '省略', '以下略', '同上', '暂缺', '暂无', '空', '空白', '空缺',
+  '占位', 'placeholder', 'PLACEHOLDER', 'Placeholder',
+  '示例', '样例', '例子', '测试', 'test', 'TEST', 'Test',
+  '-', '--', '—', '——', '_', '/', '／', '?', '？', '!', '！',
+  '。', '…', '……', '......', '………。',
+  '不知道', '没写', '没想好', '再说', '随机', '随便'
+]);
+
+// 这些字段允许出现"无 / 略"这类极短值，语义上就是"没有例外 / 没有限制"。
+// 不排除的话，正常的世界观规则会被误判成占位。
+const SHORT_VALUE_EXEMPT_FIELDS = new Set(['exception', 'limit']);
+
+// 不做长度检查的字段（本来就可以很短，且有专门的检查覆盖）
+// 这些字段要么是纯标签（type / stage / position_level），要么语义上就是短标签
+// （catchphrase 口头禅、theme_short 卷主题），要么是数组里的短条目。
+//
+// genre / book_name 是**输入快照里原样照抄的字段**（提示词要求照抄任务输入）：
+// 题材词本来就可能是两个字（历史 / 言情 / 武侠 / 科幻），书名也可能很短。
+// 不豁免的话会报 TEXT_TOO_SHORT，而模型改不了（照抄才是对的），
+// 这条错就永远修不好、还挂在报告里（tt5 实测 2026-10-25：
+// "genre 字段内容过短（有效字符 2，要求至少 3）：'历史'"）。
+const LENGTH_CHECK_EXEMPT_FIELDS = new Set([
+  'name', 'target_name', 'id', 'type', 'stage', 'gender', 'age_group',
+  'catchphrase', 'behavior_repeat_points',
+  'position_level', 'theme_short', 'stance', 'core_emotion', 'info_name',
+  'focus_points', 'key_event_descriptions', 'memorable_scenes', 'epilogue_hints',
+  'suspense_blanks', 'anti_trope_design', 'hard_constraints', 'anti_tropes',
+  'resources', 'key_elements', 'related_characters', 'related_conflicts',
+  'golden_finger', 'function', 'relation',
+  'genre', 'book_name'
+]);
+
+// "必须是一段话"的字段：短于 6 个有效字符即判为空话。
+// 这些字段承载的是叙述性内容，几个字表达不了一个完整信息。
+const LONG_PROSE_FIELDS = new Set([
+  'description', 'content', 'core_summary', 'core_conflict', 'conflict_summary',
+  'conflict_solution', 'core_goal', 'core_drive', 'influence_scope',
+  'surface_contradiction', 'deep_contradiction', 'ultimate_contradiction',
+  'internal_structure', 'suppression_method', 'resource_seizure_path',
+  'main_line_connection', 'main_relation', 'expected_outcome',
+  'narrative_role_description', 'layout', 'appearance', 'origin',
+  'function_detail', 'symbolic_meaning', 'usage_scenario', 'applicable_scope',
+  'impact_on_protagonist', 'impact_on_plot', 'violation_consequence',
+  'contradiction', 'solution', 'residual_impact', 'resolution_method',
+  'emotion_trajectory', 'final_point', 'special_remaining',
+  'climax_design', 'turning_design', 'cost_design', 'resolution_design',
+  'core_flaw', 'known_secrets', 'unknown_secrets', 'false_beliefs',
+  'long_term', 'medium_term', 'short_term',
+  'speech_rhythm', 'info_preference', 'identity_wording',
+  'personality_tone', 'relationship_stage_tone',
+  'position_description', 'relation_description'
+]);
+
+// 短叙述字段的最低有效字符数
+const MIN_LEN_LONG_PROSE = 6;
+// 普通自由文本字段的最低有效字符数
+const MIN_LEN_DEFAULT = 3;
+
+// 同质化判定：二元组 Jaccard 相似度阈值
+const DUP_JACCARD_THRESHOLD = 0.8;
+// 参与同质化比较的文本最少二元组数（太短的文本 bigram 噪声大，不参与）
+const DUP_MIN_BIGRAMS = 8;
+
+// ============================================================
+// 字数统计（写作校验器与导入阶段共用同一口径）
+// ============================================================
+
+// 反引号字符用 fromCharCode 生成，源码零反引号
+const BT = String.fromCharCode(96);
+const BT3 = BT + BT + BT;
+const BT3_RE = new RegExp(BT3 + '[\\s\\S]*?' + BT3, 'g');
+
+/**
+ * 正文字数：**计入中文标点**（与网文平台的"字数"口径一致，如起点/番茄
+ * 计的是含标点的字符数，不含空白）。不含空白、代码块、行首标题行。
+ *
+ * 为什么放在共享模块里而不是各写一份：
+ *   导入阶段从旧稿反推出的 `avg_words_per_chapter`，
+ *   要和写作校验器的 ±20% 字数容差对得上。口径不一致的话，
+ *   导入出来的章会被写作阶段误报 WORD_COUNT —— 而这跟正文质量无关。
+ */
+export function countChapterChars(text) {
+  if (typeof text !== 'string') return 0;
+  const stripped = text
+    .replace(BT3_RE, '')
+    .replace(/^#+\s+.*$/gm, '')
+    .replace(/[*_\x60>-]+/g, '')
+    .replace(/\s+/g, '');
+  return stripped.length;
+}
+
+// ============================================================
+// 基础工具
+// ============================================================
+
+/**
+ * 统计有效字符数：去掉空白与常见标点后的字符数。
+ * 只算"承载信息"的字符，避免用标点撑长度。
+ */
+export function countEffectiveChars(text) {
+  if (typeof text !== 'string') return 0;
+  let n = 0;
+  for (const ch of text) {
+    if (/\s/.test(ch)) continue;
+    if (/[，。、；：？！“”‘’（）《》【】—…·,.;:?!"'()\[\]{}<>\-_=+*/\\|~`@#$%^&]/.test(ch)) continue;
+    n++;
+  }
+  return n;
+}
+
+/**
+ * 判断字符串是否"由角色标签构成"（可带数字后缀）。
+ */
+export function isGenericName(name) {
+  if (typeof name !== 'string') return false;
+  const t = name.trim();
+  if (!t) return false;
+  for (const label of GENERIC_NAME_LABELS) {
+    if (t === label) return true;
+    if (t.length > label.length && t.startsWith(label) && /^\d+$/.test(t.slice(label.length))) return true;
+  }
+  return false;
+}
+
+/**
+ * 判断字符串是否是占位文本。
+ */
+export function isPlaceholderText(text) {
+  if (typeof text !== 'string') return false;
+  const t = text.trim();
+  if (!t) return true;
+  if (PLACEHOLDER_TEXTS.has(t)) return true;
+  // 纯标点
+  if (!/[0-9A-Za-z\u4e00-\u9fa5]/.test(t)) return true;
+  // 同一个字符重复 3 次以上（"啊啊啊"、"。。。"、"———"）
+  if (new Set(t.split('')).size === 1 && t.length >= 3) return true;
+  // x / ？ 占位符
+  if (/^[xX?？*＊#＃]{2,}$/.test(t)) return true;
+  return false;
+}
+
+/**
+ * 取中文二元组集合（去重）。
+ */
+export function bigrams(text) {
+  const t = (text || '').replace(/\s+/g, '');
+  const out = new Set();
+  for (let i = 0; i + 1 < t.length; i++) out.add(t.slice(i, i + 2));
+  return out;
+}
+
+/**
+ * 两个文本的二元组 Jaccard 相似度。
+ */
+export function jaccard(a, b) {
+  if (!a || !b) return 0;
+  let inter = 0;
+  for (const x of a) if (b.has(x)) inter++;
+  const union = a.size + b.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+
+// ============================================================
+// 遍历工具
+// ============================================================
+
+/**
+ * 递归遍历 JSON，找出所有"自由文本字段"。
+ *
+ * 返回 [{ path, leaf, text, owner }]：
+ *   path  点号路径，数组用 [] 表示（characters[].description）
+ *   leaf  字段名（最后一段）
+ *   text  字段值（字符串）
+ *   owner 所属实体的标识（数组下标或对象里的 id/name），用于同质化分组
+ */
+export function collectTextFields(data) {
+  const out = [];
+  if (!data || typeof data !== 'object') return out;
+
+  const walk = (node, path, leaf, owner) => {
+    if (Array.isArray(node)) {
+      node.forEach((v, i) => walk(v, path + '[]', leaf, owner + (owner ? '.' : '') + i));
+      return;
+    }
+    if (!node || typeof node !== 'object') return;
+    for (const [k, v] of Object.entries(node)) {
+      if (typeof v === 'string') {
+        out.push({ path: path ? path + '.' + k : k, leaf: k, text: v, owner: owner });
+      } else if (v && typeof v === 'object') {
+        walk(v, path ? path + '.' + k : k, k, owner);
+      }
+    }
+  };
+
+  walk(data, '', '', '');
+  return out;
+}
+
+/**
+ * 找出"实体名"字段：路径最后一段是 name，且不是引用别人的 name。
+ * 引用型 name（members[].name 指向骨架角色）也一并检查——
+ * 骨架那边已经是占位名的话，这里同样是占位名。
+ */
+function isNameField(path, leaf) {
+  return leaf === 'name';
+}
+
+/**
+ * 从模板 structure 里收集所有 enumRef 字段的叶子名。
+ *
+ * 枚举值天然很短（"个人""伏笔""血缘""对话"），拿叙述字段的长度标准去卡它们
+ * 会全线误报。模板是唯一知道"这个字段是枚举"的地方，所以由调用方把模板传进来。
+ */
+export function collectEnumLeaves(structure) {
+  const leaves = new Set();
+  if (!structure || typeof structure !== 'object') return leaves;
+  const walk = (node) => {
+    if (!node || typeof node !== 'object') return;
+    if (Array.isArray(node)) {
+      for (const v of node) walk(v);
+      return;
+    }
+    // 命中一个带 enumRef 的字段：它自己的名字就是要排除的叶子名
+    if (node.enumRef) leaves.add(node.__leafName || '');
+    for (const [k, v] of Object.entries(node.properties || {})) {
+      if (v && typeof v === 'object') {
+        if (v.enumRef) leaves.add(k);
+        walk(v);
+      }
+    }
+    // 数组元素：继续往下走
+    if (node.items && typeof node.items === 'object') walk(node.items);
+  };
+  walk(structure);
+  leaves.delete('');
+  return leaves;
+}
+
+// ============================================================
+// 检查主体
+// ============================================================
+
+/**
+ * 泛化名检查。
+ *
+ * 对所有实体的 name 字段判定是否只是角色标签。
+ */
+export function checkGenericNames(data, errors) {
+  for (const f of collectTextFields(data)) {
+    if (!isNameField(f.path, f.leaf)) continue;
+    if (!isGenericName(f.text)) continue;
+    errors.push({
+      code: 'NAME_PLACEHOLDER',
+      path: f.path,
+      // owner 指出是哪个实体（path 不带下标，见上面 TEXT_PLACEHOLDER 的说明）
+      owner: f.owner,
+      message: '实体名 "' + f.text.trim() + '" 是泛化占位名，不是真实的名字',
+      hint: '换成有辨识度的专名（如"陆子仲"）；泛化名会让后面所有血肉描写失去落点'
+    });
+  }
+}
+
+/**
+ * 占位文本 + 最短长度检查。
+ */
+export function checkTextQuality(data, errors, enumLeaves) {
+  const enums = enumLeaves || new Set();
+  for (const f of collectTextFields(data)) {
+    const leaf = f.leaf;
+    if (leaf === 'name') continue;   // 名字由 NAME_PLACEHOLDER 负责
+    if (SHORT_VALUE_EXEMPT_FIELDS.has(leaf)) continue;
+    if (enums.has(leaf)) continue;   // 枚举值天然短，不按叙述标准卡
+
+    if (isPlaceholderText(f.text)) {
+      errors.push({
+        code: 'TEXT_PLACEHOLDER',
+        path: f.path,
+        // 2026-10-27：错误对象带上 owner（具体是哪个实体）。
+        // path 故意**不带下标**（characters[].description）——
+        // 同质化检查（checkHomogenizedContent）靠"同路径分组"把不同实体的
+        // 同名字段放在一起比较，路径一旦带上下标，分组就散了，
+        // 同质化检查会整个失效。所以定位靠 owner，不靠 path。
+        owner: f.owner,
+        message: '字段内容是占位文本（"' + f.text.trim().slice(0, 20) + '"），没有实际信息',
+        hint: '这个字段要写实内容，不能留占位符或待办标记'
+      });
+      continue;
+    }
+
+    if (LENGTH_CHECK_EXEMPT_FIELDS.has(leaf)) continue;
+
+    const min = LONG_PROSE_FIELDS.has(leaf) ? MIN_LEN_LONG_PROSE : MIN_LEN_DEFAULT;
+    const len = countEffectiveChars(f.text);
+    if (len >= min) continue;
+
+    errors.push({
+      code: 'TEXT_TOO_SHORT',
+      path: f.path,
+      message: '字段内容过短（有效字符 ' + len + '，要求至少 ' + min + '）："' + f.text.trim().slice(0, 20) + '"',
+      hint: LONG_PROSE_FIELDS.has(leaf)
+        ? '这是一个需要成句叙述的字段，至少写清一个具体事实（谁 / 在什么处境下 / 做了什么）'
+        : '把这个字段写成具体信息，而不是一个词'
+    });
+  }
+}
+
+/**
+ * 同质化检查：同一文件里，不同实体的同一个叙述字段几乎一字不差。
+ *
+ * 典型场景是 LLM 把一段模板文字复制给了所有角色，字段数都对、内容全一样。
+ */
+export function checkHomogenizedContent(data, errors) {
+  const fields = collectTextFields(data).filter(
+    (f) => LONG_PROSE_FIELDS.has(f.leaf) && !SHORT_VALUE_EXEMPT_FIELDS.has(f.leaf)
+  );
+
+  // 按"字段路径"分组，同一组内互相比较
+  const groups = new Map();
+  for (const f of fields) {
+    if (!groups.has(f.path)) groups.set(f.path, []);
+    groups.get(f.path).push(f);
+  }
+
+  const reported = new Set();
+  for (const [path, list] of groups) {
+    if (list.length < 2) continue;
+    const withBigrams = [];
+    for (const f of list) {
+      const bg = bigrams(f.text);
+      if (bg.size < DUP_MIN_BIGRAMS) continue;
+      withBigrams.push({ f: f, bg: bg });
+    }
+    for (let i = 0; i < withBigrams.length; i++) {
+      for (let j = i + 1; j < withBigrams.length; j++) {
+        const a = withBigrams[i];
+        const b = withBigrams[j];
+        if (a.f.owner === b.f.owner) continue;
+        const sim = jaccard(a.bg, b.bg);
+        if (sim < DUP_JACCARD_THRESHOLD) continue;
+        const key = path + '|' + [a.f.owner, b.f.owner].sort().join('|');
+        if (reported.has(key)) continue;
+        reported.add(key);
+        errors.push({
+          code: 'TEXT_DUPLICATE',
+          path: path,
+          message: '两个不同实体的「' + path + '」内容几乎完全相同（相似度 ' + sim.toFixed(2) + '）',
+          hint: '每个实体写各自的具体内容；逐字复制会让角色失去区分度'
+        });
+      }
+    }
+  }
+}
+
+/**
+ * 一次跑完全部内容质量检查。
+ *
+ * opts.enumLeaves：模板里 enumRef 字段的叶子名集合，枚举值不参与长度检查。
+ */
+export function runContentQualityChecks(data, errors, opts) {
+  const enumLeaves = (opts && opts.enumLeaves) || new Set();
+  checkGenericNames(data, errors);
+  checkTextQuality(data, errors, enumLeaves);
+  checkHomogenizedContent(data, errors);
+}

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

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * deslop-validate.js —— 去 AI 味检测器（只读）
+ *
+ * 只检测、不改写。改写由模型按提示词做（插件派活），
+ * 脚本负责判定与仲裁：
+ *   1. 检测 24 类 AI 模式（词表在 ai-patterns.js，唯一真源）
+ *   2. 分级：blocking 命中就判不通过，advisory 只提示
+ *   3. 改写后复扫：blocking 清零才算改干净了
+ *
+ * 为什么不让脚本直接改正文：
+ *   旧实现的 9 条正则替换会把句子改坏（"此外，" 直接删掉，句子就散了）。
+ *   机械替换救不了"AI 腔"—— AI 腔是句式问题，不是词的问题。
+ *
+ * 用法：
+ *   node deslop-validate.js --input=设定/raw/sources/写作/第001章.md
+ *   node deslop-validate.js --input=... --fail-on-blocking
+ *
+ * 退出码：0=通过  1=内容错误（blocking 命中）  2=脚本异常
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { detectAiPatterns, AI_PATTERNS } from './ai-patterns.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ============================================================
+// 参数与 IO
+// ============================================================
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (const arg of args) {
+    const m = arg.match(/^--([\w-]+)=(.+)$/);
+    if (m) {
+      result[m[1]] = m[2];
+    } else if (arg === '--fail-on-blocking') {
+      result.failOnBlocking = true;
+    }
+  }
+  return result;
+}
+
+function readText(p) {
+  try {
+    return { data: fs.readFileSync(p, 'utf-8') };
+  } catch (e) {
+    return { error: '读取失败: ' + e.message };
+  }
+}
+
+function emit(status, file, payload) {
+  const out = Object.assign({ status: status, file: file }, payload);
+  process.stdout.write(JSON.stringify(out, null, 2) + '\n');
+  process.exitCode = status;
+  return out;
+}
+
+// ============================================================
+// 主流程
+// ============================================================
+function validate(args) {
+  if (!args.input) {
+    return emit(2, 'UNKNOWN', {
+      errors: [{ code: 'ARG', path: '--input', message: '缺少 --input', hint: null }],
+      findings: [], byCategory: {}, blockingCount: 0, advisoryCount: 0
+    });
+  }
+
+  const textRes = readText(args.input);
+  if (textRes.error) {
+    return emit(2, path.basename(args.input), {
+      errors: [{ code: 'READ', path: args.input, message: textRes.error, hint: null }],
+      findings: [], byCategory: {}, blockingCount: 0, advisoryCount: 0
+    });
+  }
+
+  const text = textRes.data;
+  let detected;
+  try {
+    detected = detectAiPatterns(text);
+  } catch (e) {
+    return emit(2, path.basename(args.input), {
+      errors: [{ code: 'CHECK_CRASHED', path: args.input, message: '检测器异常: ' + e.message, hint: null }],
+      findings: [], byCategory: {}, blockingCount: 0, advisoryCount: 0
+    });
+  }
+
+  // 每个类目带上改写指引（给模型看）
+  const categories = {};
+  for (const id of Object.keys(detected.byCategory)) {
+    const c = detected.byCategory[id];
+    const def = AI_PATTERNS.find((p) => p.id === id);
+    categories[id] = Object.assign({}, c, {
+      rewrite: def ? def.rewrite : null,
+      no: def ? def.no : null,
+      group: def ? def.group : null
+    });
+  }
+
+  const blocking = detected.blockingCount;
+  const advisory = detected.advisoryCount;
+
+  // 报告按类目聚合：同一类命中多次只列一次，模型改一处就够
+  const errors = [];
+  for (const id of Object.keys(categories)) {
+    const c = categories[id];
+    if (c.severity !== 'blocking') continue;
+    errors.push({
+      code: 'AI_PATTERN_BLOCKING',
+      path: '第 ' + c.matches[0].line + ' 行等 ' + c.count + ' 处',
+      message: '命中 AI 模式「' + c.name + '」（第 ' + c.no + ' 类）' + c.count + ' 次',
+      hint: c.rewrite
+    });
+  }
+  for (const id of Object.keys(categories)) {
+    const c = categories[id];
+    if (c.severity !== 'advisory') continue;
+    errors.push({
+      code: 'AI_PATTERN_ADVISORY',
+      path: '第 ' + c.matches[0].line + ' 行等 ' + c.count + ' 处',
+      message: '命中 AI 模式「' + c.name + '」（第 ' + c.no + ' 类）' + c.count + ' 次',
+      hint: c.rewrite
+    });
+  }
+
+  const failOnBlocking = args.failOnBlocking !== undefined;
+  const status = failOnBlocking && blocking > 0 ? 1 : 0;
+
+  return emit(status, path.basename(args.input), {
+    errors: errors,
+    findings: detected.findings,
+    byCategory: categories,
+    blockingCount: blocking,
+    advisoryCount: advisory,
+    totalCategories: Object.keys(categories).length
+  });
+}
+
+const args = parseArgs();
+validate(args);

package/plugins/fancy-story-builder/scripts/error-classes.js

@@ -0,0 +1,112 @@
+/**
+ * error-classes.js —— 校验错误的分类：内容问题 vs 脚本/环境问题
+ *
+ * 为什么必须分开：
+ *   插件的驱动逻辑是"校验 → 归因 → 重投给模型改"。
+ *   但有些错误**不是模型能改的**：
+ *     GLOSSARY_LOAD  —— 词表文件读不到（部署缺文件）
+ *     FORMULAS_LOAD  —— 公式文件读不到
+ *     TEMPLATE       —— 模板读不到
+ *     READ           —— 产物文件读不到
+ *     ARG            —— 调用参数错
+ *     CHECK_CRASHED  —— 检查器自己抛异常
+ *   这类错甩给模型毫无意义：提示词明确禁止模型改 `模板/` 和 `references/`，
+ *   而且重投多少次结果都一样（模型改不了部署清单）。
+ *
+ *   真实事故：抽出 scripts/skeleton-quota.js 后部署清单没跟着改，
+ *   骨架阶段报 "references/skeleton-quota.js is missing" ——
+ *   这是部署缺陷，不是模型写错了产物，却走进了"重投给模型"的队列。
+ *
+ * 判定标准与 prompt-drift-check.js 共用同一份 INFRA_CODES
+ * （那里用它判断"哪些码不必进提示词的速查表"）：
+ *   INFRA_CODES  → 脚本/环境问题 → **不发给模型**，单独上报
+ *   其余          → 内容问题     → 归因后重投给模型
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * 基础设施类错误码：全部对应"脚本自己出问题"，不是产物内容的问题。
+ *
+ * 判据：这个码出现时，重投给模型不可能改变结果。
+ */
+export const INFRA_CODES = new Set([
+  'ARG', 'READ', 'TEMPLATE', 'GLOSSARY_LOAD', 'FORMULAS_LOAD', 'CHECK_CRASHED',
+  // 插件侧包装出来的两类：校验脚本崩溃 / 输出不是合法 JSON
+  'VALIDATOR_CRASH', 'VALIDATOR_OUTPUT_INVALID',
+  // 驱动层（stage-driver.js）的插件级错误：模型改不了，重投也没用
+  'PROMPT_DELIVERY_FAILED',   // 提示词投递失败
+  'BATCH_SHARD_MISSING',      // 分片文件没写出来
+  'BATCH_SHARD_INVALID',      // 分片文件不是合法 JSON
+  'BATCH_GENERATION_FAILED',  // 整批生成失败
+  'CHECKPOINT_RESTART_LIMIT', // 中途校验重投到上限仍未通过
+  'SETTLED_PRODUCT_TAMPERED', // 模型越权改了已定稿产物（脚本已用分片覆盖回去）
+  'RESTORE_SETTLED_FAILED'    // 恢复已定稿产物失败
+]);
+
+/**
+ * 这个错误码是不是"脚本/环境问题"（不该发给模型）。
+ * @param {string} code
+ * @returns {boolean}
+ */
+export function isInfraCode(code) {
+  if (!code) return false;
+  return INFRA_CODES.has(String(code).trim());
+}
+
+/**
+ * 把一批校验错误分成两类。
+ *
+ * @param {Array} errors 校验器返回的 errors[]
+ * @returns {{infra: Array, content: Array}}
+ *   infra   —— 脚本/环境问题：不重投，单独上报
+ *   content —— 产物内容问题：归因后重投给模型
+ */
+export function classifyIssues(errors) {
+  const infra = [];
+  const content = [];
+  for (const e of Array.isArray(errors) ? errors : []) {
+    if (isInfraCode(e && e.code)) infra.push(e);
+    else content.push(e);
+  }
+  return { infra, content };
+}
+
+/**
+ * 基础设施错误的一句话说明（给用户看的）。
+ * @param {Array} infra classifyIssues 里的 infra 部分
+ * @returns {string}
+ */
+export function describeInfraIssues(infra) {
+  const list = Array.isArray(infra) ? infra : [];
+  if (!list.length) return '';
+  const codes = [];
+  for (const e of list) {
+    const c = (e && e.code) || 'ERROR';
+    if (codes.indexOf(c) < 0) codes.push(c);
+  }
+  return '校验脚本自身出问题（不是生成的文件的问题，模型改不了）：' + codes.join('、');
+}
+
+/**
+ * 把基础设施问题渲染成报告里的一段（三个阶段共用）。
+ *
+ * 单独成段的理由：这类错**没有**重投给模型，
+ * 如果混在"校验错误"里，用户会以为模型下一轮能改好。
+ *
+ * @param {Array} infra classifyIssues 里的 infra 部分
+ * @returns {string[]} markdown 行（空数组 = 没有基础设施问题）
+ */
+export function renderInfraBlock(infra) {
+  const list = Array.isArray(infra) ? infra : [];
+  if (!list.length) return [];
+  const lines = [];
+  lines.push('');
+  lines.push('**校验脚本自身的问题（' + list.length + ' 条）**');
+  lines.push('这些不是生成的文件的问题：模型改不了 `模板/` 和 `references/`，所以没有重投给模型。');
+  for (const e of list.slice(0, 8)) {
+    lines.push('- [' + (e.code || 'ERROR') + '] ' + (e.path || '(无路径)') + '：' + (e.message || ''));
+  }
+  if (list.length > 8) lines.push('- ……还有 ' + (list.length - 8) + ' 条');
+  return lines;
+}