@cloud411716/fancy-webnovel 1.0.46 → 3.0.0

package/plugins/fancy-scan/scripts/report-validate.js

@@ -0,0 +1,824 @@
+/**
+ * report-validate.js —— 扫榜报告正文的**机械校验**
+ *
+ * ## 定位
+ *
+ * 只校验**能被机械判定**的东西：章节在不在、表头对不对、方向几个、
+ * 标签齐不齐、字数够不够、有没有占位符、有没有命令痕迹。
+ *
+ * **不**校验"洞察深不深""选题好不好" —— 那是模型的事。
+ * 脚本一旦开始管内容质量，模型就会为了过校验而写废话。
+ *
+ * ## 谁在用
+ *
+ *   - `scripts/append-block.js`：写之前校验（不合格根本不碰目标文件）；
+ *   - `plugins/fancy-scan/index.js`：模型回合结束后再复核一次
+ *     （哪怕模型绕过脚本，插件也会发现并告诉用户）。
+ *
+ * 两边共用这一份实现，口径不会漂。
+ */
+import { existsSync, readFileSync, openSync, readSync, closeSync, statSync } from 'fs';
+import { basename } from 'path';
+import { createHash } from 'crypto';
+import {
+  SECTION_TITLES,
+  REPORT_RULES,
+  tableHeaders,
+  TABLE_SEP_RE,
+  DIRECTION_RE,
+  DIRECTION_LABELS,
+} from '../templates/report-schema.js';
+
+/**
+ * 文件**前 n 字节**的 sha256。
+ *
+ * 用来证明"写之前就有的内容一个字节都没被动过"——
+ * 写完之后重新算一遍同样长度的前缀，哈希必须一模一样。
+ */
+export function hashPrefix(path, nBytes) {
+  if (!existsSync(path) || !nBytes) return '';
+  const fd = openSync(path, 'r');
+  try {
+    const h = createHash('sha256');
+    const chunk = Buffer.alloc(64 * 1024);
+    let read = 0;
+    while (read < nBytes) {
+      const want = Math.min(chunk.length, nBytes - read);
+      const got = readSync(fd, chunk, 0, want, read);
+      if (got <= 0) break;
+      h.update(chunk.subarray(0, got));
+      read += got;
+    }
+    return h.digest('hex');
+  } finally {
+    closeSync(fd);
+  }
+}
+
+/** 记下文件此刻的状态（写之前存一份，写之后用来比对） */
+export function captureFileState(path) {
+  if (!existsSync(path)) return { size: 0, hash: '' };
+  let size = 0;
+  try {
+    size = statSync(path).size;
+  } catch {
+    return { size: 0, hash: '' };
+  }
+  return { size, hash: hashPrefix(path, size) };
+}
+
+/** 数汉字（CJK 统一表意文字，含扩展 A） */
+export function cjkCount(text) {
+  let n = 0;
+  for (const ch of String(text)) {
+    const c = ch.codePointAt(0);
+    if ((c >= 0x4e00 && c <= 0x9fff) || (c >= 0x3400 && c <= 0x4dbf)) n++;
+  }
+  return n;
+}
+
+/**
+ * 读数据文件头部的 `抓取时间` / `条目数`。
+ *
+ * 报告必须引用**当前文件**的抓取时间：模型在同一会话里连续跑多个回合时，
+ * 很容易直接复用上一轮上下文里的旧数字（实测 91f7ae4e 第三轮就这样），
+ * 而数据文件可能已经被重新采集覆盖。时间戳是最便宜、最确定的对账锚点。
+ */
+/** 把“12.3万”“1,234”“1234”统一成数字；解析不了返回 null */
+function parseMetricValue(raw) {
+  const s = String(raw || '').replace(/[,，\s]/g, '');
+  const m = s.match(/(\d+(?:\.\d+)?)\s*(万|亿)?/);
+  if (!m) return null;
+  let n = Number(m[1]);
+  if (m[2] === '万') n *= 10000;
+  if (m[2] === '亿') n *= 100000000;
+  return Number.isFinite(n) ? n : null;
+}
+
+function escapeRe(s) {
+  return String(s || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * 从引用括号里取主指标值。
+ *
+ * 先找“月票/在读/积分/热度 + 数字”的形式（最精确），没有再按
+ * 张/人/分/积分/热度 这些单位找。这样起点的“19245 张”、番茄的
+ * “在读 59.8万”、晋江的“积分 1053978496 分”、七猫的“热度 3853.8万”
+ * 都能对账；不认识的写法返回 null，避免误报。
+ */
+function extractMetricValue(text, metricLabel) {
+  const label = String(metricLabel || '').trim();
+  if (label) {
+    const re = new RegExp(escapeRe(label) + '\\s*[：:]?\\s*(\\d+(?:\\.\\d+)?\\s*(?:万|亿)?)', 'g');
+    const hits = [...String(text || '').matchAll(re)];
+    if (hits.length) return parseMetricValue(hits[hits.length - 1][1]);
+  }
+  const unitRe = /(\d+(?:\.\d+)?\s*(?:万|亿)?)\s*(?:张|人|分|积分|热度)/g;
+  const hits = [...String(text || '').matchAll(unitRe)];
+  if (hits.length) return parseMetricValue(hits[hits.length - 1][1]);
+  return null;
+}
+
+export function readDataFileHeaders(paths, metricLabel = '月票', knownLists = []) {
+  const out = [];
+  // 字段行现在统一是 Markdown 列表项：`- **月票：** 100`。
+  // 兼容旧产物（没有 `- ` 前缀），否则引用对账会读不到指标值。
+  const metricRe = new RegExp(
+    '^(?:-\\s+)?\\*\\*' + escapeRe(metricLabel) + '：\\*\\*\\s*(.+)$'
+  );
+  for (const p of Array.isArray(paths) ? paths : []) {
+    try {
+      const text = readFileSync(p, 'utf-8');
+      const lines = text.split('\n');
+      const head = lines.slice(0, 20).join('\n');
+      const tm = /抓取时间\s*[：:]\s*([^\s]+)/.exec(head);
+      const cm = /条目数\s*[：:]\s*(\d+)/.exec(head);
+      const titleLine = lines.find(l => /^#\s+/.test(l)) || '';
+      // 平台文件头不一定是「# 平台 · 榜单」：
+      //   番茄  # 番茄 · 男频阅读榜 · 全 N 题材
+      //   七猫  # 七猫 · 男生 · 大热月榜
+      // 先用 manifest 里的全部榜单名做最长匹配，匹配不到再退回第一段。
+      const norm = s => String(s || '').replace(/[·\s]/g, '');
+      const known = Array.isArray(knownLists) ? knownLists : [];
+      let list = '';
+      let listNorm = '';
+      for (const label of known) {
+        const n = norm(label);
+        if (n && norm(titleLine).includes(n) && n.length > listNorm.length) {
+          list = label;
+          listNorm = n;
+        }
+      }
+      if (!list) {
+        const lm = /^#\s*[^·]*·\s*(.+?)\s*$/.exec(titleLine);
+        list = lm ? lm[1].trim() : '';
+      }
+      const books = new Map();
+      let cur = null;
+      for (const line of lines) {
+        const bm = /^#{2,3} #(\d+) (.+)$/.exec(line);
+        if (bm) {
+          cur = { rank: Number(bm[1]), value: null };
+          books.set(bm[2].trim(), cur);
+          continue;
+        }
+        if (!cur) continue;
+        const vm = metricRe.exec(line);
+        if (vm) cur.value = parseMetricValue(vm[1]);
+      }
+      out.push({
+        path: p,
+        name: basename(p),
+        list,
+        time: tm ? tm[1] : '',
+        count: cm ? cm[1] : '',
+        books,
+      });
+    } catch {
+      // 读不了的文件由预检负责，不在正文校验里重复报错
+    }
+  }
+  return out;
+}
+
+/** 表头行 → 归一化的列名（去掉首尾竖线、每列去空白、用 `|` 连接） */
+function normalizeHeader(line) {
+  return String(line).replace(/^\s*\|/, '').replace(/\|\s*$/, '')
+    .split('|')
+    .map(s => s.trim())
+    .join('|');
+}
+
+/** 是不是表格分隔行 */
+function isTableSep(line) {
+  return TABLE_SEP_RE.test(line);
+}
+
+/**
+ * 校验一份报告正文。
+ *
+ * @param {string} body 报告正文（**不含** start/end 标记行）
+ * @param {Object} opts
+ * @param {string} opts.metricLabel 热度指标名（如"月票"、"在读"）
+ * @param {boolean} opts.grouped 数据是否按题材分组（番茄/晋江）
+ * @returns {{ok: boolean, errors: string[], warnings: string[], stats: Object}}
+ */
+export function validateReportBody(body, opts = {}) {
+  const metricLabel = opts.metricLabel || '月票';
+  const grouped = !!opts.grouped;
+  const multiList = !!opts.multiList;
+  const R = REPORT_RULES;
+
+  const text = String(body || '');
+  const lines = text.split('\n');
+  const errors = [];
+  const warnings = [];
+
+  // 乱码替换字符 U+FFFD：模型输出/传输被截断或按错误编码解码时会出现。
+  // 它不影响章节/字数等结构校验，但读者会看到“��推荐”这种坏字，
+  // 所以必须当成正文不合格拦下来，而不是沉默写进报告。
+  const replacementChars = (text.match(/\uFFFD/g) || []).length;
+  if (replacementChars) {
+    errors.push(`正文里有 ${replacementChars} 个乱码替换字符（\uFFFD）—— 内容在生成/传输中损坏，请重新生成这一段`);
+  }
+
+  // 数据文件可能在本轮开始前被重新采集覆盖。报告必须引用**当前文件**
+  // 的抓取时间；只靠提示词说"不要用对话历史"挡不住模型复用旧快照。
+  const dataHeaders = readDataFileHeaders(opts.dataFiles, metricLabel, opts.knownLists);
+  for (const dh of dataHeaders) {
+    if (dh.time && !text.includes(dh.time)) {
+      errors.push(`正文没有引用数据文件 ${dh.name} 的抓取时间 ${dh.time}`
+        + ' —— 可能用了对话历史里的旧快照；请重新读文件开头，'
+        + '把每个数据文件的抓取时间原样写进“一、数据与方法”');
+    }
+  }
+
+  // ── 单榜报告不能比较另一个榜单 ────────────────────────────────
+  // 单榜提示词明确说"没有第二个榜单可比"。模型仍可能引用目标文件里
+  // 已有的其它榜单块（实测 29cfc65f 的推荐榜块就这样），这里直接拒收。
+  if (!multiList && dataHeaders.length === 1 && dataHeaders[0].list) {
+    const own = dataHeaders[0].list;
+    const fallbackKnown = [
+      '畅销榜', '月票榜', '阅读榜', '书友榜', '推荐榜', '更新榜',
+      '签约榜', '新书榜', '新人作者榜', '新书月榜', '完本榜', '收藏榜',
+      '男频阅读榜', '男频新书榜', '女频阅读榜', '女频新书榜',
+      '月榜', '总分榜', '季度榜', '新晋作者榜',
+      '男生大热月榜', '男生新书月榜', '女生大热月榜', '女生新书月榜',
+    ];
+    const known = Array.isArray(opts.knownLists) && opts.knownLists.length
+      ? opts.knownLists
+      : fallbackKnown;
+    for (const label of known) {
+      if (label === own) continue;
+      let pos = 0;
+      while ((pos = text.indexOf(label, pos)) >= 0) {
+        const before = text.slice(Math.max(0, pos - 10), pos);
+        pos += label.length;
+        // “不是月票榜 / 不引用月票榜”这类否定说明不是跨榜比较
+        if (/(不是|而非|不引用|不比较|不参考|没有|不含)/.test(before)) continue;
+        errors.push(`单榜报告只允许分析「${own}」，但正文提到了另一个榜单「${label}」`
+          + ' —— 单榜数据不能与其它榜单比较');
+        break;
+      }
+    }
+  }
+
+  // ── 引用榜单值对账 ────────────────────────────────────────────
+  // 正文写 `《书名》（阅读榜第 15 名，86408 张）` 时，必须与当前
+  // 阅读榜数据文件里的名次/月票一致。只检查**明确写了榜单**的引用；
+  // `榜内第 N 名` 只在单榜时按唯一数据文件核对，多榜时无法归因，跳过。
+  const fileByList = new Map();
+  for (const dh of dataHeaders) {
+    if (dh.list && !fileByList.has(dh.list)) fileByList.set(dh.list, dh);
+  }
+  const citeCheckRe = /《([^》]+)》（([^）\n]{0,260})）/g;
+  let citeHit;
+  while ((citeHit = citeCheckRe.exec(text))) {
+    const title = citeHit[1].trim();
+    const inside = citeHit[2];
+    const lm = /([^\s，,。；;]{1,16}榜)第\s*(\d+)\s*名/.exec(inside);
+    let target = null;
+    let rank = null;
+    if (lm) {
+      const label = lm[1].split('·').pop();
+      target = fileByList.get(label) || null;
+      rank = Number(lm[2]);
+    } else if (!multiList && dataHeaders.length === 1 && inside.includes('榜内第')) {
+      target = dataHeaders[0];
+      const rm = /榜内第\s*(\d+)\s*名/.exec(inside);
+      rank = rm ? Number(rm[1]) : null;
+    }
+    if (!target || !rank) continue;
+    const value = extractMetricValue(inside, metricLabel);
+    if (value === null) continue;
+    const book = target.books.get(title);
+    if (!book) {
+      errors.push(`引用对账失败：《${title}》不在「${target.list}」数据文件里`);
+      continue;
+    }
+    if (book.rank !== rank) {
+      errors.push(`引用对账失败：《${title}》在「${target.list}」是第 ${book.rank} 名，`
+        + `正文写第 ${rank} 名`);
+    }
+    if (book.value !== null && value !== null && book.value !== value) {
+      errors.push(`引用对账失败：《${title}》在「${target.list}」是 ${book.value}（${metricLabel}），`
+        + `正文写 ${value}`);
+    }
+  }
+
+  // ── 1. 章节标题 ────────────────────────────────────────────────
+  let cursor = -1;
+  let foundSections = 0;
+  for (const title of SECTION_TITLES) {
+    const want = '## ' + title;
+    const idx = lines.findIndex((l, i) => i > cursor && l.trim() === want);
+    if (idx < 0) {
+      errors.push(`缺章节标题「${want}」（七个章节必须齐全且按序出现）`);
+    } else {
+      cursor = idx;
+      foundSections++;
+    }
+  }
+
+  // 多榜单时，市场结构里必须有一节“榜单间结构”；
+  // 单榜单没有第二个榜可比，不强制。
+  if (multiList) {
+    const secStart = lines.findIndex(l => l.trim() === '## 二、市场结构（单日快照）');
+    const secEnd = lines.findIndex((l, i) => i > secStart && /^##\s+三、/.test(l));
+    const scope = secStart >= 0 ? lines.slice(secStart, secEnd >= 0 ? secEnd : lines.length) : [];
+    if (!scope.some(l => /^#{3,4}\s*榜单间结构\s*$/.test(l.trim()))) {
+      errors.push('多榜单报告缺「### 榜单间结构」小节（二、市场结构里必须回答跨榜重合度/名次差/题材分布）');
+    }
+  }
+
+  // ── 2. 方向标题 ────────────────────────────────────────────────
+  const dirPos = [];
+  lines.forEach((l, i) => { if (DIRECTION_RE.test(l)) dirPos.push(i); });
+  if (dirPos.length < R.minDirections || dirPos.length > R.maxDirections) {
+    errors.push(`方向个数是 ${dirPos.length}，要求 ${R.minDirections}-${R.maxDirections} 个（标题格式 \`### 方向 N：名称\`）`);
+  }
+  const dirNums = dirPos.map(i => Number(DIRECTION_RE.exec(lines[i])[1]));
+  dirNums.forEach((n, k) => {
+    if (n !== k + 1) {
+      errors.push(`方向序号不连续：第 ${k + 1} 个方向写的是「${n}」，序号要从 1 连续编号`);
+    }
+  });
+  // 形如 `### 方向 3X：…` 的变体 —— 它不会被算成方向（正则要求数字+冒号），
+  // 但说明标题写歪了，静默忽略会让方向数莫名其妙少一个。
+  const badDir = lines.find(l => /^###\s*方向/.test(l) && !DIRECTION_RE.test(l));
+  if (badDir) {
+    errors.push(`方向标题格式不对：「${badDir.trim().slice(0, 30)}」`
+      + ' —— 必须写成 `### 方向 N：名称`（N 是连续数字）');
+  }
+
+  // ── 3. 每个方向的 11 项标签 ───────────────────────────────────
+  const tagStats = [];
+  dirPos.forEach((start, k) => {
+    const end = k + 1 < dirPos.length ? dirPos[k + 1] : lines.length;
+    const section = lines.slice(start, end);
+    let okTags = 0;
+    for (const lab of DIRECTION_LABELS) {
+      const re = new RegExp(
+        '^\\s*[-*+]?\\s*\\*\\*' + lab.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\*\\*\\s*[:：]\\s*(.+)$'
+      );
+      const hit = section.map(l => re.exec(l)).find(Boolean);
+      if (!hit) {
+        errors.push(`方向 ${k + 1} 缺标签「${lab}」（11 项必须齐全，格式 \`- **${lab}**：内容\`）`);
+        continue;
+      }
+      const chars = cjkCount(hit[1]);
+      if (chars < R.minTagChars) {
+        errors.push(`方向 ${k + 1} 的「${lab}」只有 ${chars} 个汉字（要求 ≥${R.minTagChars}，不能只写个标签名充数）`);
+      } else {
+        okTags++;
+      }
+    }
+    tagStats.push({ direction: k + 1, okTags, total: DIRECTION_LABELS.length });
+  });
+
+  // ── 4. 字数 ────────────────────────────────────────────────────
+  const totalCjk = cjkCount(text);
+  if (totalCjk < R.minCjkTotal || totalCjk > R.maxCjkTotal) {
+    errors.push(`正文汉字数 ${totalCjk}，要求 ${R.minCjkTotal}-${R.maxCjkTotal}`);
+  }
+
+  // 纯正文：排除表格行、标题行、分隔线、标签行
+  const pureLines = lines.filter(l => {
+    const t = l.trim();
+    if (!t) return false;
+    if (t.startsWith('#')) return false;
+    if (t.startsWith('|')) return false;
+    if (isTableSep(t)) return false;
+    if (/^[-*_]{3,}$/.test(t)) return false;
+    // 标签行（`- **定位**：…`）不算"正文"
+    if (/^\s*[-*+]?\s*\*\*[^*]+\*\*\s*[:：]/.test(l)) return false;
+    return true;
+  });
+  const pureCjk = cjkCount(pureLines.join('\n'));
+  if (pureCjk < R.minPureCjk) {
+    errors.push(`去掉表格/标题/标签行之后只剩 ${pureCjk} 个汉字（要求 ≥${R.minPureCjk}，正文不能全靠表格撑着）`);
+  }
+
+  // ── 5. 表格 ────────────────────────────────────────────────────
+  const headers = tableHeaders(metricLabel, grouped);
+  // 表头里的空格不能参与比较：模型写 `题材|书目数|…` 也算同一张表。
+  // 这里必须先归一化再和 `head` 比 —— 之前拿归一化后的 head 去比
+  // 带空格的原始表头，导致下面的行级检查（"全部"行、份额列）全是死代码。
+  const normalizedHeaders = Object.fromEntries(
+    Object.entries(headers).map(([k, v]) => [k, normalizeHeader(v)])
+  );
+  const foundTables = [];
+  const topicTables = [];
+  const competitionTables = [];
+  let choiceTableRows = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!isTableSep(lines[i])) continue;
+    const head = normalizeHeader(lines[i - 1] || '');
+    const rows = [];
+    let j = i + 1;
+    while (j < lines.length && lines[j].trim().startsWith('|')) {
+      rows.push(normalizeHeader(lines[j]));
+      j++;
+    }
+    foundTables.push({ head, rows });
+    if (head === normalizedHeaders.topic) topicTables.push(rows);
+    if (head === normalizedHeaders.competition) competitionTables.push(rows);
+    if (head === normalizedHeaders.choice) choiceTableRows = rows;
+  }
+  if (foundTables.length < R.minTables) {
+    errors.push(`只有 ${foundTables.length} 张表，要求 ≥${R.minTables} 张`);
+  }
+  for (const key of Object.keys(headers)) {
+    if (!foundTables.some(t => t.head === normalizedHeaders[key])) {
+      errors.push(`缺表头「${headers[key]}」这张表（表头必须逐字一致）`);
+    }
+  }
+  // 题材表里不能有"全部"汇总行（它不是题材）。
+  // 多榜单报告可能有两张题材表（每榜一张），每张都要查。
+  for (const rows of topicTables) {
+    const hit = rows.find(r => r.split('|').some(c => c.trim() === '全部'));
+    if (hit) {
+      errors.push('题材表里有「全部」这一行 —— 它是汇总不是题材，必须去掉');
+    }
+    if (rows.length < 3) {
+      errors.push(`题材表只有 ${rows.length} 行数据，至少要有 3 个题材`);
+    }
+  }
+  for (const rows of competitionTables) {
+    const hit = rows.find(r => r.split('|').some(c => c.trim() === '全部'));
+    if (hit) {
+      errors.push('竞争度表里有「全部」这一行 —— 它是汇总不是题材，必须去掉');
+    }
+  }
+
+  // 份额列必须是百分比。样本量不足只影响头部集中度/同质化程度/差异化空间三项，
+  // 不影响"该题材总量 ÷ 样本内总量"这个可算的数；写成"3 本仅描述"
+  // 会让同一列里一半是比例、一半是说明，列名与内容对不上。
+  const shareRe = /^(?:<|≤)?\d+(?:\.\d+)?%(?:\s*[（(](?:高|中|低)[）)])?$/;
+  const shareName = grouped ? '需求份额' : '样本内份额';
+  function checkShareCells(rows, headerText, tableName) {
+    const cols = headerText.split('|').map(s => s.trim());
+    const idx = cols.indexOf(shareName);
+    if (idx < 0) return;
+    rows.forEach((row, ri) => {
+      const cells = row.split('|').map(s => s.trim());
+      const val = (cells[idx] || '').trim();
+      if (!shareRe.test(val)) {
+        errors.push(`${tableName}第 ${ri + 1} 行「${shareName}」不是百分比：「${val || '（空）'}」`
+          + ' —— 样本量不足只影响其余指标，份额仍要按总量计算');
+      }
+    });
+  }
+  for (const rows of topicTables) checkShareCells(rows, headers.topic, '题材表');
+  for (const rows of competitionTables) checkShareCells(rows, headers.competition, '竞争度表');
+
+  // 份额的高/中/低必须按 n 的三分位切：前 ⌊n/3⌋ 高、后 ⌊n/3⌋ 低、
+  // 中间为中。只核对“所有行都带档位”的表，避免把没写档位的旧报告误判。
+  function checkShareTiers(rows, headerText, tableName) {
+    const cols = headerText.split('|').map(s => s.trim());
+    const idx = cols.indexOf(shareName);
+    if (idx < 0) return;
+    const tiers = [];
+    for (const row of rows) {
+      const cells = row.split('|').map(s => s.trim());
+      const m = /^(?:<|≤)?\d+(?:\.\d+)?%[（(](高|中|低)[）)]$/.exec(cells[idx] || '');
+      if (!m) return;
+      tiers.push(m[1]);
+    }
+    const n = tiers.length;
+    if (n < 3) return;
+    const edge = Math.floor(n / 3);
+    const want = { 高: edge, 低: edge, 中: n - edge * 2 };
+    const got = { 高: 0, 中: 0, 低: 0 };
+    for (const t of tiers) got[t]++;
+    if (got.高 !== want.高 || got.中 !== want.中 || got.低 !== want.低) {
+      errors.push(`${tableName}的高/中/低分档数量是 高${got.高}/中${got.中}/低${got.低}，`
+        + `按 ${n} 个题材应为 高${want.高}/中${want.中}/低${want.低}`
+        + '（前 ⌊n/3⌋ 高、后 ⌊n/3⌋ 低、其余为中）');
+    }
+  }
+  for (const rows of topicTables) checkShareTiers(rows, headers.topic, '题材表');
+  for (const rows of competitionTables) checkShareTiers(rows, headers.competition, '竞争度表');
+
+  // 头部集中度 / 同质化程度的阈值是 0.8 / 0.7，所以表里必须写
+  // 0–1 的小数（0.56、0.4286），不能写 56.07% / 42.86%。
+  // 百分比写法会被读者当成 56.07 去比 0.8，和"（中）"的档位自相矛盾。
+  const fractionRe = /^(?:0|1)(?:\.\d+)?\s*(?:[（(](?:高|中|低|只描述|仅描述)[）)])?$/;
+  const smallSample = '样本不足';
+  for (const rows of competitionTables) {
+    rows.forEach((row, ri) => {
+      const cells = row.split('|').map(s => s.trim());
+      const checks = [
+        [2, '头部集中度'],
+        [3, '同质化程度'],
+      ];
+      for (const [idx, label] of checks) {
+        const val = (cells[idx] || '').trim();
+        if (val === smallSample) continue;
+        // 3-4 本只描述时允许写“只描述/仅描述”，样本量检查会确保
+        // 只有 3-4 本才能用这两个词。
+        if (val === '只描述' || val === '仅描述') continue;
+        if (!fractionRe.test(val)) {
+          errors.push(`竞争度表第 ${ri + 1} 行「${label}」应写 0–1 的小数、`
+            + `“只描述”或“样本不足”，不能写百分比，也不能在数值后加说明：「${val || '（空）'}」`);
+        }
+      }
+    });
+  }
+
+  // 样本量口径：≥5 正常打分；3-4 只描述（数值或“只描述”），
+  // <3 头部集中度/同质化程度/差异化空间三项“样本不足”；份额列仍按总量算。
+  // 题材数从题材表取，若有多张题材表，选与竞争度表题材重合最多的一张。
+  function parseTopicCounts(rows) {
+    const cols = headers.topic.split('|').map(s => s.trim());
+    const gi = cols.indexOf('题材');
+    const ci = cols.indexOf('书目数');
+    if (gi < 0 || ci < 0) return null;
+    const map = new Map();
+    for (const row of rows) {
+      const cells = row.split('|').map(s => s.trim());
+      const genre = cells[gi];
+      const n = Number(cells[ci]);
+      if (genre && Number.isFinite(n)) map.set(genre, n);
+    }
+    return map;
+  }
+  const countTables = topicTables.map(parseTopicCounts).filter(Boolean);
+  for (const rows of competitionTables) {
+    let counts = null;
+    let best = -1;
+    for (const map of countTables) {
+      let score = 0;
+      for (const row of rows) {
+        const genre = row.split('|')[0].trim();
+        if (map.has(genre)) score++;
+      }
+      if (score > best) {
+        best = score;
+        counts = map;
+      }
+    }
+    if (!counts) continue;
+    rows.forEach((row, ri) => {
+      const cells = row.split('|').map(s => s.trim());
+      const genre = cells[0];
+      const n = counts.get(genre);
+      if (!n) return;
+      const head = cells[2] || '';
+      const hom = cells[3] || '';
+      const diff = cells[4] || '';
+      const isSampleInsufficient = v => v.startsWith('样本不足');
+      const isDescribe = v => v.includes('只描述') || v.includes('仅描述');
+      if (n < 3) {
+        for (const [idx, label] of [[2, '头部集中度'], [3, '同质化程度'], [4, '差异化空间']]) {
+          if (!isSampleInsufficient(cells[idx] || '')) {
+            errors.push(`竞争度表第 ${ri + 1} 行「${label}」：${genre} 只有 ${n} 本`
+              + '（<3），必须写“样本不足”');
+          }
+        }
+      } else if (n <= 4) {
+        for (const [idx, label] of [[2, '头部集中度'], [3, '同质化程度']]) {
+          if (isSampleInsufficient(cells[idx] || '')) {
+            errors.push(`竞争度表第 ${ri + 1} 行「${label}」：${genre} 有 ${n} 本`
+              + '（3-4 本档），只能描述，不能写“样本不足”');
+          }
+        }
+        if (isSampleInsufficient(diff) || /^(高|中|低)/.test(diff)) {
+          errors.push(`竞争度表第 ${ri + 1} 行「差异化空间」：${genre} 有 ${n} 本`
+            + '（3-4 本档），只能写“只描述/仅描述”，不能打分或写“样本不足”');
+        }
+      } else {
+        for (const [idx, label] of [[2, '头部集中度'], [3, '同质化程度']]) {
+          if (isSampleInsufficient(cells[idx] || '') || isDescribe(cells[idx] || '')) {
+            errors.push(`竞争度表第 ${ri + 1} 行「${label}」：${genre} 有 ${n} 本`
+              + '（≥5 本档），必须正常打分，不能只描述');
+          }
+        }
+        if (isSampleInsufficient(diff) || isDescribe(diff) || !/^(高|中|低)/.test(diff)) {
+          errors.push(`竞争度表第 ${ri + 1} 行「差异化空间」：${genre} 有 ${n} 本`
+            + '（≥5 本档），必须给高/中/低，不能只描述');
+        }
+      }
+    });
+  }
+
+  // 选题对比表的“优先级”列必须是名次 1..N（从上到下递增），
+  // 不是加权总分。之前模型在列里填 4.44 / 3.83，读者无法一眼看出排名。
+  if (choiceTableRows.length) {
+    const nums = choiceTableRows.map(row => {
+      const cells = row.split('|').map(s => s.trim());
+      return Number(cells[cells.length - 1]);
+    });
+    const valid = nums.every((p, i) => Number.isInteger(p) && p === i + 1);
+    if (!valid) {
+      errors.push(`选题对比表的“优先级”列必须是 1–${choiceTableRows.length} 的名次`
+        + `（从上到下递增），当前是 ${nums.map(x => Number.isFinite(x) ? x : '空').join('/')}`);
+    }
+  }
+
+  // 优先级打分是自由文本，但常见写法是
+  // "方向 N ... a/b/c/待确认，加权后为 X"。
+  // 能解析就核对算术与排序；解析不到就跳过（不因为写法不同而误报）。
+  const scoreRows = [];
+  for (const chunk of text.split(/[；;\n]/)) {
+    const m = chunk.match(
+      /方向\s*(\d+)[^。；\n]{0,60}?(\d+)\s*\/\s*(\d+)\s*\/\s*(\d+)[^。；\n]{0,60}?加权后为\s*(\d+(?:\.\d+)?)/
+    );
+    if (!m) continue;
+    const scores = [Number(m[2]), Number(m[3]), Number(m[4])];
+    const expected = Math.round(
+      ((scores[0] * 40 + scores[1] * 25 + scores[2] * 25) / 90) * 100
+    ) / 100;
+    scoreRows.push({
+      direction: Number(m[1]),
+      scores,
+      stated: Number(m[5]),
+      expected,
+    });
+  }
+  for (const r of scoreRows) {
+    if (Math.abs(r.expected - r.stated) > 0.011) {
+      warnings.push(`优先级打分算术不一致：方向 ${r.direction} 的 ${r.scores.join('/')}`
+        + ` 按 90% 归一化应为 ${r.expected.toFixed(2)}，正文写 ${r.stated.toFixed(2)}`);
+    }
+  }
+  if (scoreRows.length > 1 && choiceTableRows.length) {
+    const priorityByDir = new Map();
+    for (const row of choiceTableRows) {
+      const cells = row.split('|').map(s => s.trim());
+      if (cells.length < 2) continue;
+      const dm = /^方向\s*(\d+)/.exec(cells[0]);
+      const p = Number(cells[cells.length - 1]);
+      if (dm && Number.isFinite(p)) priorityByDir.set(Number(dm[1]), p);
+    }
+    for (let i = 0; i < scoreRows.length; i++) {
+      for (let j = i + 1; j < scoreRows.length; j++) {
+        const a = scoreRows[i];
+        const b = scoreRows[j];
+        const pa = priorityByDir.get(a.direction);
+        const pb = priorityByDir.get(b.direction);
+        if (!pa || !pb || Math.abs(a.expected - b.expected) < 0.005) continue;
+        const wrong = (a.expected > b.expected && pa > pb)
+          || (b.expected > a.expected && pb > pa);
+        if (wrong) {
+          warnings.push(`选题对比表的优先级与加权总分不一致：方向 ${a.direction}`
+            + `（${a.expected.toFixed(2)}）与方向 ${b.direction}（${b.expected.toFixed(2)}）`
+            + ` 的顺序对不上（表里优先级 ${pa} vs ${pb}）`);
+        }
+      }
+    }
+  }
+
+  // ── 6. 引用（书名 + 指标） ──────────────────────────────────────
+  // 数的是**出现次数**，不是行数 —— 一行里写了两本书的两条佐证也算两处。
+  const citeRe = new RegExp(
+    '《[^》]+》[^。\\n]{0,60}?' + metricLabel + '[^。\\n]{0,20}?\\d', 'g'
+  );
+  const citations = (text.match(citeRe) || []).length;
+  if (citations < R.minCitations) {
+    errors.push(`只有 ${citations} 处「《书名》…${metricLabel}…」式的引用，要求 ≥${R.minCitations} 处（结论要有书名 + 排名 + ${metricLabel} 佐证）`);
+  }
+  // 佐证必须落在“题材/市场分析”里，不能全堆在最后的选题建议里。
+  const beforeCompetition = text.split('## 五、竞争度评估')[0] || '';
+  const earlyCitations = (beforeCompetition.match(citeRe) || []).length;
+  if (earlyCitations < R.minCitations) {
+    errors.push(`「五、竞争度评估」之前只有 ${earlyCitations} 处「《书名》…${metricLabel}…」引用，要求 ≥${R.minCitations} 处（题材结论不能没有榜单数据佐证）`);
+  }
+
+  // ── 7. 推断标记 ────────────────────────────────────────────────
+  const inferCount = (text.match(/推断/g) || []).length;
+  if (inferCount < R.minInferMarks) {
+    errors.push(`全文只有 ${inferCount} 处「推断」标记，要求 ≥${R.minInferMarks} 处（数据里没有的东西必须标"推断"）`);
+  }
+
+  // ── 8. 占位符 / 标记行 / 命令痕迹 ─────────────────────────────
+  if (text.includes('<本次正文>')) {
+    errors.push('正文里还留着 `<本次正文>` 占位符 —— 内容没真正替换');
+  }
+  const markerLine = lines.find(l => /^#\s+\S+-(start|end)\s*$/.test(l.trim()));
+  if (markerLine) {
+    errors.push(`正文里有一行标记「${markerLine.trim()}」—— start/end 标记由脚本写入，你不用自己写`);
+  }
+  const heredoc = lines.find(l => /^(?:FANCY_SCAN_EOF|FANCY_SCAN_BODY_EOF)$/i.test(l.trim()));
+  if (heredoc) {
+    errors.push(`正文里有一行 \`${heredoc.trim()}\` —— 那是命令的结束标记，不能进正文`);
+  }
+  const cmdTrace = lines.find(l => /\b(cat\s+>>|python3|grep\s+-c|node\s+\S+\.js|<<)/.test(l));
+  if (cmdTrace) {
+    errors.push(`正文里混进了命令：「${cmdTrace.trim().slice(0, 60)}」—— 写进去的应该是分析，不是命令`);
+  }
+
+  // ── 9. 软告警（不拦） ─────────────────────────────────────────
+  const trendWords = ['增长', '上升', '降温', '较上月', '同比', '环比'];
+  const trendHits = [];
+  // 第六节是选题方向设计，"每一步上升""逐级上升"说的是人物弧线，
+  // 不是榜单趋势。只跳过这一节，前五节与第七节仍然检查。
+  const secSix = lines.findIndex(l => l.trim() === '## 六、选题方向建议');
+  const secSeven = lines.findIndex(l => l.trim() === '## 七、风险与验证');
+  for (let li = 0; li < lines.length; li++) {
+    if (secSix >= 0 && li > secSix && (secSeven < 0 || li < secSeven)) continue;
+    const line = lines[li];
+    for (const w of trendWords) {
+      let idx = line.indexOf(w);
+      while (idx >= 0) {
+        // 否定句里的趋势词不是趋势结论：
+        // "全文不写'上升''降温'一类判断" / "没有历史数据，任何'上升'都缺乏依据"。
+        // 只看词前 40 字与词后 20 字，避免把真正的趋势结论也吞掉。
+        const before = line.slice(Math.max(0, idx - 40), idx);
+        const after = line.slice(idx + w.length, idx + w.length + 20);
+        const negated = /(不写|不要|不得|不能写|不能读作|不能视为|不能当|没有|缺乏|不代表|不构成|并非|不是|非)/.test(before)
+          || /(一类趋势|趋势判断|缺乏|没有数据)/.test(after);
+        // 排名变动里的“上升/下降 N 本/位”是单次名次变化，不是趋势结论。
+        // 提示词明确允许写“名次较上次上升 N 位”，不能把它当趋势告警。
+        const rankChange = /(排名变动|名次较上次|名次变化|上升\s*\d+\s*本|下降\s*\d+\s*本)/.test(line);
+        if (!negated && !rankChange && !trendHits.includes(w)) trendHits.push(w);
+        idx = line.indexOf(w, idx + w.length);
+      }
+    }
+  }
+  if (trendHits.length) {
+    warnings.push(`正文里出现了趋势词（${trendHits.join('、')}）—— 本次是单日快照，除非有对比数据否则不要写趋势`);
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    stats: {
+      totalCjk,
+      pureCjk,
+      directions: dirPos.length,
+      tags: tagStats,
+      tables: foundTables.length,
+      citations,
+      earlyCitations,
+      inferMarks: inferCount,
+      sections: foundSections,
+      multiList,
+    },
+  };
+}
+
+/**
+ * 复核"这一次到底写进去没有、写对没有"。
+ *
+ * 脚本已经校验过一遍了，但模型**可能绕过脚本**（自己 `cat >>`、用 write 覆盖…）。
+ * 所以插件在模型回合结束后**自己再查一遍**：
+ *
+ *   - 本次块在不在、是不是只有一份、闭合了没有；
+ *   - 块正文过不过机械校验；
+ *   - 写之前就有的内容有没有被动过。
+ *
+ * 这一层是"校验不许跳过"的最后一道保险 ——
+ * 就算模型没走脚本，插件也会发现并告诉用户。
+ *
+ * @param {string} filePath 目标文件
+ * @param {string} blockId 块 ID（平台-榜单-日期）
+ * @param {Object} opts 传给 validateReportBody 的参数
+ * @param {Object|null} pre 写之前的状态（captureFileState 的结果）
+ * @returns {{ok: boolean, problems: string[]}}
+ */
+export function verifyBlockWritten(filePath, blockId, opts = {}, pre = null) {
+  const problems = [];
+  if (!existsSync(filePath)) {
+    return { ok: false, problems: ['目标文件不存在 —— 这次分析没有写进去'] };
+  }
+  const raw = readFileSync(filePath, 'utf-8');
+  const lines = raw.split('\n');
+  const startMarker = `# ${blockId}-start`;
+  const endMarker = `# ${blockId}-end`;
+  const starts = lines.filter(l => l.trim() === startMarker).length;
+  const ends = lines.filter(l => l.trim() === endMarker).length;
+
+  if (starts !== 1) {
+    problems.push(`本次块（${blockId}）的 start 标记有 ${starts} 个（应为 1）`
+      + (starts === 0 ? ' —— 这次分析没有写进去' : ' —— 写重了'));
+  }
+  if (ends !== 1) {
+    problems.push(`本次块（${blockId}）的 end 标记有 ${ends} 个（应为 1）`);
+  }
+  if (starts === 1 && ends === 1) {
+    const i = lines.findIndex(l => l.trim() === startMarker);
+    const j = lines.findIndex(l => l.trim() === endMarker);
+    if (j <= i) {
+      problems.push('end 标记在 start 标记之前 —— 块是坏的');
+    } else {
+      const body = lines.slice(i + 1, j).join('\n');
+      const v = validateReportBody(body, opts);
+      if (!v.ok) {
+        problems.push(...v.errors.slice(0, 6).map(e => '块正文不合格：' + e));
+      }
+    }
+  }
+
+  // 旧内容一个字节都不能少
+  if (pre && pre.size > 0) {
+    const after = hashPrefix(filePath, pre.size);
+    if (after !== pre.hash) {
+      problems.push('写之前就有的内容被改动了 —— 旧块被覆盖了');
+    }
+  }
+
+  return { ok: problems.length === 0, problems };
+}