@cloud411716/fancy-webnovel 1.0.46 → 2.2.0

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

@@ -0,0 +1,682 @@
+#!/usr/bin/env node
+/**
+ * 写作阶段校验脚本 v1.2
+ * 源码中零反引号，避免 markdown 渲染问题。
+ *
+ * v1.2 变更（修复批次 P2-1 / P2-9）：
+ * - P2-1：chineseToInt 的 unitMap 补 '万': 10000
+ *   （原版 titlePattern 允许"万"但 unitMap 没有，导致"一万"被解析为 1）
+ * - P2-9：UPSTREAM_PARTIAL 触发条件从 !outline && !avgWords 改为 !outline || !avgWords
+ *   （原版只提供骨架时 avgWords 有值、outline 为空，不会触发提示，
+ *    但实际上缺细纲对照就是上游不完整）
+ *
+ * 保留 v1.1 的 P1-1 修复：
+ * - 章节标题三种格式兼容
+ * - 禁用词与提示词对齐
+ * - countChineseChars 只删行首标题
+ * - EMPTY_BODY
+ * - 删除空函数 compareWithTimeline
+ *
+ * 用法：
+ *   node writing-validate.js \
+ *     --input=设定/raw/sources/写作/第NNN章.md \
+ *     --chapter=N \
+ *     --upstream=设定/raw/sources/骨架,设定/raw/sources/血肉,设定/raw/sources/节奏
+ * 退出码：0=通过  1=内容错误  2=脚本异常
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readStageGate } from './graph-utils.js';
+import { countChapterChars as countChineseChars } from './content-quality.js';
+import {
+  resolveTailHook,
+  resolveHeadHook,
+  resolveMicroPayoff,
+  findHookRepeats,
+  TAIL_HOOK_TYPES,
+  HEAD_HOOK_TYPES,
+  MICRO_PAYOFFS,
+  HOOK_CATEGORIES
+} from './reading-power.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ============================================================
+// 参数解析
+// ============================================================
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = { upstream: [] };
+  for (const arg of args) {
+    // 参数名允许连字符（与 skeleton/flesh/rhythm 三个脚本保持一致），
+    // 否则 --stage-dir 这类参数会被静默丢弃
+    const m = arg.match(/^--([\w-]+)=(.+)$/);
+    if (m) {
+      if (m[1] === 'upstream') {
+        result.upstream.push(...m[2].split(',').map(s => s.trim()).filter(Boolean));
+      } else {
+        result[m[1]] = m[2];
+      }
+    }
+  }
+  return result;
+}
+
+// ============================================================
+// IO
+// ============================================================
+function readJson(p) {
+  if (!fs.existsSync(p)) return { error: '文件不存在: ' + p };
+  try {
+    return { data: JSON.parse(fs.readFileSync(p, 'utf-8')) };
+  } catch (err) {
+    return { error: 'JSON 解析失败: ' + err.message };
+  }
+}
+
+function readText(p) {
+  if (!fs.existsSync(p)) return { error: '文件不存在: ' + p };
+  try {
+    return { data: fs.readFileSync(p, 'utf-8') };
+  } catch (err) {
+    return { error: '读取失败: ' + err.message };
+  }
+}
+
+// ============================================================
+// 中文数字 → 整数
+//
+// 正确实现中文小节记法：
+//   一百零五 = 105   零是"占位"（不占位值）
+//   一千零五 = 1005
+//   十二     = 12    十前面无数字时按 1 处理
+//   二百五十 = 250
+//   十二万   = 120000  万级要把已收拢的小节整体乘 10000
+//
+// 旧实现把"万"当成普通单位直接累加（十二万 → 20010），
+// 且"零"的处理与注释描述相反（一百零五 虽对，零后数字会被清零）。
+// ============================================================
+function chineseToInt(s) {
+  const digitMap = { '零': 0, '一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '七': 7, '八': 8, '九': 9 };
+  const unitMap = { '十': 10, '百': 100, '千': 1000, '万': 10000, '亿': 100000000 };
+  let total = 0;    // 已完成的万/亿级部分
+  let section = 0;  // 当前小节（万以下）
+  let current = 0;  // 当前数字
+  let pendingZero = false;
+  for (const ch of s) {
+    if (digitMap[ch] !== undefined) {
+      if (ch === '零') {
+        pendingZero = true;
+        current = 0;
+      } else {
+        current = digitMap[ch];
+        pendingZero = false;
+      }
+    } else if (unitMap[ch] !== undefined) {
+      const u = unitMap[ch];
+      if (u >= 10000) {
+        // 万/亿：先收拢当前小节，再整体乘以单位
+        section += current;
+        total = (total + section) * u;
+        section = 0;
+      } else {
+        // 十/百/千：前面没有数字时按 1 处理（十二 = 12）
+        section += (current === 0 && !pendingZero ? 1 : current) * u;
+      }
+      current = 0;
+      pendingZero = false;
+    }
+  }
+  return total + section + current;
+}
+
+// ============================================================
+// 字数统计
+// ============================================================
+// 口径统一走 content-quality.js 的 countChapterChars（计入中文标点，
+// 与网文平台的"字数"口径一致）。校验用 ±20% 容差比较 word_target。
+// 导入阶段反推 avg_words_per_chapter 时也用同一个口径 ——
+// 两边口径不一致，导入出来的章会被误报 WORD_COUNT。
+// 反引号字符用 fromCharCode 生成，源码零反引号
+const BT = String.fromCharCode(96);
+const BT3 = BT + BT + BT;
+const BT3_RE = new RegExp(BT3 + '[\\s\\S]*?' + BT3, 'g');
+
+// ============================================================
+// 字符集 / 禁用词
+// ============================================================
+const KOREAN_RE = /[\uAC00-\uD7A3\u1100-\u11FF\u3130-\u318F]/;
+const KANA_RE = /[\u3040-\u309F\u30A0-\u30FF]/;
+// 占位符检测（避免误伤正常散文）：
+// - 方括号占位符 [X]/[Y]/[Z]/[W] 一律算占位符（无歧义）
+// - "待定"/"待确认"/"TBD"/"N/A"/"xxx" 只在"独占一行"时才算占位符。
+//   之前用 /待定/ 全局匹配，正常正文里的"合同上的价格待定"会被误判成占位符并卡住章节。
+//   词表与 content-quality.js（骨架/血肉阶段）的 PLACEHOLDER_TEXTS 对齐：
+//   那边按"整段 token"匹配，所以 xxx 独占一行会被拦；这边原来漏了 xxx，
+//   提示词却写着"xxx 会被 PLACEHOLDER 拦"—— 提示词说一套、代码做一套（2026-10-27 修）。
+const PLACEHOLDER_RE = /\[[XYZW]\]/;
+const PLACEHOLDER_LINE_RE = /^\s*(待确认|待定|待补充|TBD|N\/A|未定|xxx|XXX|xx|XX)\s*$/m;
+
+// 与 04-writing-prompt.md §7.3 和 §11.4 严格一致
+// 注："建议"/"尽量"/"约莫"/"大致" 是小说常用词（对白/叙述），不在禁用清单
+const FORBIDDEN_WORDS = ['基本一致', '无重大问题'];
+
+function textContentCheck(text, errors) {
+  if (KOREAN_RE.test(text)) {
+    const m = text.match(KOREAN_RE);
+    errors.push({ code: 'CHARSET_KO', path: '正文', message: '含韩文: "' + m[0] + '"', hint: null });
+  }
+  if (KANA_RE.test(text)) {
+    const m = text.match(KANA_RE);
+    errors.push({ code: 'CHARSET_JP', path: '正文', message: '含日文假名: "' + m[0] + '"', hint: null });
+  }
+  const placeholderMatch = text.match(PLACEHOLDER_RE) || text.match(PLACEHOLDER_LINE_RE);
+  if (placeholderMatch) {
+    errors.push({ code: 'PLACEHOLDER', path: '正文', message: '含占位符: "' + placeholderMatch[0].trim() + '"', hint: null });
+  }
+  for (const w of FORBIDDEN_WORDS) {
+    if (text.includes(w)) {
+      errors.push({
+        code: 'FORBIDDEN_WORD',
+        path: '正文',
+        message: '含禁用词 "' + w + '"',
+        hint: '这是 AI 分析口吻，不应出现在小说正文'
+      });
+    }
+  }
+}
+
+// ============================================================
+// 格式检查（含章节标题正则 + 正文非空）
+// ============================================================
+function formatCheck(text, chapterN, errors) {
+  const lines = text.split('\n');
+
+  const firstNonEmptyIdx = lines.findIndex(l => l.trim().length > 0);
+  if (firstNonEmptyIdx < 0) {
+    errors.push({ code: 'EMPTY_CHAPTER', path: '全文', message: '章节正文为空', hint: null });
+    return;
+  }
+  const firstNonEmpty = lines[firstNonEmptyIdx];
+
+  // 章节标题：兼容
+  //   # 第1章 <标题>         (阿拉伯数字，不补零)
+  //   # 第001章 <标题>       (阿拉伯数字，三位补零)
+  //   # 第一章 <标题>        (中文数字)
+  // 允许标题前后有空格
+  const titlePattern = /^#\s*第\s*([0-9]+|[零一二三四五六七八九十百千万]+)\s*章/;
+  const titleMatch = firstNonEmpty.match(titlePattern);
+
+  if (!titleMatch) {
+    errors.push({
+      code: 'CHAPTER_TITLE',
+      path: '第一行',
+      message: '第一行应为 "# 第N章 <标题>" 或 "# 第NNN章 <标题>" 或 "# 第X章 <标题>"（X 为中文数字），实际 "' + firstNonEmpty.slice(0, 40) + '"',
+      hint: null
+    });
+  } else {
+    const raw = titleMatch[1];
+    let parsed;
+    if (/^[0-9]+$/.test(raw)) {
+      parsed = parseInt(raw, 10);
+    } else {
+      parsed = chineseToInt(raw);
+    }
+    if (parsed !== chapterN) {
+      errors.push({
+        code: 'CHAPTER_TITLE',
+        path: '第一行',
+        message: '标题中的章号 "' + raw + '"（解析为 ' + parsed + '）与 --chapter=' + chapterN + ' 不一致',
+        hint: null
+      });
+    }
+  }
+
+  // 全文不得再出现其它一级标题（豁免代码块内的 #）
+  const h1Matches = text.replace(BT3_RE, '').match(/^#\s+/gm) || [];
+  if (h1Matches.length > 1) {
+    errors.push({
+      code: 'CHAPTER_TITLE_DUP',
+      path: '全文',
+      message: '出现 ' + h1Matches.length + ' 个一级标题，本章应只有 1 个',
+      hint: '小标题用 ## 或 ###'
+    });
+  }
+
+  // 标题存在但正文为空（去掉标题行后，非空白字符 < 50）
+  const bodyLines = lines.slice(firstNonEmptyIdx + 1);
+  const bodyText = bodyLines.join('\n');
+  const bodyNonSpace = bodyText.replace(/\s+/g, '').length;
+  if (bodyNonSpace < 50) {
+    errors.push({
+      code: 'EMPTY_BODY',
+      path: '正文',
+      message: '标题存在但正文内容过短（非空白字符仅 ' + bodyNonSpace + ' 个，应 >= 50）',
+      hint: null
+    });
+  }
+
+  // 无多余空行（连续 4 个以上换行）
+  const emptyParagraphRuns = text.match(/\n{4,}/g);
+  if (emptyParagraphRuns) {
+    errors.push({
+      code: 'EMPTY_PARAGRAPH',
+      path: '全文',
+      message: '出现连续 ' + emptyParagraphRuns.length + ' 处多余空行（超过 3 个）',
+      hint: null
+    });
+  }
+}
+
+// ============================================================
+// 与细纲对照
+// ============================================================
+function compareWithOutline(text, chapterN, outline, errors, warnings) {
+  if (!outline) {
+    warnings.push({
+      code: 'OUTLINE_MISSING',
+      path: '章节细纲',
+      message: '本章（第 ' + chapterN + ' 章）无细纲，无法做钩子/爽点对照',
+      hint: '重点章应有细纲'
+    });
+    return;
+  }
+
+  if (typeof outline.word_target === 'number') {
+    const actual = countChineseChars(text);
+    const low = Math.round(outline.word_target * 0.8);
+    const high = Math.round(outline.word_target * 1.2);
+    if (actual < low || actual > high) {
+      errors.push({
+        code: 'WORD_TARGET_MISMATCH',
+        path: '正文字数',
+        message: '实际字数 ' + actual + ' 偏离细纲 word_target=' + outline.word_target + ' 超过 ±20% [' + low + ', ' + high + ']',
+        hint: null
+      });
+    }
+  }
+
+  if (outline.hook_strength === '强') {
+    // 钩子须在首/尾 100 字内兑现（见 04-writing-prompt.md §7.3）。
+    // 旧实现取前/后 400 字再判断 length < 50，而正文早已被 EMPTY_BODY 兜底为 >= 50 字符，
+    // 两条检查实际永远不触发（死代码）。这里改成检查首/尾 100 字内的有效内容密度。
+    const HOOK_WINDOW = 100;
+    const HOOK_MIN = 30;
+    const head = text.slice(0, HOOK_WINDOW).replace(/\s+/g, '');
+    const tail = text.slice(-HOOK_WINDOW).replace(/\s+/g, '');
+    if (head.length < HOOK_MIN) {
+      errors.push({
+        code: 'HOOK_HEAD_MISSING', path: '章首',
+        message: '钩子强度为"强"但前 ' + HOOK_WINDOW + ' 字内有效内容不足 ' + HOOK_MIN + ' 字（实际 ' + head.length + '）',
+        hint: '按细纲 hook_head 在章首兑现钩子'
+      });
+    }
+    if (tail.length < HOOK_MIN) {
+      errors.push({
+        code: 'HOOK_TAIL_MISSING', path: '章尾',
+        message: '钩子强度为"强"但末 ' + HOOK_WINDOW + ' 字内有效内容不足 ' + HOOK_MIN + ' 字（实际 ' + tail.length + '）',
+        hint: '按细纲 hook_tail 在章尾兑现钩子'
+      });
+    }
+  }
+}
+
+// ============================================================
+// 与人物档案对照
+// ============================================================
+function compareWithCharacter(text, chapterN, characters, errors, warnings) {
+  if (!characters || !characters.length) return;
+
+  const mentionCount = new Map();
+  for (const c of characters) {
+    if (!c.name) continue;
+    const escaped = c.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(escaped, 'g');
+    const count = (text.match(re) || []).length;
+    if (count > 0) mentionCount.set(c.name, count);
+  }
+  if (mentionCount.size === 0) {
+    warnings.push({
+      code: 'NO_CHARACTER_MENTION',
+      path: '正文',
+      message: '本章未提及任何已建档角色',
+      hint: '除非是纯环境/过渡章，否则应有至少一个角色出现'
+    });
+  } else {
+    // 旧实现算出了每个角色的出现次数却直接丢弃，这里把它用起来：
+    // 列出本章实际出场的角色及出现次数，便于人工核对"该出场的角色是否都出场"。
+    const detail = [...mentionCount.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .map(([name, n]) => name + '×' + n)
+      .join('、');
+    warnings.push({
+      code: 'CHARACTER_MENTION',
+      path: '正文',
+      message: '本章出场角色（按出现次数）：' + detail,
+      hint: null
+    });
+  }
+}
+
+// ============================================================
+// 阅读动力与台账对照（钩子类型 / 钩子重复 / 微兑现 / 死人出场）
+// ============================================================
+
+/**
+ * 人物台账里表示"已死亡"的 status 写法。
+ * 旧 skill 的"死人不再出场"闸门靠这个判定，没有统一枚举，
+ * 所以按关键字兜（模型写"死亡/已死/身亡/阵亡/去世"都算数）。
+ */
+const DEAD_STATUS_RE = /(死亡|已死|身亡|阵亡|去世|殁)/;
+
+/**
+ * 章台账归一化：支持数组与"以 ch 为 key 的对象"两种存法，
+ * 并按 ch 去重、**保留最后一条**。
+ *
+ * 为什么取最后一条：重写某章时台账是"追加"而不是"原地改"，
+ * 同一 ch 会有多条记录。后写的那条才是当前生效的版本。
+ */
+export function normalizeChapterLedger(raw) {
+  let list = [];
+  if (Array.isArray(raw)) list = raw.slice();
+  else if (raw && typeof raw === 'object') {
+    for (const k of Object.keys(raw)) {
+      const v = raw[k];
+      if (v && typeof v === 'object') list.push(Object.assign({ ch: Number(k) }, v));
+    }
+  }
+  const byCh = new Map();
+  for (const e of list) {
+    if (!e || typeof e !== 'object') continue;
+    const ch = Number(e.ch);
+    if (!Number.isInteger(ch)) continue;
+    byCh.set(ch, e);
+  }
+  return Array.from(byCh.values()).sort((a, b) => a.ch - b.ch);
+}
+
+/**
+ * 章台账与阅读动力规则的对账。
+ *
+ * 覆盖旧 skill 的 3 项充分性闸门（见 writing-rules.js COMMIT_GATES）：
+ *   闸门 5 钩子符合 7/13 种 → HOOK_TYPE_INVALID / HOOK_REPEAT
+ *   闸门 6 死人不再出场     → DEAD_CHARACTER_APPEARS
+ * 以及 7 种微兑现（每章至少 1 个）→ MICRO_PAYOFF_MISSING
+ *
+ * 规则表在 reading-power.js（唯一真源），这里只负责对账。
+ */
+function ledgerChecks(stageDir, chapterN, text, errors, warnings) {
+  const ledgerDir = path.join(stageDir, '台账');
+  const chapterRaw = readJson(path.join(ledgerDir, '章台账.json'));
+  const characterRaw = readJson(path.join(ledgerDir, '人物台账.json'));
+
+  const entries = normalizeChapterLedger(chapterRaw.data);
+  const entry = entries.find((e) => e.ch === chapterN) || null;
+
+  if (!entry) {
+    errors.push({
+      code: 'LEDGER_ENTRY_MISSING',
+      path: '台账/章台账.json',
+      message: '第 ' + chapterN + ' 章没有对应的台账条目（写完一章必须更新章台账）',
+      hint: '章台账每章追加一条，含 ch / actual_word_count / hook_head_type / hook_tail_type / micro_payoffs'
+    });
+    return;
+  }
+
+  // ---- 闸门 5a：钩子类型必须在 7 式 / 13 式之内 ----
+  const head = resolveHeadHook(entry.hook_head_type);
+  if (!head) {
+    errors.push({
+      code: 'HOOK_TYPE_INVALID',
+      path: '台账/章台账.json#hook_head_type',
+      message: '章首引子类型 "' + (entry.hook_head_type || '(空)') + '" 不在 7 式章首引子之内',
+      hint: '合法值（id 或中文名）：' + HEAD_HOOK_TYPES.map((h) => h.name).join('、')
+    });
+  }
+  const tail = resolveTailHook(entry.hook_tail_type);
+  if (!tail) {
+    errors.push({
+      code: 'HOOK_TYPE_INVALID',
+      path: '台账/章台账.json#hook_tail_type',
+      message: '章末钩子类型 "' + (entry.hook_tail_type || '(空)') + '" 不在 13 式章末钩子之内',
+      hint: '合法值（id 或中文名）：' + TAIL_HOOK_TYPES.map((h) => h.name).join('、')
+    });
+  }
+
+  // ---- 闸门 5b：不得连续 3 章用同一种钩子 / 同一大分类 ----
+  const repeats = findHookRepeats(entries);
+  for (const rep of repeats.sameType) {
+    if (rep.chapters.indexOf(chapterN) < 0) continue;
+    errors.push({
+      code: 'HOOK_REPEAT',
+      path: '台账/章台账.json#hook_tail_type',
+      message: '第 ' + rep.chapters.join('、') + ' 章连续用了同一种章末钩子（' + rep.value + '），严禁连续 3 章用同一种',
+      hint: '换一种章末钩子；或换一个大分类（' + HOOK_CATEGORIES.join('、') + '）也行'
+    });
+  }
+  for (const rep of repeats.sameCategory) {
+    if (rep.chapters.indexOf(chapterN) < 0) continue;
+    errors.push({
+      code: 'HOOK_REPEAT',
+      path: '台账/章台账.json#hook_tail_type',
+      message: '第 ' + rep.chapters.join('、') + ' 章连续用了同一大分类的章末钩子（' + rep.value + '），读者的感受会重复',
+      hint: '换一个大分类（' + HOOK_CATEGORIES.join('、') + '）'
+    });
+  }
+
+  // ---- 7 种微兑现：每章至少 1 个 ----
+  const payoffs = Array.isArray(entry.micro_payoffs) ? entry.micro_payoffs : [];
+  if (!payoffs.length) {
+    errors.push({
+      code: 'MICRO_PAYOFF_MISSING',
+      path: '台账/章台账.json#micro_payoffs',
+      message: '第 ' + chapterN + ' 章没有登记微兑现，每章至少要有 1 个，否则读者会觉得这章白读',
+      hint: '合法值（id 或中文名）：' + MICRO_PAYOFFS.map((m) => m.name).join('、')
+    });
+  } else {
+    const bad = payoffs.filter((p) => !resolveMicroPayoff(p));
+    if (bad.length) {
+      errors.push({
+        code: 'MICRO_PAYOFF_MISSING',
+        path: '台账/章台账.json#micro_payoffs',
+        message: '微兑现类型不在 7 种之内：' + bad.join('、'),
+        hint: '合法值（id 或中文名）：' + MICRO_PAYOFFS.map((m) => m.name).join('、')
+      });
+    }
+  }
+
+  // ---- 闸门 6：死人不再出场（除非本章登记了复生） ----
+  const characters = (characterRaw.data && typeof characterRaw.data === 'object') ? characterRaw.data : {};
+  const revivals = Array.isArray(entry.revival_events) ? entry.revival_events.join('、') : '';
+  for (const name of Object.keys(characters)) {
+    const c = characters[name];
+    if (!c || typeof c !== 'object') continue;
+    const status = typeof c.status === 'string' ? c.status : '';
+    if (!status || !DEAD_STATUS_RE.test(status)) continue;
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    if (!new RegExp(escaped).test(text)) continue;
+    if (revivals.indexOf(name) >= 0) continue;
+    errors.push({
+      code: 'DEAD_CHARACTER_APPEARS',
+      path: '台账/人物台账.json#' + name,
+      message: '角色「' + name + '」已死亡（status="' + status + '"），却在本章正文里出现',
+      hint: '要么改剧情，要么在本章台账的 revival_events 里登记复生（写清角色名与原因）'
+    });
+  }
+}
+
+// ============================================================
+// 主流程
+// ============================================================
+function emit(status, file, errors, warnings) {
+  const payload = { status: status, file: file, errors: errors, warnings: warnings };
+  process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+  process.exitCode = status;
+  // 返回载荷对象：调用方可能用返回值做守卫（如 `if (err) return err;`），
+  // 返回 undefined 会让守卫失效导致继续执行并二次输出。
+  return payload;
+}
+
+function validate(args) {
+  const errors = [];
+  const warnings = [];
+
+  const chapterN = parseInt(args.chapter, 10);
+  if (!Number.isInteger(chapterN) || chapterN < 1) {
+    return emit(2, 'UNKNOWN', [{ code: 'ARG', path: '--chapter', message: '--chapter 必须是正整数', hint: null }], []);
+  }
+
+  if (!args.input) {
+    return emit(2, 'UNKNOWN', [{ code: 'ARG', path: '--input', message: '缺少 --input', hint: null }], []);
+  }
+
+  if (!args.upstream || args.upstream.length === 0) {
+    return emit(2, 'UNKNOWN', [{ code: 'UPSTREAM_MISSING', path: '', message: '写作阶段必须提供 --upstream=<骨架>,<血肉>,<节奏>', hint: null }], []);
+  }
+
+  // 阶段门禁：骨架/血肉/节奏三个上游都必须已通过全量校验
+  // （此前这个判定只写在提示词里，脚本从不读上游状态）
+  for (const dir of args.upstream) {
+    const g = readStageGate(dir);
+    if (!g.ok) {
+      return emit(2, '第' + chapterN + '章', [{ code: 'UPSTREAM_NOT_PASSED', path: dir, message: g.reason, hint: '请先对上游阶段执行全量校验并通过' }], []);
+    }
+  }
+
+  const textRes = readText(args.input);
+  if (textRes.error) {
+    return emit(2, '第' + chapterN + '章', [{ code: 'READ', path: args.input, message: textRes.error, hint: null }], []);
+  }
+  const text = textRes.data;
+
+  let outline = null;
+  let characters = [];
+  let avgWords = null;
+
+  for (const dir of args.upstream) {
+    const outlineRes = readJson(path.join(dir, '章节细纲.json'));
+    if (outlineRes.data && Array.isArray(outlineRes.data.outlines)) {
+      outline = outlineRes.data.outlines.find(o => o.ch === chapterN) || null;
+    }
+
+    const charRes = readJson(path.join(dir, '角色.json'));
+    if (charRes.data && Array.isArray(charRes.data.characters)) {
+      characters = charRes.data.characters.map(c => ({ name: c.name })).filter(c => c.name);
+    }
+
+    const fwRes = readJson(path.join(dir, '框架.json'));
+    if (fwRes.data && fwRes.data.capacity && fwRes.data.capacity.avg_words_per_chapter) {
+      avgWords = fwRes.data.capacity.avg_words_per_chapter;
+    }
+  }
+
+  // P2-9：outline 或 avgWords 任一缺失就提示上游不完整
+  if (!outline || !avgWords) {
+    warnings.push({
+      code: 'UPSTREAM_PARTIAL',
+      path: '',
+      message: '上游不完整：' + (!outline ? '缺章节细纲' : '') + (!outline && !avgWords ? '、' : '') + (!avgWords ? '缺框架字数基准' : '') + '，无法做完整对照',
+      hint: '确认 --upstream 是否同时包含节奏目录（章节细纲.json）和骨架目录（框架.json）'
+    });
+  }
+
+  // 1. 文本内容检查
+  textContentCheck(text, errors);
+
+  // 2. 格式检查（含章节标题 + 正文非空）
+  formatCheck(text, chapterN, errors);
+
+  // 3. 字数检查
+  const targetAvg = (outline && outline.word_target) || avgWords;
+  if (typeof targetAvg === 'number' && targetAvg > 0) {
+    const actual = countChineseChars(text);
+    const low = Math.round(targetAvg * 0.8);
+    const high = Math.round(targetAvg * 1.2);
+    if (actual < low || actual > high) {
+      const alreadyReported = errors.some(e => e.code === 'WORD_TARGET_MISMATCH');
+      if (!alreadyReported) {
+        errors.push({
+          code: 'WORD_COUNT',
+          path: '正文字数',
+          message: '实际字数 ' + actual + ' 偏离基准 ' + targetAvg + ' 超过 ±20% [' + low + ', ' + high + ']',
+          hint: null
+        });
+      }
+    }
+  }
+
+  // 4. 与细纲对照
+  compareWithOutline(text, chapterN, outline, errors, warnings);
+
+  // 5. 与人物档案对照
+  compareWithCharacter(text, chapterN, characters, errors, warnings);
+
+  // 6. 阅读动力与台账对照（钩子类型 / 钩子重复 / 微兑现 / 死人出场）
+  ledgerChecks(path.dirname(args.input), chapterN, text, errors, warnings);
+
+  // 7. 更新 stage-status
+  const stageDir = path.dirname(args.input);
+  updateChapterStatus(stageDir, chapterN, errors.length === 0 ? 0 : 1);
+
+  emit(errors.length === 0 ? 0 : 1, '第' + chapterN + '章', errors, warnings);
+}
+
+// ============================================================
+// stage-status 更新
+// ============================================================
+function updateChapterStatus(stageDir, chapterN, status) {
+  const statusPath = path.join(stageDir, '.stage-status.json');
+  let s = {
+    stage: '写作',
+    last_check: null,
+    chapters: {},
+    last_passed_chapter: 0,
+    total_chapters: 0
+  };
+  if (fs.existsSync(statusPath)) {
+    try { s = JSON.parse(fs.readFileSync(statusPath, 'utf-8')); } catch (e) {}
+  }
+  // 兜底：旧 status 文件可能缺 chapters / last_passed_chapter / total_chapters 字段
+  s.stage = s.stage || '写作';
+  s.chapters = s.chapters || {};
+  s.last_passed_chapter = typeof s.last_passed_chapter === 'number' ? s.last_passed_chapter : 0;
+  s.total_chapters = typeof s.total_chapters === 'number' ? s.total_chapters : Object.keys(s.chapters).length;
+  s.last_check = new Date().toISOString();
+  s.chapters[chapterN] = {
+    status: status === 0 ? 'PASSED' : 'FAILED',
+    last_check: new Date().toISOString()
+  };
+  // 连续通过的最大章号：写作阶段的完本判定是 last_passed_chapter === T，
+  // 因此必须要求 1..T 全部连续通过。
+  // 旧实现取"最大通过章号"，导致第 3 章失败、第 5 章通过时 last_passed_chapter=5，
+  // 缺口被掩盖，下游会误判为"已完本且全部通过"。
+  let contiguous = 0;
+  while (s.chapters[String(contiguous + 1)] && s.chapters[String(contiguous + 1)].status === 'PASSED') {
+    contiguous++;
+  }
+  s.last_passed_chapter = contiguous;
+  s.max_passed_chapter = Math.max(
+    contiguous,
+    ...Object.entries(s.chapters)
+      .filter(([, v]) => v && v.status === 'PASSED')
+      .map(([k]) => Number(k) || 0)
+  );
+  s.failed_chapters = Object.entries(s.chapters)
+    .filter(([, v]) => v && v.status !== 'PASSED')
+    .map(([k]) => Number(k) || 0)
+    .sort((a, b) => a - b);
+  s.total_chapters = Object.keys(s.chapters).length;
+  try { fs.writeFileSync(statusPath, JSON.stringify(s, null, 2), 'utf-8'); } catch (e) {}
+}
+
+// ============================================================
+// 入口
+// ============================================================
+function main() {
+  const args = parseArgs();
+  return validate(args);
+}
+
+main();