@cloud411716/fancy-webnovel 1.0.46 → 2.2.0

package/plugins/fancy-story-builder/deslop-driver.js

@@ -0,0 +1,821 @@
+/**
+ * deslop-driver.js
+ * 去 AI 味阶段：插件驱动、逐章执行
+ *
+ * 设计原则（与写作阶段一致）：
+ *   **插件当司机，LLM 只按指令改文件；脚本当裁判。**
+ *
+ * 为什么不让脚本直接改正文：
+ *   旧实现的 9 条正则替换会把句子改坏 —— 把"此外，"直接删掉，句子就散了；
+ *   把"至关重要"换成"重要"，语义就飘了。AI 腔是句式问题，不是词的问题，
+ *   机械替换救不了。
+ *
+ * 所以本驱动只做四件事：
+ *   1. 派提示词让模型按 24 类清单改写（清单在 scripts/ai-patterns.js，唯一真源）
+ *   2. 改写后**自己跑 deslop-validate.js 复扫**，blocking 没清零不算改干净
+ *   3. 算改动比例（changeRatio），超过 35% 自动回滚 —— 旧 SKILL.md 承诺了，
+ *      但旧代码里根本没有这个上限
+ *   4. 生成报告，把"改了什么、还剩什么"摆出来
+ *
+ * 本模块不直接依赖 dsh 运行时：sendPrompt / waitIdle / detect 都由调用方注入，
+ * 因此可以在没有 LLM 的情况下用测试夹具驱动。
+ */
+import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+import { changeRatio, deslopLevel, DESLOP_ROLLBACK_RATIO } from './scripts/ai-patterns.js';
+import { countEffectiveChars } from './scripts/content-quality.js';
+import { chapterFileName } from './writing-driver.js';
+import { cnToNumber } from '#chinese-num';
+
+export { cnToNumber };
+
+/** 单章最大尝试次数（含首次） */
+export const DESLOP_MAX_ATTEMPTS = 3;
+/** 备份目录名（放在写作目录里，与正文同源） */
+export const DESLOP_REVISIONS_DIRNAME = '.revisions';
+/** 报告目录（项目根下） */
+export const DESLOP_REPORTS_DIRNAME = '审查报告';
+/**
+ * 字数容差：与写作阶段的 ±20% 一致。
+ * 改动比例（编辑距离）管不住"只加不减"—— 凭空多写 20% 的字，
+ * 编辑距离只有 17%，但已经超出写作阶段的字数容差了。
+ */
+export const DESLOP_WORD_TOLERANCE = 0.2;
+
+// ============================================================
+// 路径与目录
+// ============================================================
+
+/**
+ * 去味阶段的目录布局。
+ * @param {string} projectRoot
+ */
+export function deslopDirs(projectRoot) {
+  const src = join(projectRoot, '设定', 'raw', 'sources');
+  const writing = join(src, '写作');
+  return {
+    sources: src,
+    writing,
+    revisions: join(writing, DESLOP_REVISIONS_DIRNAME),
+    reports: join(projectRoot, DESLOP_REPORTS_DIRNAME)
+  };
+}
+
+/**
+ * 列出已写出的章文件（按章号升序）。
+ * 只认 `第NNN章.md` —— 与写作阶段的落盘约定一致。
+ *
+ * @param {string} projectRoot
+ * @returns {Array<{ch:number,name:string,path:string}>}
+ */
+export function listChapterFiles(projectRoot) {
+  const dirs = deslopDirs(projectRoot);
+  let files = [];
+  try {
+    if (existsSync(dirs.writing)) files = readdirSync(dirs.writing);
+  } catch {
+    files = [];
+  }
+  const out = [];
+  for (const name of files) {
+    const m = /^第(\d+)章\.md$/.exec(name);
+    if (!m) continue;
+    out.push({ ch: Number(m[1]), name, path: join(dirs.writing, name) });
+  }
+  out.sort((a, b) => a.ch - b.ch);
+  return out;
+}
+
+/**
+ * 备份原文到 `.revisions/`。
+ * 备份失败必须**报错**（旧 skill 的 EC017）—— 没有备份就没有回滚能力，
+ * 后面那一步"改太多就回滚"就是空话。
+ *
+ * @returns {string} 备份文件路径
+ * @throws {Error} 备份失败时抛出
+ */
+export function backupChapter(dirs, ch, text) {
+  mkdirSync(dirs.revisions, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const path = join(dirs.revisions, '第' + String(ch).padStart(3, '0') + '章_' + stamp + '.md');
+  writeFileSync(path, text, 'utf-8');
+  return path;
+}
+
+/**
+ * 回滚到备份内容。
+ * @returns {boolean} 是否写回成功
+ */
+export function restoreChapter(path, text) {
+  try {
+    writeFileSync(path, text, 'utf-8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ============================================================
+// 章节完整性（改写不能把章改坏）
+// ============================================================
+
+/**
+ * 归一化标题行：把章号统一成阿拉伯数字、去掉前导零。
+ *
+ * 数字转换本身搬到 lib/chinese-num.js（导入阶段读旧稿的"第十二章"用同一份）。
+ *
+ * @param {string} line
+ * @returns {string}
+ */
+export function normalizeTitleLine(line) {
+  const raw = String(line || '').trim();
+  if (!raw) return '';
+  return raw.replace(/第\s*([0-9]+|[〇零一二三四五六七八九十百千万两]+)\s*章/, (m, no) => {
+    const n = cnToNumber(no);
+    return n === null ? m : '第' + n + '章';
+  });
+}
+
+/**
+ * 检查改写有没有把章节改坏。
+ *
+ * 去味只该改 AI 味，不该顺手把标题改了、把字数改了、把正文删空了。
+ * 改动比例（编辑距离）管不住"只加不减"—— 凭空多写 20% 的字，
+ * 编辑距离只有 17%，但已经超出写作阶段的 ±20% 字数容差了。
+ *
+ * @param {string} before 改前正文
+ * @param {string} after 改后正文
+ * @returns {{ok:boolean, problems:string[]}}
+ */
+export function checkChapterIntegrity(before, after) {
+  const problems = [];
+  const bTitle = String(before || '').split('\n')[0] || '';
+  const aTitle = String(after || '').split('\n')[0] || '';
+
+  if (bTitle.trim() && normalizeTitleLine(aTitle) !== normalizeTitleLine(bTitle)) {
+    problems.push('章节标题行被改了（原文「' + bTitle.trim() + '」，现在「' + aTitle.trim() + '」）');
+  }
+
+  const bWords = countEffectiveChars(before);
+  const aWords = countEffectiveChars(after);
+  if (bWords > 0) {
+    const delta = Math.abs(aWords - bWords) / bWords;
+    if (delta > DESLOP_WORD_TOLERANCE) {
+      problems.push('字数变化 ' + Math.round(delta * 100) + '%，超过 ±' +
+        Math.round(DESLOP_WORD_TOLERANCE * 100) + '%（' + bWords + ' → ' + aWords + '）');
+    }
+  }
+  if (bWords >= 50 && aWords < 50) {
+    problems.push('正文被清空了（有效字符 ' + aWords + ' < 50）');
+  }
+
+  return { ok: problems.length === 0, problems };
+}
+
+// ============================================================
+// 提示词
+// ============================================================
+
+/**
+ * 取出命中行的原文（给模型看它到底要改哪几句）。
+ * @param {string} text
+ * @param {Array<{line:number}>} hits
+ * @param {number} [maxLines]
+ * @returns {Array<{line:number, text:string}>}
+ */
+export function extractOffendingLines(text, hits, maxLines = 12) {
+  const lines = String(text || '').split('\n');
+  const seen = new Set();
+  const out = [];
+  for (const h of hits) {
+    if (!h || typeof h.line !== 'number') continue;
+    if (seen.has(h.line)) continue;
+    seen.add(h.line);
+    const content = (lines[h.line - 1] || '').trim();
+    out.push({ line: h.line, text: content });
+    if (out.length >= maxLines) break;
+  }
+  return out;
+}
+
+/**
+ * 把校验器的检出结果整理成"类目 → 命中行"的清单。
+ * @param {Object} detection deslop-validate.js 的 JSON 输出
+ * @param {string} text 原文
+ * @returns {Array<{id:string,no:number,name:string,group:string,severity:string,count:number,rewrite:string,lines:Array}>}
+ */
+export function summarizeDetection(detection, text) {
+  const byCategory = (detection && detection.byCategory) || {};
+  const out = [];
+  for (const id of Object.keys(byCategory)) {
+    const c = byCategory[id];
+    if (!c) continue;
+    out.push({
+      id: c.id || id,
+      no: c.no,
+      name: c.name,
+      group: c.group,
+      severity: c.severity,
+      count: c.count,
+      rewrite: c.rewrite || '',
+      lines: extractOffendingLines(text, c.matches || [])
+    });
+  }
+  // blocking 在前，同级按编号排 —— 模型先处理最该改的
+  out.sort((a, b) => {
+    if (a.severity !== b.severity) return a.severity === 'blocking' ? -1 : 1;
+    return (a.no || 0) - (b.no || 0);
+  });
+  return out;
+}
+
+/**
+ * 构建一章的去味提示词。
+ *
+ * @param {Object} o
+ * @param {{ch:number,name:string,path:string}} o.chapter
+ * @param {string} o.contract 去味执行须知（产物契约）
+ * @param {Object} o.detection 首次检出结果（deslop-validate.js 的 JSON）
+ * @param {string} o.text 当前正文
+ * @param {number} [o.attempt] 第几次尝试
+ * @param {Object} [o.prev] 上一次尝试的结果 {ratio, exceeded, blockingCount, note}
+ * @returns {string}
+ */
+export function buildDeslopPrompt(o) {
+  const chapter = o.chapter;
+  const attempt = o.attempt || 1;
+  const categories = summarizeDetection(o.detection, o.text);
+  const blocking = categories.filter((c) => c.severity === 'blocking');
+  const advisory = categories.filter((c) => c.severity !== 'blocking');
+  const parts = [];
+
+  if (o.contract) {
+    parts.push(o.contract.trim());
+    parts.push('');
+    parts.push('---');
+    parts.push('');
+  }
+
+  parts.push('# 本轮派活：第 ' + chapter.ch + ' 章去 AI 味' + (attempt > 1 ? '（第 ' + attempt + ' 次尝试）' : ''));
+  parts.push('');
+
+  parts.push('## 目标文件');
+  parts.push('');
+  parts.push('- 路径：`设定/raw/sources/写作/' + chapter.name + '`');
+  parts.push('- 改写方式：**直接覆盖原文件**，不要新建文件、不要改文件名。');
+  parts.push('');
+
+  parts.push('## 检出结果（校验器判的，不要自己另找标准）');
+  parts.push('');
+
+  if (blocking.length) {
+    parts.push('### 必须改干净（blocking）');
+    parts.push('');
+    for (const c of blocking) {
+      parts.push('- **第 ' + c.no + ' 类 ' + c.name + '**（' + c.group + '）—— 命中 ' + c.count + ' 处');
+      if (c.lines.length) {
+        for (const l of c.lines) {
+          parts.push('  - 第 ' + l.line + ' 行：' + (l.text || '（空行）'));
+        }
+      }
+      if (c.rewrite) parts.push('  - 改法：' + c.rewrite);
+    }
+    parts.push('');
+  }
+
+  if (advisory.length) {
+    parts.push('### 建议一并处理（advisory，不强制）');
+    parts.push('');
+    for (const c of advisory) {
+      parts.push('- **第 ' + c.no + ' 类 ' + c.name + '** —— 命中 ' + c.count + ' 处');
+      if (c.rewrite) parts.push('  - 改法：' + c.rewrite);
+    }
+    parts.push('');
+  }
+
+  if (!categories.length) {
+    parts.push('（校验器没有检出命中项 —— 如果你收到本提示词，说明上一轮判定有误，请先跑一遍校验器确认。）');
+    parts.push('');
+  }
+
+  if (o.prev && o.prev.exceeded) {
+    parts.push('## ⚠️ 上一轮被回滚了');
+    parts.push('');
+    parts.push('上一轮你的改动幅度是 ' + Math.round((o.prev.ratio || 0) * 100) + '%，超过了 ' +
+      Math.round(DESLOP_ROLLBACK_RATIO * 100) + '% 的上限，原文已被还原。');
+    parts.push('这说明你改得太狠了。**这一轮只改上面列出的那几处**，其余句子一个字都不要动。');
+    parts.push('');
+  } else if (o.prev && o.prev.note) {
+    parts.push('## ⚠️ 上一轮没通过');
+    parts.push('');
+    parts.push(o.prev.note);
+    parts.push('');
+  }
+
+  parts.push('## 硬约束');
+  parts.push('');
+  parts.push('- **只改 AI 味，不改剧情**：人物、事件、因果、伏笔、事实一律不动。');
+  parts.push('- **不要改标题行**（第一行 `# 第N章 <标题>` 保持原样）。');
+  parts.push('- **不要动台账**（`设定/raw/sources/写作/台账/` 下的文件本阶段不许改）。');
+  parts.push('- **改动幅度控制在 ' + Math.round(DESLOP_ROLLBACK_RATIO * 100) + '% 以内**，超了会被自动回滚。');
+  parts.push('- **字数变化不超过 ±' + Math.round(DESLOP_WORD_TOLERANCE * 100) + '%**（与写作阶段的字数容差一致），' +
+    '标题行也要原样保留 —— 这两条超了同样会被回滚。');
+  parts.push('');
+
+  parts.push('## 交活');
+  parts.push('');
+  parts.push('改完后用一段话汇报：改了几处、每处原来是什么句式、改成了什么。');
+  parts.push('');
+
+  return parts.join('\n');
+}
+
+// ============================================================
+// 报告
+// ============================================================
+
+/**
+ * 渲染单章的去味报告。
+ * @param {Object} r 章节结果
+ * @returns {string} markdown
+ */
+export function renderChapterReport(r) {
+  const lines = [];
+  const statusText = {
+    clean: '无需改写（未检出 blocking）',
+    passed: '已改写并通过复扫',
+    failed: '未改干净',
+    rolled_back: '改动超限已回滚',
+    error: '执行出错'
+  };
+  lines.push('# 第 ' + r.ch + ' 章 去 AI 味报告');
+  lines.push('');
+  lines.push('- 状态：**' + (statusText[r.status] || r.status) + '**');
+  lines.push('- 文件：`设定/raw/sources/写作/' + r.name + '`');
+  if (r.backup) lines.push('- 原文备份：`设定/raw/sources/写作/' + DESLOP_REVISIONS_DIRNAME + '/' + r.backupName + '`');
+  if (r.error) lines.push('- 错误：' + r.error);
+  lines.push('');
+
+  lines.push('## 初次检出');
+  lines.push('');
+  lines.push('- blocking 命中：' + r.initial.blockingCount + ' 处');
+  lines.push('- advisory 命中：' + r.initial.advisoryCount + ' 处');
+  lines.push('');
+  lines.push('| # | 分组 | 名称 | 级别 | 次数 |');
+  lines.push('|---|---|---|---|---|');
+  for (const c of r.initial.categories) {
+    lines.push('| ' + c.no + ' | ' + c.group + ' | ' + c.name + ' | ' + c.severity + ' | ' + c.count + ' |');
+  }
+  lines.push('');
+
+  if (r.attempts.length) {
+    lines.push('## 改写尝试');
+    lines.push('');
+    lines.push('| 尝试 | 改动比例 | 等级 | 复扫 blocking | 结论 |');
+    lines.push('|---|---|---|---|---|');
+    for (const a of r.attempts) {
+      const ratio = typeof a.ratio === 'number' ? Math.round(a.ratio * 100) + '%' : '-';
+      lines.push('| ' + a.attempt + ' | ' + ratio + ' | ' + (a.level || '-') + ' | ' +
+        (typeof a.blockingCount === 'number' ? a.blockingCount : '-') + ' | ' + (a.note || '-') + ' |');
+    }
+    lines.push('');
+  }
+
+  if (r.remaining && r.remaining.blockingCount > 0) {
+    lines.push('## 复扫后仍未清除（blocking）');
+    lines.push('');
+    lines.push('| # | 名称 | 次数 |');
+    lines.push('|---|---|---|');
+    for (const c of r.remaining.categories.filter((x) => x.severity === 'blocking')) {
+      lines.push('| ' + c.no + ' | ' + c.name + ' | ' + c.count + ' |');
+    }
+    lines.push('');
+  }
+
+  if (r.remaining && r.remaining.advisoryCount > 0) {
+    lines.push('## 残留 advisory（只提示，不拦）');
+    lines.push('');
+    lines.push('| # | 名称 | 次数 |');
+    lines.push('|---|---|---|');
+    for (const c of r.remaining.categories.filter((x) => x.severity !== 'blocking')) {
+      lines.push('| ' + c.no + ' | ' + c.name + ' | ' + c.count + ' |');
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * 渲染总览报告。
+ * @param {Array} chapters 章节结果数组
+ * @returns {string} markdown
+ */
+export function renderOverviewReport(chapters) {
+  const lines = [];
+  const passed = chapters.filter((c) => c.status === 'passed' || c.status === 'clean').length;
+  lines.push('# 去 AI 味总览');
+  lines.push('');
+  lines.push('- 章节总数：' + chapters.length);
+  lines.push('- 已处理：' + passed);
+  lines.push('- 未通过：' + chapters.filter((c) => c.status === 'failed' || c.status === 'rolled_back').length);
+  lines.push('- 执行出错：' + chapters.filter((c) => c.status === 'error').length);
+  lines.push('');
+  lines.push('| 章 | 状态 | 初次 blocking | 改动比例 | 复扫 blocking |');
+  lines.push('|---|---|---|---|---|');
+  for (const c of chapters) {
+    const last = c.attempts.length ? c.attempts[c.attempts.length - 1] : null;
+    const ratio = last && typeof last.ratio === 'number' ? Math.round(last.ratio * 100) + '%' : '-';
+    const rem = c.remaining ? c.remaining.blockingCount : '-';
+    lines.push('| ' + c.ch + ' | ' + c.status + ' | ' + c.initial.blockingCount + ' | ' + ratio + ' | ' + rem + ' |');
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * 写报告到磁盘。
+ * @returns {string} 报告路径（失败返回空串）
+ */
+export function writeReport(dirs, name, content) {
+  try {
+    mkdirSync(dirs.reports, { recursive: true });
+    const path = join(dirs.reports, name);
+    writeFileSync(path, content, 'utf-8');
+    return path;
+  } catch {
+    return '';
+  }
+}
+
+// ============================================================
+// 主循环
+// ============================================================
+
+/**
+ * 逐章驱动去味阶段。
+ *
+ * @param {Object} opts
+ * @param {string} opts.projectRoot
+ * @param {Array<{ch:number,name:string,path:string}>} [opts.chapters]
+ * @param {number} [opts.maxAttempts]
+ * @param {string} [opts.contract] 去味执行须知
+ * @param {(prompt:string) => Promise<{ok:boolean, error?:string}>} opts.sendPrompt
+ * @param {(files:string[], before:string) => Promise<{ok:boolean, reason?:string, code?:string}>} opts.waitIdle
+ * @param {(file:string) => Promise<{ok:boolean, detection?:Object, error?:string}>} opts.detect
+ * @param {(msg:string) => void} [opts.onProgress]
+ * @param {(chapter:Object) => void} [opts.onChapter] 单章结束时的回调（用于落报告）
+ * @returns {Promise<Object>} 汇总报告
+ */
+export async function runDeslopStage(opts) {
+  const dirs = opts.dirs || deslopDirs(opts.projectRoot);
+  const chapters = opts.chapters || listChapterFiles(opts.projectRoot);
+  const maxAttempts = opts.maxAttempts || DESLOP_MAX_ATTEMPTS;
+
+  const report = {
+    ok: true,
+    error: null,
+    chapters: [],
+    passed: 0,
+    clean: 0,
+    failed: [],
+    rolledBack: [],
+    errored: []
+  };
+
+  for (const chapter of chapters) {
+    const original = (() => {
+      try {
+        return readFileSync(chapter.path, 'utf-8');
+      } catch {
+        return null;
+      }
+    })();
+    if (original === null) {
+      const r = {
+        ch: chapter.ch,
+        name: chapter.name,
+        path: chapter.path,
+        status: 'error',
+        error: '读取章节文件失败：' + chapter.path,
+        backup: null,
+        backupName: null,
+        attempts: [],
+        initial: { blockingCount: 0, advisoryCount: 0, categories: [] },
+        remaining: null
+      };
+      report.chapters.push(r);
+      report.errored.push(chapter.ch);
+      if (opts.onProgress) opts.onProgress('第 ' + chapter.ch + ' 章读取失败，已跳过。');
+      continue;
+    }
+
+    // 1. 初次检测
+    const first = await opts.detect(chapter.path);
+    if (!first || !first.ok) {
+      const r = {
+        ch: chapter.ch,
+        name: chapter.name,
+        path: chapter.path,
+        status: 'error',
+        error: (first && first.error) || '检测脚本异常',
+        backup: null,
+        backupName: null,
+        attempts: [],
+        initial: { blockingCount: 0, advisoryCount: 0, categories: [] },
+        remaining: null
+      };
+      report.chapters.push(r);
+      report.errored.push(chapter.ch);
+      if (opts.onProgress) opts.onProgress('第 ' + chapter.ch + ' 章检测失败：' + r.error);
+      continue;
+    }
+
+    const detection = first.detection;
+    const initialCategories = summarizeDetection(detection, original);
+    const initial = {
+      blockingCount: detection.blockingCount || 0,
+      advisoryCount: detection.advisoryCount || 0,
+      categories: initialCategories
+    };
+
+    const base = {
+      ch: chapter.ch,
+      name: chapter.name,
+      path: chapter.path,
+      backup: null,
+      backupName: null,
+      attempts: [],
+      initial,
+      remaining: null,
+      error: null
+    };
+
+    // 2. 没有 blocking 就不用改（advisory 只进报告）
+    if (initial.blockingCount === 0) {
+      base.status = 'clean';
+      base.remaining = {
+        blockingCount: 0,
+        advisoryCount: initial.advisoryCount,
+        categories: initialCategories
+      };
+      report.chapters.push(base);
+      report.clean++;
+      if (opts.onProgress) {
+        opts.onProgress('第 ' + chapter.ch + ' 章没有 blocking 命中，跳过改写。');
+      }
+      if (opts.onChapter) opts.onChapter(base);
+      continue;
+    }
+
+    // 3. 备份（失败即中止该章：没有备份就没有回滚能力）
+    let backupPath;
+    try {
+      backupPath = backupChapter(dirs, chapter.ch, original);
+    } catch (e) {
+      base.status = 'error';
+      base.error = '备份失败：' + (e && e.message ? e.message : String(e));
+      report.chapters.push(base);
+      report.errored.push(chapter.ch);
+      if (opts.onProgress) opts.onProgress('第 ' + chapter.ch + ' 章备份失败，已中止该章。');
+      if (opts.onChapter) opts.onChapter(base);
+      continue;
+    }
+    base.backup = backupPath;
+    base.backupName = backupPath.slice(backupPath.lastIndexOf('/') + 1);
+
+    // 4. 改写循环
+    let attempt = 1;
+    let prev = null;
+    let status = 'failed';
+    let remaining = null;
+    let lastRatio = null;
+    // 本轮要喂给模型的是**当前**的检测结果与当前文本。
+    //
+    // 旧实现每轮都喂首次的 detection + 原始正文 —— 于是第二次以后，
+    // 模型看到的还是**原文**里的命中行（可能早就被改掉了），
+    // 它不知道剩下的问题在哪一行、哪一类，只能重新通读全文猜，
+    // 容易改错/改多，触发 35% 回滚。
+    // 现在每轮复扫后把 det2 与改后的正文接上，
+    // 模型看到的是"还剩哪几类、在哪几行、当前文本长什么样"。
+    let currentDetection = detection;
+    let currentText = original;
+
+    while (attempt <= maxAttempts) {
+      const prompt = buildDeslopPrompt({
+        chapter,
+        contract: opts.contract,
+        detection: currentDetection,
+        text: currentText,
+        attempt,
+        prev
+      });
+
+      const sent = await opts.sendPrompt(prompt);
+      if (!sent || sent.ok !== true) {
+        base.error = (sent && sent.error) || '提示词投递失败';
+        status = 'error';
+        report.errored.push(chapter.ch);
+        break;
+      }
+
+      const waited = await opts.waitIdle([chapter.path], original);
+      if (!waited || waited.ok !== true) {
+        const code = (waited && waited.code) || '';
+        const reason = (waited && waited.reason) || '等待 LLM 失败';
+        base.attempts.push({ attempt, kind: 'wait_failed', ratio: null, level: null, blockingCount: null, note: reason });
+        // 环境类失败（超时/中断）重试没有意义，直接中止本章
+        if (code === 'TIMEOUT' || code === 'ABORTED' || code === 'NO_AGENT') {
+          base.error = reason;
+          status = 'error';
+          report.errored.push(chapter.ch);
+          break;
+        }
+        prev = { note: '上一轮没有改动文件：' + reason };
+        attempt++;
+        continue;
+      }
+
+      const after = (() => {
+        try {
+          return readFileSync(chapter.path, 'utf-8');
+        } catch {
+          return null;
+        }
+      })();
+      if (after === null) {
+        base.attempts.push({ attempt, kind: 'unreadable', ratio: null, level: null, blockingCount: null, note: '改写后文件读不到' });
+        prev = { note: '上一轮之后文件读不到了，请重新写一遍这一章。' };
+        attempt++;
+        continue;
+      }
+
+      const ratio = changeRatio(original, after);
+      const level = deslopLevel(ratio);
+      lastRatio = ratio;
+
+      // 改动超限 → 回滚
+      if (level.exceeded) {
+        const restored = restoreChapter(chapter.path, original);
+        base.attempts.push({
+          attempt,
+          kind: 'ratio_exceeded',
+          ratio,
+          level: level.name,
+          blockingCount: null,
+          note: restored ? '超 ' + Math.round(DESLOP_ROLLBACK_RATIO * 100) + '%，已回滚' : '超限，回滚失败'
+        });
+        prev = { ratio, exceeded: true };
+        // 回滚了 → 磁盘上的内容又变回原文，检测基线也要跟着回退
+        currentDetection = detection;
+        currentText = original;
+        attempt++;
+        continue;
+      }
+
+      // 章节完整性：去味不能顺手把标题改了、字数改了、正文删空了
+      const integrity = checkChapterIntegrity(original, after);
+      if (!integrity.ok) {
+        restoreChapter(chapter.path, original);
+        base.attempts.push({
+          attempt,
+          kind: 'integrity',
+          ratio,
+          level: level.name,
+          blockingCount: null,
+          note: '改坏了（' + integrity.problems.join('；') + '），已回滚'
+        });
+        prev = { note: '上一轮改动把章节改坏了，已回滚：' + integrity.problems.join('；') +
+          '。这一轮只改 AI 味，标题、字数、篇幅都要保持原样。' };
+        currentDetection = detection;
+        currentText = original;
+        attempt++;
+        continue;
+      }
+
+      // 复扫
+      const again = await opts.detect(chapter.path);
+      if (!again || !again.ok) {
+        // 检测脚本崩了是**环境问题**，不是内容问题：重投不会改变结果。
+        // 按错误分类（见 scripts/error-classes.js）：脚本问题不重投，单独上报。
+        restoreChapter(chapter.path, original);
+        base.attempts.push({
+          attempt,
+          kind: 'detect_crashed',
+          ratio,
+          level: level.name,
+          blockingCount: null,
+          note: '复扫失败：' + ((again && again.error) || '未知错误') + '，已回滚'
+        });
+        base.error = '复扫时检测脚本异常：' + ((again && again.error) || '未知错误');
+        status = 'error';
+        report.errored.push(chapter.ch);
+        break;
+      }
+
+      const det2 = again.detection;
+      // 下一轮喂 det2 + 改后的正文（不是首次的 detection + 原文）
+      currentDetection = det2;
+      currentText = after;
+      const remainingCategories = summarizeDetection(det2, after);
+      remaining = {
+        blockingCount: det2.blockingCount || 0,
+        advisoryCount: det2.advisoryCount || 0,
+        categories: remainingCategories
+      };
+
+      if (det2.blockingCount === 0) {
+        // 去味"干净"不等于"写作校验还能过"。
+        //
+        // 去味的完整性检查只有三项（标题没改、字数没变超过 ±20%、正文没被删空），
+        // 不检查占位符/字符集/禁用词/一级标题/台账 —— 所以去味完全可能
+        // 把一个本来合规的章改坏（引入 [X]、韩文、第二个 # 标题…），
+        // 而阶段照样报"✅ 去味完成"，用户以为"写作+去味"双通过了。
+        //
+        // 这里在判通过之前补跑一次写作校验，不过就回滚（宁可这章没去味，
+        // 也不能留一个被改坏的章）。
+        if (opts.validateWriting) {
+          const wv = await opts.validateWriting(chapter, after);
+          if (!wv || wv.ok !== true) {
+            const reasons = ((wv && wv.errors) || []).map((e) => '[' + e.code + '] ' + e.message);
+            restoreChapter(chapter.path, original);
+            base.attempts.push({
+              attempt,
+              kind: 'writing_reject',
+              ratio,
+              level: level.name,
+              blockingCount: 0,
+              note: '去味后写作复检未通过（' + reasons.join('；') + '），已回滚'
+            });
+            prev = {
+              note: '上一轮改完后去味检测干净了，但**写作校验**没通过：'
+                + reasons.join('；')
+                + '。说明改写引入了新问题（占位符/字符集/禁用词/标题层级…）。'
+                + '这一轮只改 AI 味，别动这些地方。'
+            };
+            currentDetection = detection;
+            currentText = original;
+            attempt++;
+            continue;
+          }
+          base.writingRecheck = { ok: true };
+        }
+
+        base.attempts.push({
+          attempt,
+          kind: 'passed',
+          ratio,
+          level: level.name,
+          blockingCount: 0,
+          note: opts.validateWriting ? '通过（已复检写作校验）' : '通过'
+        });
+        status = 'passed';
+        break;
+      }
+
+      base.attempts.push({
+        attempt,
+        kind: 'rescan_failed',
+        ratio,
+        level: level.name,
+        blockingCount: det2.blockingCount,
+        note: '复扫仍有 ' + det2.blockingCount + ' 处 blocking'
+      });
+      prev = {
+        note: '上一轮改完后复扫，仍有 ' + det2.blockingCount + ' 处 blocking 没清掉'
+          + (remainingCategories.length
+            ? '，剩下的是第 ' + remainingCategories.map((c) => c.no + ' 类（' + c.name + '，' + c.count + ' 处）').join('、')
+            : '')
+          + '。**只改上面列出的这些命中行**，其余句子一个字都不要动。'
+      };
+      attempt++;
+    }
+
+    if (status !== 'passed' && status !== 'error') {
+      // 没改干净。只有"改动超限"才算 rolled_back ——
+      // "改坏了标题""改坏了字数"也是回滚，但那是另一类问题，报告里要分得开。
+      const last = base.attempts[base.attempts.length - 1];
+      if (last && last.kind === 'ratio_exceeded') {
+        status = 'rolled_back';
+        report.rolledBack.push(chapter.ch);
+      } else {
+        status = 'failed';
+      }
+      report.failed.push(chapter.ch);
+    } else if (status === 'passed') {
+      report.passed++;
+    }
+
+    base.status = status;
+    base.remaining = remaining;
+    if (typeof lastRatio === 'number') base.ratio = lastRatio;
+    report.chapters.push(base);
+    if (opts.onProgress) {
+      opts.onProgress('第 ' + chapter.ch + ' 章去味结果：' + status);
+    }
+    if (opts.onChapter) opts.onChapter(base);
+  }
+
+  return report;
+}