@cloud411716/fancy-webnovel 1.0.45 → 2.2.0

package/plugins/fancy-story-builder/scripts/ai-patterns.js

@@ -0,0 +1,619 @@
+/**
+ * ai-patterns.js —— 24 类 AI 写作模式的唯一真源
+ *
+ * 这套规则原先散在三处，而且**互相漂移**：
+ *   旧 fancy-deslop/references/ai-patterns-24.md  —— 声称 24 类，列了 24 条（4 组 × 6）
+ *   旧 fancy-review/references/report-metadata-and-fallback.md —— 标题写"19 类"，实际列了 20 条
+ *   旧 fancy-write/references/check-ai-patterns.py —— 声称 24 类，实际只实现了 21 类
+ *     （缺 11 同义词循环 / 15 内联标题垂直列表 / 16 标题大写）
+ *
+ * 同一个"去 AI 味"在三个文件里是三套类目，模型根本不知道以哪套为准。
+ * 现在收敛成**一份**：类目编号沿用 ai-patterns-24.md（4 组 × 6），
+ * 正则沿用 check-ai-patterns.py（它写得更细），并补齐它缺的 3 类。
+ *
+ * 分级沿用旧定义：
+ *   blocking —— 命中就要改（11 类）
+ *   advisory —— 只提示（13 类）
+ *
+ * 每一类都带 rewrite（改写指引）。改写本身由模型按提示词做，
+ * 脚本只负责"检测 + 判级 + 算改动比例 + 回滚"，不做机械替换 ——
+ * 旧实现的 9 条正则替换会把句子改坏（"此外，" 直接删掉，句子就散了）。
+ */
+
+// ============================================================
+// 24 类模式
+// ============================================================
+
+export const AI_PATTERN_GROUPS = ['内容模式', '语言和语法模式', '风格模式', '交流模式'];
+
+export const AI_PATTERNS = [
+  // ---------------- 内容模式（6 类） ----------------
+  {
+    id: 'overstate_meaning',
+    no: 1,
+    group: '内容模式',
+    name: '过度强调意义',
+    severity: 'blocking',
+    patterns: [
+      /作为.{0,20}的体现/,
+      /标志着.{0,30}的到来/,
+      /象征着.{0,20}的/,
+      /是关键.{0,10}的.{0,10}时刻/
+    ],
+    rewrite: '把"作为……的体现""标志着……的到来"这类拔高句改成具体动作或具体后果。写"他推开门"，不写"他推开了门，这一刻标志着某种东西的到来"。'
+  },
+  {
+    id: 'media_fame',
+    no: 2,
+    group: '内容模式',
+    name: '过度强调知名度',
+    severity: 'advisory',
+    patterns: [/独立报道/, /知名专家(?:撰写|表示)/],
+    rewrite: '故事里不需要"独立报道""知名专家表示"这种外部背书。要权威感就让具体的人（有身份、有利害关系）来给结论。'
+  },
+  {
+    id: 'ing_ending',
+    no: 3,
+    group: '内容模式',
+    name: '-ing 结尾',
+    severity: 'blocking',
+    patterns: [
+      /(?:突出|强调|彰显|确保|反映|象征|展示)[^。！？]{0,30}的[^\s]{0,15}/
+    ],
+    rewrite: '中文不是英语，不存在 -ing 尾。"强调了……的""彰显了……的"这类结构改成动词收尾："他强调了三件事""这一战彰显了他的决心"。'
+  },
+  {
+    id: 'promo_words',
+    no: 4,
+    group: '内容模式',
+    name: '宣传广告词',
+    severity: 'blocking',
+    patterns: [/充满活力的.{0,15}/, /令人叹为观止/, /必游之地/, /坐落于/],
+    rewrite: '把宣传语换成具体画面或具体感受。"令人叹为观止的景色"改成"风从谷口灌进来，刮得人睁不开眼"。'
+  },
+  {
+    id: 'vague_attribution',
+    no: 5,
+    group: '内容模式',
+    name: '模糊归因',
+    severity: 'advisory',
+    patterns: [/行业报告显示/, /专家认为/, /一些批评者认为/],
+    rewrite: '把"行业报告显示""专家认为"换成具体的来源：具体的人、具体的报告名、具体的数字。没有来源就删掉。'
+  },
+  {
+    id: 'challenge_outlook',
+    no: 6,
+    group: '内容模式',
+    name: '挑战展望',
+    severity: 'advisory',
+    patterns: [/尽管其.{0,30}面临若干挑战/, /未来展望/, /挑战与遗产/],
+    rewrite: '"尽管……面临若干挑战，未来展望……"是公文腔。改成角色当下的处境和打算，不替他们做总结。'
+  },
+
+  // ---------------- 语言和语法模式（6 类） ----------------
+  {
+    id: 'ai_frequent_words',
+    no: 7,
+    group: '语言和语法模式',
+    name: 'AI 高频词',
+    severity: 'blocking',
+    patterns: [
+      /此外[,，]/,
+      /至关重要/,
+      /深入探讨/,
+      /持久的/,
+      // "复杂""格局"在中文里是普通词（"复杂的笑容""格局不大"），
+      // 原来的 /复杂(?:性|的)/、/格局(?:的)?/ 会把正常句子全判成 AI 腔。
+      // 只留真正带 AI 腔的固定搭配："复杂性""复杂而…""复杂地…"、宏大/开阔的"格局"。
+      /复杂性/,
+      /复杂(?:而|地)/,
+      /格局(?:宏大|开阔|很大|深远)/,
+      /格局的(?:意义|层面|格局)/,
+      /织锦/,
+      /宝贵的/,
+      /充满活力的/
+    ],
+    rewrite: '把这些词换成具体的动词或名词："至关重要"→"少了他就塌了"；"深入探讨"→"掰开来看"；"格局"→具体指什么就写什么。'
+  },
+  {
+    id: 'copula_avoidance',
+    no: 8,
+    group: '语言和语法模式',
+    name: '系动词回避',
+    severity: 'advisory',
+    patterns: [/作为[一个]?/, /代表着/, /标志着[一个]?/],
+    rewrite: '"作为……"开头是 AI 腔的重灾区。改成主谓结构直接说。'
+  },
+  {
+    id: 'negation_flip',
+    no: 9,
+    group: '语言和语法模式',
+    name: '否定排比',
+    severity: 'blocking',
+    patterns: [/不仅仅?是.{1,30}而是/, /这不仅仅是.{0,30}而是/],
+    rewrite: '"不是……而是……"用一次是有力，连用就是套路。留最需要对比的那一处，其余直接说。'
+  },
+  {
+    id: 'rule_of_three',
+    no: 10,
+    group: '语言和语法模式',
+    name: '三段式法则',
+    // 2026-10-27 由 blocking 降为 advisory：
+    // "张三、李四、王五""少年、少女、老人，"都是正常中文，
+    // 原来的正则把它们全判成 AI 腔 —— 于是正常小说几乎不可能零命中，
+    // 每章都要反复改写，改写幅度一大又触发 35% 回滚。
+    // 现在仍然提示，但不拦（模型可以顺手改，也可以不动）。
+    severity: 'advisory',
+    patterns: [
+      /[一-鿿]{2,3}[、，,][一-鿿]{2,3}[、，,][一-鿿]{2,3}[^的]/
+    ],
+    rewrite: '"甲、乙、丙"是 AI 最爱的排比。留两个，或者把第三个拆成独立的句子。'
+  },
+  {
+    id: 'synonym_loop',
+    no: 11,
+    group: '语言和语法模式',
+    name: '同义词循环',
+    severity: 'advisory',
+    patterns: [
+      /(?:推进|促进|提升|加强|改善|加快|提高|降低|减少|增加|加大|深化)[了]?(?:进展|提升|水平|管理|分析|工作|建设|发展|速度|效率|质量|能力|意识|力度|力度|程度|氛围|效果|效率|规模|力度)/
+    ],
+    rewrite: '"推进了进展""提升了水平""加强了管理"——谓语和宾语说的是同一件事。直接说动词："推进了工期""水平提上来了""把他骂了一顿"。'
+  },
+  {
+    id: 'false_range',
+    no: 12,
+    group: '语言和语法模式',
+    name: '虚假范围',
+    severity: 'advisory',
+    patterns: [/从[一-鿿]{0,30}到[一-鿿]{0,30}的.{0,20}/],
+    rewrite: '"从……到……"两端不在同一个尺度上（从感情到生死、从鸡毛蒜皮到天崩地裂）就是虚假范围。要么统一尺度，要么拆开写。'
+  },
+
+  // ---------------- 风格模式（6 类） ----------------
+  {
+    id: 'em_dash_overuse',
+    no: 13,
+    group: '风格模式',
+    name: '破折号',
+    // 2026-10-27 由 blocking 降为 advisory，并加密度阈值：
+    // 破折号是中文的正常标点（一章里出现一两次完全正常），
+    // "出现即 blocking" 会让每章都命中，等于逼着模型把正常标点改掉。
+    // 真正的 AI 味是"到处都在用"，所以按密度判：每 1000 字超过 2 处才算命中。
+    severity: 'advisory',
+    minDensity: 2,
+    patterns: [/——/],
+    rewrite: '"——"用得太密是 AI 味。一章里一两处破折号很正常，密集出现才需要改：换成逗号、句号，或者把后半句提起来单独成句。'
+  },
+  {
+    id: 'bold_overuse',
+    no: 14,
+    group: '风格模式',
+    name: '粗体过度',
+    severity: 'advisory',
+    patterns: [/\*\*[一-鿿]{2,8}\*\*/],
+    rewrite: '正文里几乎不该出现加粗。要强调就用动作或者语气，不用格式。'
+  },
+  {
+    id: 'inline_bullet_title',
+    no: 15,
+    group: '风格模式',
+    name: '内联标题垂直列表',
+    severity: 'advisory',
+    patterns: [/^[ \t]*[-*][ \t]*\*\*[^*]+\*\*[:：]/m],
+    rewrite: '"- **标题**：说明"这种列表是文档体，不是小说体。要点散进句子里，或者直接删掉这一层包装。'
+  },
+  {
+    id: 'title_case_heading',
+    no: 16,
+    group: '风格模式',
+    name: '标题大写',
+    severity: 'advisory',
+    patterns: [/^[A-Z][A-Z0-9 \t]{4,}$/m],
+    rewrite: '整行全大写的标题是英文写作习惯，中文正文里很突兀。改成正常大小写。（中文不适用此条）'
+  },
+  {
+    id: 'emoji',
+    no: 17,
+    group: '风格模式',
+    name: '表情符号',
+    severity: 'advisory',
+    // 2026-10-27 修：原来的 /\u{1F300}-\u{1F6FF}/u 里的 "-" 是**字面连字符**，
+    // 整个正则匹配的是"😀-😁"这个三字符序列 —— 单独一个 emoji 从来没被命中过。
+    // 字符类里的范围写法才对：/[\u{1F300}-\u{1F6FF}]/u
+    patterns: [/[\u{1F300}-\u{1F6FF}]/u],
+    rewrite: '表情符号不出现在小说正文里。'
+  },
+  {
+    id: 'curly_quotes',
+    no: 18,
+    group: '风格模式',
+    name: '弯引号',
+    // 2026-10-27 由 blocking 降为 advisory：
+    // 中文对话的标准引号就是“”，写作提示词从没要求用「」，
+    // 按 blocking 拦等于逼模型把正常对白引号全部改掉。
+    severity: 'advisory',
+    patterns: [/[“”]/],
+    rewrite: '弯引号（“”）本身不是错。如果这本书统一用直角引号「」，可以统一改；不统一就不用动。'
+  },
+
+  // ---------------- 交流模式（6 类） ----------------
+  {
+    id: 'assistant_chatter',
+    no: 19,
+    group: '交流模式',
+    name: '协作交流痕迹',
+    severity: 'advisory',
+    patterns: [/希望这对您有帮助/, /当然！/, /您说得完全正确/, /请告诉我/],
+    rewrite: '"希望这对您有帮助""当然！"是助手对助手说的话，不该出现在正文。'
+  },
+  {
+    id: 'knowledge_cutoff',
+    no: 20,
+    group: '交流模式',
+    name: '知识截止日期',
+    severity: 'advisory',
+    patterns: [/截至\s*\d{4}/, /根据我最后的训练/],
+    rewrite: '"截至 2024 年""根据我最后的训练"是模型的自我暴露，正文里绝对不能有。'
+  },
+  {
+    id: 'sycophancy',
+    no: 21,
+    group: '交流模式',
+    name: '谄媚语气',
+    severity: 'advisory',
+    patterns: [/非常好的问题/, /您说得完全正确/, /这是一个复杂的话题/],
+    rewrite: '"这是一个复杂的话题"是助手腔。改成角色自己的判断，哪怕粗糙。'
+  },
+  {
+    id: 'filler_phrase',
+    no: 22,
+    group: '交流模式',
+    name: '填充短语',
+    severity: 'blocking',
+    patterns: [/为了实现这一目标/, /由于.{1,10}的事实/, /在这个时间点/],
+    rewrite: '"为了实现这一目标""在这个时间点"是过渡填充。删掉，句子照样成立。'
+  },
+  {
+    id: 'over_hedging',
+    no: 23,
+    group: '交流模式',
+    name: '过度限定',
+    severity: 'blocking',
+    patterns: [/(?:可能|或许|也许|似乎)\s*(?:可能|或许|也许|似乎){1,3}/],
+    rewrite: '连着好几个"可能""也许"是 AI 在回避表态。挑一个，或者干脆给个准话。'
+  },
+  {
+    id: 'generic_positive',
+    no: 24,
+    group: '交流模式',
+    name: '通用积极结论',
+    severity: 'blocking',
+    patterns: [/未来看起来光明/, /激动人心的时代/, /踏上新的旅程/, /新的篇章(?:开始|即将)/],
+    rewrite: '"未来一片光明""激动人心的时代""新的篇章开始了"是收尾套话。结尾要落在具体的事上。'
+  }
+];
+
+// ============================================================
+// 索引
+// ============================================================
+
+const BY_ID = new Map(AI_PATTERNS.map((p) => [p.id, p]));
+const BY_NO = new Map(AI_PATTERNS.map((p) => [p.no, p]));
+
+/** 按 id 查一个类目 */
+export function patternById(id) {
+  return BY_ID.get(id) || null;
+}
+
+/** 按编号（1-24）查一个类目 */
+export function patternByNo(no) {
+  return BY_NO.get(Number(no)) || null;
+}
+
+/** blocking 类目的 id 集合 */
+export function blockingPatternIds() {
+  return AI_PATTERNS.filter((p) => p.severity === 'blocking').map((p) => p.id);
+}
+
+/** advisory 类目的 id 集合 */
+export function advisoryPatternIds() {
+  return AI_PATTERNS.filter((p) => p.severity === 'advisory').map((p) => p.id);
+}
+
+/**
+ * 检测一个类目在文本里的命中。
+ * @returns {Array<{index:number, line:number, match:string}>}
+ */
+export function matchPattern(pattern, text) {
+  const out = [];
+  if (!pattern || !pattern.patterns) return out;
+  for (const re of pattern.patterns) {
+    const rx = new RegExp(re.source, re.flags.includes('g') ? re.flags : re.flags + 'g');
+    let m;
+    while ((m = rx.exec(text)) !== null) {
+      out.push({
+        index: m.index,
+        line: countLine(text, m.index),
+        match: m[0]
+      });
+      if (m[0].length === 0) rx.lastIndex++;
+    }
+  }
+  return out.sort((a, b) => a.index - b.index);
+}
+
+/**
+ * 全文检测 24 类 AI 模式。
+ *
+ * @param {string} text 正文
+ * @returns {{findings:Array, byCategory:Object, blockingCount:number, advisoryCount:number}}
+ *   findings —— 每条 {categoryId, category, severity, line, match}
+ */
+export function detectAiPatterns(text) {
+  const findings = [];
+  const byCategory = {};
+  if (typeof text !== 'string' || !text) {
+    return { findings, byCategory, blockingCount: 0, advisoryCount: 0 };
+  }
+  for (const p of AI_PATTERNS) {
+    const hits = matchPattern(p, text);
+    if (!hits.length) continue;
+    // 密度阈值：某些模式（破折号）本身是正常标点，
+    // "出现即命中"会误伤整章。按每千字允许若干处来判，
+    // 超过这个量才算真命中（minDensity = 每 1000 字允许的处数）。
+    if (p.minDensity) {
+      const allowed = Math.max(1, Math.floor((text.length / 1000) * p.minDensity));
+      if (hits.length <= allowed) continue;
+    }
+    byCategory[p.id] = {
+      id: p.id,
+      no: p.no,
+      name: p.name,
+      group: p.group,
+      severity: p.severity,
+      count: hits.length,
+      matches: hits.slice(0, 10)
+    };
+    for (const h of hits) {
+      findings.push({
+        categoryId: p.id,
+        category: p.name,
+        no: p.no,
+        severity: p.severity,
+        line: h.line,
+        match: h.match.slice(0, 60),
+        index: h.index
+      });
+    }
+  }
+  return {
+    findings,
+    byCategory,
+    blockingCount: findings.filter((f) => f.severity === 'blocking').length,
+    advisoryCount: findings.filter((f) => f.severity === 'advisory').length
+  };
+}
+
+/** 统计某个下标所在行号（1 起） */
+function countLine(text, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+
+/**
+ * 改动比例：改动的字符占原文字数的比例（0-1）。
+ *
+ * 旧实现用的是 (原长 - 新长) / 原长，
+ * 但删字不是唯一改法 —— 换词也会改长度但长度可能不变。
+ * 这里用**归一化编辑距离**（LCS 近似）：
+ *   ratio = (n + m - 2 * lcs) / (n + m)
+ *
+ * 语义：等长文本时它就等于"被改掉的字符占比"
+ * （改掉一半 → 0.5）。之前写成 (n-lcs + (m-lcs)) / max(n,m)
+ * 会把"替换"算成一次删除加一次插入 —— 改掉一半的字算成 100%，
+ * 阈值 35% 就会误伤正常改写。
+ *
+ * 注意：纯增删时它偏低（凭空多写 20% 的字只算 9%），
+ * 所以"只加不减"的改写要靠**字数容差**那条闸门兜住（见 deslop-driver.js）。
+ *
+ * @param {string} before 改前
+ * @param {string} after 改后
+ * @returns {number} 0-1 之间
+ */
+export function changeRatio(before, after) {
+  const a = typeof before === 'string' ? before : '';
+  const b = typeof after === 'string' ? after : '';
+  if (!a.length && !b.length) return 0;
+  if (!a.length) return 1;
+  if (!b.length) return 1;
+  // 最长公共子序列（O(n*m) 空间换时间，长文本要防爆）
+  const n = a.length;
+  const m = b.length;
+  if (n * m > 4 * 1000 * 1000) {
+    // 太大时改用**分块指纹**算相似度（见 blockSimilarity）。
+    //
+    // 为什么不能退化成长度差：等长整章重写的长度差是 0 —— 于是
+    // "改动超 35% 自动回滚"这条保护在 2000 字以上的章节（= 正常章节长度）
+    // **完全失效**：模型可以把整章换掉而回滚不触发（2026-10-27 实测：
+    // 2000 字等长重写 → 1，2001 字等长重写 → 0）。
+    return Math.min(1, 1 - blockSimilarity(a, b));
+  }
+  let prev = new Uint32Array(m + 1);
+  let cur = new Uint32Array(m + 1);
+  for (let i = 1; i <= n; i++) {
+    cur[0] = 0;
+    for (let j = 1; j <= m; j++) {
+      if (a.charCodeAt(i - 1) === b.charCodeAt(j - 1)) cur[j] = prev[j - 1] + 1;
+      else cur[j] = prev[j] > cur[j - 1] ? prev[j] : cur[j - 1];
+    }
+    const tmp = prev;
+    prev = cur;
+    cur = tmp;
+  }
+  const lcs = prev[m];
+  return Math.min(1, (n + m - 2 * lcs) / (n + m));
+}
+
+/**
+ * 分块指纹相似度：把两段文本切成同样大小的块，逐块算指纹，
+ * 用"指纹多重集交集 ÷ 块数"当相似度。
+ *
+ * 为什么用块而不是字符：字符级比对在长文本上是 O(n*m)，2000 字就已经
+ * 400 万个格子；块级是 O(n)，任意长度都不爆。
+ *
+ * 行为：
+ *   整章重写（内容全换、字数不变） → 所有指纹都不同 → 相似度 0 → 比例 1
+ *   改一个字                       → 只影响一个块 → 比例很小
+ *   增删 10% 字数                   → 块数变了 → 比例同时反映长度变化
+ *
+ * @param {string} a 改前
+ * @param {string} b 改后
+ * @param {number} blockSize 块大小（字符）
+ * @returns {number} 0-1，1 = 完全不同
+ */
+function blockSimilarity(a, b, blockSize = 100) {
+  const ha = blockHashes(a, blockSize);
+  const hb = blockHashes(b, blockSize);
+  if (!ha.length && !hb.length) return 1;
+  if (!ha.length || !hb.length) return 0;
+  const pool = new Map();
+  for (const h of ha) pool.set(h, (pool.get(h) || 0) + 1);
+  let same = 0;
+  for (const h of hb) {
+    const c = pool.get(h) || 0;
+    if (c > 0) {
+      same++;
+      pool.set(h, c - 1);
+    }
+  }
+  return same / Math.max(ha.length, hb.length);
+}
+
+/**
+ * 逐块指纹（FNV-1a 32 位 + 块长，避免不同长度的尾块撞指纹）。
+ * @param {string} text
+ * @param {number} size
+ * @returns {number[]}
+ */
+function blockHashes(text, size) {
+  const out = [];
+  for (let i = 0; i < text.length; i += size) {
+    const chunk = text.slice(i, i + size);
+    let h = 2166136261;
+    for (let k = 0; k < chunk.length; k++) {
+      h ^= chunk.charCodeAt(k);
+      h = Math.imul(h, 16777619) >>> 0;
+    }
+    out.push((h >>> 0) + ':' + chunk.length);
+  }
+  return out;
+}
+
+/**
+ * 去味等级：按改动比例分档。
+ * 旧实现的阈值是 轻度<15%、中度<25%、重度≥25%，且**没有上限**
+ * —— 文档承诺"超过 35% 回滚"，代码里根本没有。这里把上限补上。
+ */
+export const DESLOP_LEVELS = [
+  { id: 'light', name: '轻度', max: 0.15 },
+  { id: 'medium', name: '中度', max: 0.25 },
+  { id: 'heavy', name: '重度', max: 0.35 }
+];
+
+/** 超过这个比例就要回滚（改得太多说明改坏了，不是去味） */
+export const DESLOP_ROLLBACK_RATIO = 0.35;
+
+/**
+ * 按改动比例判定等级。
+ *
+ * 档位与超限在同一个出口算：
+ *   - 档位：<15% 轻度 / <25% 中度 / <35% 重度 / ≥35% 也是重度（但超限）
+ *   - 超限：>35% 就该回滚
+ * 之前把 exceeded 写在循环里，等于把一个恒为 false 的值算两遍 ——
+ * 循环分支的条件是 r < 档位上限（最大 0.35），r > 0.35 在那里永远不成立。
+ *
+ * @param {number} ratio 改动比例（0-1）
+ * @returns {{id:string,name:string,exceeded:boolean}}
+ *   exceeded = 超过回滚上限
+ */
+export function deslopLevel(ratio) {
+  const r = typeof ratio === 'number' && isFinite(ratio) ? ratio : 0;
+  let level = DESLOP_LEVELS[DESLOP_LEVELS.length - 1];
+  for (const lv of DESLOP_LEVELS) {
+    if (r < lv.max) {
+      level = lv;
+      break;
+    }
+  }
+  return { id: level.id, name: level.name, exceeded: r > DESLOP_ROLLBACK_RATIO };
+}
+
+// ============================================================
+// 派生清单（提示词 / 文档的唯一出处）
+// ============================================================
+
+/**
+ * 历史 id → 当前 id 的兼容映射。
+ *
+ * 为什么需要：第 19 类原来的 id 是 'assistant_ chatter'（**带空格**）。
+ * id 会进日志、报告、URL 和脚本参数，带空格就到处要转义。
+ * 改名之后，外部按旧 id 查类目会查不到，所以留这张表做换算。
+ */
+export const LEGACY_PATTERN_IDS = {
+  'assistant_ chatter': 'assistant_chatter'
+};
+
+/**
+ * 24 类的结构化行，供文档守卫逐条比对。
+ * @returns {Array<{no:number,id:string,group:string,name:string,severity:string,legacyId?:string}>}
+ */
+export function deslopPatternRows() {
+  return AI_PATTERNS.map((p) => {
+    const row = {
+      no: p.no,
+      id: p.id,
+      group: p.group,
+      name: p.name,
+      severity: p.severity
+    };
+    for (const [oldId, newId] of Object.entries(LEGACY_PATTERN_IDS)) {
+      if (newId === p.id) row.legacyId = oldId;
+    }
+    return row;
+  });
+}
+
+/**
+ * 生成"AI 模式清单"，直接拼进去味提示词。
+ *
+ * 为什么动态生成而不是把清单写死在 markdown 里：
+ *   旧 skill 正是这么坏的 —— deslop 声称 24 类、review 声称 19 类（实际 20 条）、
+ *   代码里只实现 21 类，三份互不一致，模型根本不知道以哪套为准。
+ *   清单只有这一份，提示词、校验器、写作指导都从它派生。
+ *
+ * 提示词里必须带 rewrite 指引：只告诉模型"第 12 类命中了"没用，
+ * 得告诉它这类句式该改成什么样。
+ *
+ * @returns {string} 可直接拼进提示词的 markdown 段
+ */
+export function deslopLegend() {
+  const lines = [];
+  lines.push('---');
+  lines.push('');
+  lines.push('## 附：AI 模式清单（24 类，由校验器判定）');
+  lines.push('');
+  lines.push('校验器按下面这张表判定。`blocking` = 命中就要改；`advisory` = 只提示，不拦。');
+  lines.push('每类后面的「改法」就是改写指引，按它改，不要自己另发明替换规则。');
+  lines.push('');
+  lines.push('| # | 分组 | 名称 | 级别 | 改法 |');
+  lines.push('|---|---|---|---|---|');
+  for (const p of AI_PATTERNS) {
+    lines.push('| ' + p.no + ' | ' + p.group + ' | ' + p.name + ' | ' + p.severity + ' | ' + p.rewrite + ' |');
+  }
+  lines.push('');
+  return lines.join('\n');
+}