dsh-novel-writer 3.7.1 → 3.9.0

package/cordis.patch.yml

@@ -1,4 +1,4 @@
-# dsh-novel-writer v3.7.0 bundle patch: 16 tools (incl. novel_semantic_search) + local embedding engine.
+# dsh-novel-writer v3.9.0 bundle patch: 16 tools (incl. novel_semantic_search) + local embedding engine.
 # dsh-novel-writer bundle patch: mounts the novel-writing assistant plugin
 # into the profile's loader tree. The entry's name is the plugin package
 # itself, resolved from the profile's node_modules.

package/lib/client.js

@@ -1,5 +1,5 @@
 /**
- * dsh-novel-writer — 浏览器端（client half, v0.3.0）
+ * dsh-novel-writer — 浏览器端（client half, v3.9.0）
  *
  * 在 Web GUI 侧边栏挂载「句式分析」入口，点击后在会话区打开开关面板：
  *   - 启用句式分析（enabled）：控制 AI 是否可用 novel_sentence_analysis
@@ -276,7 +276,7 @@ var css = `
       "tool.novel_summary": "章节摘要 novel_summary",
       "tool.novel_continuity_check": "连贯性审计 novel_continuity_check",
       "tool.novel_semantic_search": "语义检索 novel_semantic_search",
-      "tool.novel_settings.desc": "四张设定表：人物卡/地点卡/道具/时间线。",
+      "tool.novel_settings.desc": "五张设定表：人物/地点/道具/时间线/世界观用语规范。",
       "tool.novel_summary.desc": "保存/读取每章摘要，长书续写先读摘要。",
       "tool.novel_continuity_check.desc": "对照设定表扫描全书，输出矛盾候选。",
       "tool.novel_semantic_search.desc": "按语义检索全书相关内容：即使段落未出现查询关键词，也能基于含义匹配。",
@@ -750,7 +750,7 @@ var css = `
         },
         setToggle: function (fn) { toggleRef = fn; },
         openView: function (view) { api.set({ view: view, revealMsg: "", revealErr: false }); },
-        setToolGroupOpen: function (patch) { api.set({ toolGroupOpen: Object.assign({}, (this.state && this.state.toolGroupOpen) || {}, patch) }); },
+        setToolGroupOpen: function (patch) { api.set({ toolGroupOpen: Object.assign({}, state.toolGroupOpen || {}, patch) }); },
         rawToggle: function (wantOn) {
           if (!wantOn) {
             if (rawTimer) { clearInterval(rawTimer); rawTimer = null; }
@@ -969,7 +969,8 @@ var css = `
 var TOOL_GROUPS = [
         { key: "analyze", icon: "📊", tools: ["novel_books", "novel_chapters", "novel_read", "novel_keywords", "novel_sentence_analysis", "novel_style_check", "novel_style_report", "novel_semantic_search", "novel_continuity_check"] },
         { key: "settings", icon: "📚", tools: ["novel_settings", "novel_plot", "novel_summary", "novel_import"] },
-        { key: "create", icon: "✍️", tools: ["novel_new_chapter", "novel_sentence_config", "novel_outline"] }
+        // v3.9.0：novel_sentence_config 移出组开关（宿主会剥离该键，全关后 UI 显示与实际不一致）——config 仅由二级页/设置单独管理
+        { key: "create", icon: "✍️", tools: ["novel_new_chapter", "novel_outline"] }
       ];
       var toolGroupOpen = state.toolGroupOpen || {};
       var toolRows = TOOL_GROUPS.map(function (grp) {

package/lib/embedding.js

@@ -409,4 +409,4 @@ function chunkText(text) {
 /** 显式释放（仅重置单例，WASM 内存由 GC 回收）。 */
 function reset() { enginePromise = null; engine = { available: false, error: null, tokenizer: null, session: null, ort: null, wasmPaths: null }; }
 
-export { status, isAvailable, embed, embedMany, cosine, search, saveIndex, loadIndex, loadIndexMeta, fingerprint, textHash, buildIndexIncremental, chunkText, reset, detectImplicitEmotions, IMPLICIT_EMOTION_PROTOTYPES, MODEL_DIR, cachePath };
+export { status, isAvailable, embed, embedMany, cosine, search, saveIndex, loadIndex, loadIndexMeta, fingerprint, textHash, buildIndexIncremental, chunkText, reset, detectImplicitEmotions, IMPLICIT_EMOTION_PROTOTYPES, MODEL_DIR, cachePath, engine };

package/lib/index.js

@@ -1,5 +1,5 @@
 /**
- * dsh-novel-writer — 小说写作助手插件（v0.3.0：新增句式模式分析扩展）
+ * dsh-novel-writer — 小说写作助手插件（v3.9.0：render 全量可见化 / 锚包写作 / 对照修正）
  *   - novel_sentence_analysis 句式模式分析（句式分布/排列规律/段落结构/句长节奏/情感曲线/风格指纹）
  *   - novel_sentence_config    句式分析开关（Web GUI 侧边栏「句式分析」面板同步）
  *
@@ -236,7 +236,13 @@ function bookDir(root, book) {
 }
 /** 读取一部作品的章节文件列表（按序号排序），返回带元信息的条目。 */
 async function scanChapters(bookPath) {
-  const entries = await readdir(bookPath, { withFileTypes: true });
+  let entries;
+  try {
+    entries = await readdir(bookPath, { withFileTypes: true });
+  } catch (e) {
+    // v3.9.0：缺失书目录不再抛裸 ENOENT——友好报错（各工具行为统一）
+    throw new Error("书库中未找到作品目录：" + bookPath + "（检查书名是否精确匹配——可用 novel_books 查看全部作品名；或确认 novels/ 下已创建该书目录）", { cause: e });
+  }
   const chapters = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
@@ -393,6 +399,90 @@ function tallyCjkRun(run, cjkChars, cjkBigrams, cjkTrigrams) {
 const IMPORT_NOISE = new Set(["原稿件", "单章", "调教计划", "未命名", "新建文档", "草稿", "无题", "正文", "手稿"]);
 
 /** 从文件名提取书名候选：去扩展名、章号标记、噪音词与分隔符。失败返回 void 0。 */
+/** v3.9.0 修正：导入重名解决——解析目标章号 → 扫描目录全部已占用章号（含补零/中文数字/前缀/中间形式，异形同号算同一章）→ 取空闲章号 → 按原格式生成文件名；无法解析章号才退化为 -k 后缀。 */
+function numberToCjk(n) {
+  const digits = ["零", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
+  if (!Number.isInteger(n) || n <= 0 || n >= 10000) return null;
+  if (n < 10) return digits[n];
+  if (n < 20) return "十" + (n % 10 === 0 ? "" : digits[n % 10]);
+  const tens = Math.floor(n / 10);
+  const rest = n % 10;
+  let s = (tens === 1 ? "一" : digits[tens]) + "十";
+  if (rest > 0) s += digits[rest];
+  return s;
+}
+function nextFreeChapterFile(destDir, fileName) {
+  const stem = fileName.replace(/\.[^.]+$/, "");
+  const ext = extname(fileName);
+  const baseNum = parseChapterNumber(stem);
+  // v3.9.0 复查修正：同名或同章号（异形）占用都触发改名
+  const numOccupied = function (num) {
+    try {
+      for (const ex of readdirSync(destDir)) {
+        if (parseChapterNumber(ex) === num) return true;
+      }
+    } catch { /* 目录不可读按同名处理 */ }
+    return false;
+  };
+  if (baseNum === void 0) {
+    if (!existsSync(join(destDir, fileName))) return fileName;
+    let k = 2;
+    while (existsSync(join(destDir, stem + "-" + k + ext))) k += 1;
+    return stem + "-" + k + ext;
+  }
+  if (!existsSync(join(destDir, fileName)) && !numOccupied(baseNum)) return fileName;
+  // 扫描目录内全部已占用章号（第01章/第1章/第一章/01-标题 都算同一章）
+  const used = new Set();
+  try {
+    for (const existing of readdirSync(destDir)) {
+      const n = parseChapterNumber(existing);
+      if (n !== void 0) used.add(n);
+    }
+  } catch { /* 目录不可读时按文件名探测 */ }
+  let next = baseNum + 1;
+  while (used.has(next)) next += 1;
+  // 按原文件名格式生成空闲章号（保持补零宽度）
+  const mArab = /^(.*第)(\d{1,4})([章回话].*)$/.exec(stem);
+  if (mArab) {
+    const width = mArab[2].length;
+    let bump = next;
+    let candidate = mArab[1] + String(bump).padStart(width, "0") + mArab[3] + ext;
+    while (existsSync(join(destDir, candidate))) { bump += 1; candidate = mArab[1] + String(bump).padStart(width, "0") + mArab[3] + ext; }
+    return candidate;
+  }
+  const mCjk = /^(.*第)([零一二三四五六七八九十百两]+)([章回话].*)$/.exec(stem);
+  if (mCjk) {
+    let bump = next;
+    let candidate = null;
+    while (!candidate || existsSync(join(destDir, candidate))) {
+      const cjk = numberToCjk(bump);
+      if (cjk === null) break;
+      candidate = mCjk[1] + cjk + mCjk[3] + ext;
+      bump += 1;
+    }
+    if (candidate) return candidate;
+  }
+  const mLead = /^(\d{1,4})([-._].*)$/.exec(stem);
+  if (mLead) {
+    const width = mLead[1].length;
+    let bump = next;
+    let candidate = String(bump).padStart(width, "0") + mLead[2] + ext;
+    while (existsSync(join(destDir, candidate))) { bump += 1; candidate = String(bump).padStart(width, "0") + mLead[2] + ext; }
+    return candidate;
+  }
+  const mMid = /^(.*?[-._\s])(\d{1,4})([-._\s].*)$/.exec(stem);
+  if (mMid) {
+    const width = mMid[2].length;
+    let bump = next;
+    let candidate = mMid[1] + String(bump).padStart(width, "0") + mMid[3] + ext;
+    while (existsSync(join(destDir, candidate))) { bump += 1; candidate = mMid[1] + String(bump).padStart(width, "0") + mMid[3] + ext; }
+    return candidate;
+  }
+  let k = 2;
+  while (existsSync(join(destDir, stem + "-" + k + ext))) k += 1;
+  return stem + "-" + k + ext;
+}
+
 function bookNameFromFileName(fileName) {
   const stem = fileName.replace(/\.[^.]+$/, "");
   // v3.6.0：文件名启发式只取章号前的书名前缀（"斗破苍穹 第1章 陨落.md" → "斗破苍穹"，不再把本章标题拼进书名）
@@ -457,9 +547,9 @@ async function collectTextFiles(dir, recursive, out = [], prefix = "") {
 function formatImport(value) {
   const lines = [`<path>${value.src}</path>`, `<type>novel-import-${value.mode}</type>`, "<content>", ""];
   lines.push(`扫描结果：${value.groups.reduce((n, g) => n + g.files.length, 0)} 个文件 → ${value.groups.length} 组` +
-    (value.skipped.length > 0 ? `（跳过 ${value.skipped.length} 个无法读取的文件）` : ""));
+    (value.skipped.length > 0 ? `（跳过 ${value.skipped.length} 个文件：无法读取或未分类）` : ""));
   for (const group of value.groups) {
-    const from = group.from === "file" ? "文件名" : group.from === "content" ? "文件头内容" : "强制指定";
+    const from = group.from === "file" ? "文件名" : group.from === "content" ? "文件头内容" : group.from === "unclassified" ? "未分类" : "强制指定";
     lines.push("");
     lines.push(`[${group.book}] (来自${from}, ${group.files.length} 个文件)`);
     for (const f of group.files) {
@@ -467,6 +557,10 @@ function formatImport(value) {
       lines.push(`  - ${ch} ${f.file}`);
     }
   }
+  if (value.skipped.length > 0) {
+    lines.push("", "跳过：");
+    for (const item of value.skipped) lines.push(`  - ${item}`);
+  }
   if (value.imported.length > 0) {
     lines.push("");
     lines.push(`已导入 ${value.imported.length} 个文件：`);
@@ -651,20 +745,32 @@ function registerNovelImport(ctx, config) {
       const imported = [];
       if (mode === "apply") {
         for (const group of groups) {
-          if (group.book === "未分类") continue;
+          if (group.book === "未分类") {
+            // v3.9.0：未分类文件不再静默丢弃——计入 skipped 并说明原因
+            for (const row of group.files) skipped.push(row.file + "（未分类，未导入——请用 book 参数指定归属书名后重试）");
+            continue;
+          }
           const safeBook = sanitizeSegment(group.book, "book");
           const destDir = join(novelsDir(root), safeBook);
           await mkdir(destDir, { recursive: true });
           for (const row of group.files) {
             const srcFull = join(src, row.file);
-            // v3.5.0 #19：目标同名已存在 → 自动改名（-2/-3…），不静默覆盖、move 模式不丢源
-            let destFile = basename(row.file);
-            const destBase = destFile.replace(/\.(md|txt)$/i, "");
-            const destExt = destFile.match(/\.(md|txt)$/i)?.[0] || "";
-            let k = 2;
-            while (existsSync(join(destDir, destFile))) {
-              destFile = destBase + "-" + k + destExt;
-              k += 1;
+            // v3.5.0 #19：目标同名已存在 → 自动改名，不静默覆盖、move 模式不丢源
+            // v3.9.0：统一按扩展名处理（.markdown/.docx 等不再丢失扩展名）；章号冲突改用空闲章号
+            // v3.9.0 复查：异形同号也算占用（第一章 vs 第01章 文件名不同但章号相同 → 改名，不再产生重复章号）
+            const rawName = basename(row.file);
+            const rawNum = parseChapterNumber(rawName);
+            let destFile = rawName;
+            if (rawNum !== void 0) {
+              let occupied = false;
+              try {
+                for (const ex of readdirSync(destDir)) {
+                  if (parseChapterNumber(ex) === rawNum) { occupied = true; break; }
+                }
+              } catch { /* 目录不可读按重名处理 */ }
+              if (occupied) destFile = nextFreeChapterFile(destDir, rawName);
+            } else if (existsSync(join(destDir, rawName))) {
+              destFile = nextFreeChapterFile(destDir, rawName);
             }
             const destFull = join(destDir, destFile);
             await copyFile(srcFull, destFull);
@@ -673,6 +779,7 @@ function registerNovelImport(ctx, config) {
           }
         }
       }
+      if (mode === "apply" && imported.length > 0) await noteRoot(root); // v3.9.0：apply 导入后记录书库根
       return { src, mode, groups, skipped, imported };
     }
   });
@@ -828,6 +935,8 @@ async function enrichSemanticImplicit(state, root, book, result, exec) {
   try {
     if (!semanticFeatureEnabled(state, "semanticImplicit")) return result;
     if (!(await embedding.isAvailable())) return result;
+    // v3.9.0 修正：缓存已带 semanticImplicit（miss 路径算好写盘的）→ 直接复用，不再重建索引全量读盘
+    if (result?.emotion?.quantification?.semanticImplicit) return result;
     const dir = bookDir(root, book);
     const chapters = await scanChapters(dir);
     const chunks = [];
@@ -978,6 +1087,20 @@ async function atomicWriteJson(file, obj) {
 
 // v3.5.0 #18：state 读-改-写串行队列（并发 POST 不再互相覆盖）
 let stateWriteChain = Promise.resolve();
+/** v3.9.0：风格基线容差钳制（low ∈ [-99,0]、high ∈ [0,99]，非法键丢弃）——工具与 POST /state 共用 */
+function clampStyleTolerance(tol) {
+  const cleaned = {};
+  if (tol !== null && typeof tol === "object") {
+    for (const [tk, tv] of Object.entries(tol)) {
+      if (tv !== null && typeof tv === "object") {
+        const low = typeof tv.low === "number" ? Math.max(-99, Math.min(0, tv.low)) : void 0;
+        const high = typeof tv.high === "number" ? Math.max(0, Math.min(99, tv.high)) : void 0;
+        if (low !== void 0 && high !== void 0 && low <= high) cleaned[tk] = { low, high };
+      }
+    }
+  }
+  return cleaned;
+}
 async function writeSentenceState(patch) {
   const run = stateWriteChain.then(async function () {
     const current = await readSentenceState();
@@ -988,7 +1111,7 @@ async function writeSentenceState(patch) {
     ...(patch?.tools !== null && typeof patch?.tools === "object" ? { tools: { ...(current.tools ?? {}), ...patch.tools } } : {}),
     ...(typeof patch?.lastRoot === "string" ? { lastRoot: patch.lastRoot } : {}),
     ...(patch?.features !== null && typeof patch?.features === "object" ? { features: { ...(current.features ?? {}), ...patch.features } } : {}),
-    ...(patch?.styleTolerance !== null && typeof patch?.styleTolerance === "object" ? { styleTolerance: patch.styleTolerance } : {}),
+    ...(patch?.styleTolerance !== null && typeof patch?.styleTolerance === "object" ? { styleTolerance: clampStyleTolerance(patch.styleTolerance) } : {}), // v3.9.0：写路径统一钳制
     ...(patch?.styleTolerance === null ? { styleTolerance: null } : {}),
     ...(patch?.creationProfile !== null && typeof patch?.creationProfile === "object" ? { creationProfile: patch.creationProfile } : {}),
     ...(patch?.creationProfile === null ? { creationProfile: null } : {}),
@@ -1062,12 +1185,15 @@ function writeJson(res, status, body) {
 }
 
 /** 读取 JSON 请求体（上限 16KB）。 */
+// v3.9.0 修正：超限哨兵用 Symbol——普通 JSON 无法伪造（{"tooLarge":true} 不再误判 413）
+const BODY_TOO_LARGE = Symbol("bodyTooLarge");
 async function readJsonBody(req) {
   const chunks = [];
   let size = 0;
+  const LIMIT = 1024 * 1024; // v3.9.0：16KB → 1MB（原创模式长设定被 400 拒，UI 静默降级 localStorage）
   for await (const chunk of req) {
     size += chunk.length;
-    if (size > 16384) return void 0;
+    if (size > LIMIT) return { [BODY_TOO_LARGE]: true };
     chunks.push(chunk);
   }
   try { return JSON.parse(Buffer.concat(chunks).toString("utf8")); } catch { return void 0; }
@@ -1163,6 +1289,7 @@ function makeStateRoutes(allowLan, config) {
     }
     if (method === "POST") {
       const body = await readJsonBody(req);
+      if (body && body[BODY_TOO_LARGE]) return writeJson(res, 413, { error: "request body too large (limit 1MB)" });
       if (body === void 0 || body === null || typeof body !== "object" || Array.isArray(body)) return writeJson(res, 400, { error: "invalid JSON body" });
       try {
         // v3.7.0 高3：路由层剥离 novel_sentence_config（与工具侧一致）——UI 一键全关不能锁死 AI 通道（关了 AI 就无法再开）
@@ -1206,6 +1333,12 @@ function makeStateRoutes(allowLan, config) {
       return writeJson(res, 500, { ok: false, error: String(e).slice(0, 200) });
     }
   };
+  // v3.9.0：UI 路由统一根回退（与 GET /state 一致：config.root → lastRoot → cwd）
+  const resolveUiRoot = (cfg, st) => {
+    const c = typeof cfg?.root === "string" && cfg.root.length > 0 ? cfg.root : "";
+    const l = !c && typeof st?.lastRoot === "string" && st.lastRoot.length > 0 ? st.lastRoot : "";
+    return c || l || process.cwd();
+  };
   const revealHandler = async (req, res) => {
     if (!isAllowedRequest(req, allowLan)) return writeJson(res, 403, { error: "forbidden: loopback-only" });
     if ((req.method ?? "GET") !== "POST") return writeJson(res, 405, { error: "method not allowed" });
@@ -1214,8 +1347,8 @@ function makeStateRoutes(allowLan, config) {
     const allowedTargets = ["data-dir", "plots-dir", "settings-dir", "summaries-dir", "analysis-dir", "audits-dir", "embedding-dir", "state-file"];
     if (!allowedTargets.includes(target)) return writeJson(res, 400, { error: 'unknown target (allowed: ' + allowedTargets.join(", ") + ')' });
     const state = await readSentenceState();
-    // v0.8.0：空字符串 root 回退 lastRoot
-    const root = (typeof config?.root === "string" && config.root.length > 0) ? config.root : state.lastRoot;
+    // v3.9.0：与 GET /state 同一回退（config.root → lastRoot → cwd），全新环境不再 404
+    const root = resolveUiRoot(config, state);
     if (typeof root !== "string" || root.length === 0) {
       return writeJson(res, 404, { error: "书库根未知：先在对话中调用一次 novel_plot / novel_settings（或配置插件 root），即可在 UI 中打开数据文件夹。" });
     }
@@ -1246,7 +1379,7 @@ function makeStateRoutes(allowLan, config) {
     if (!isAllowedRequest(req, allowLan)) return writeJson(res, 403, { error: "forbidden: loopback-only" });
     try {
       const state = await readSentenceState();
-      const root = (typeof config?.root === "string" && config.root.length > 0) ? config.root : state.lastRoot;
+      const root = resolveUiRoot(config, state);
       const dataDir = typeof root === "string" && root.length > 0 ? novelDataDir(root) : "";
       const qs = String(req.url || "").split("?")[1] || "";
       const params = new URLSearchParams(qs);
@@ -1359,6 +1492,50 @@ ${value.message ?? ""}
   lines.push(`- 情绪分布: ${emoWords || "无明显情绪词"}`);
   const curve = value.emotion.curve.map((point) => `${point.segment}:${EMOTION_CODE[point.dominant] ?? point.dominant}${point.intensity}`).join(" ");
   lines.push(`- 情感曲线: ${curve || "-"}`);
+  // v3.9.0：render 补全——情感净化预警/量化三指标/细节密度/语义隐性情感（此前只在 value，模型看不到）
+  if (value.emotion && value.emotion.cleanDominant && value.emotion.cleanDominant !== value.emotion.dominant) {
+    lines.push("", "【情感净化预警】");
+    lines.push(`- 规则主导: ${EMOTION_CODE[value.emotion.dominant] ?? value.emotion.dominant}，净化后主导: ${EMOTION_CODE[value.emotion.cleanDominant] ?? value.emotion.cleanDominant}（置信度 ${value.emotion.confidence ?? "?"}）`);
+    if (value.emotion.caveat) lines.push(`- 注意: ${value.emotion.caveat}`);
+    if (value.emotion.aiAction) lines.push(`- 建议: ${value.emotion.aiAction}`);
+    if (value.emotion.pollution && Object.keys(value.emotion.pollution).length > 0) {
+      lines.push(`- 污染词: ${Object.entries(value.emotion.pollution).map(([k, v]) => k + "=" + JSON.stringify(v)).join("; ")}`);
+    }
+  }
+  if (value.emotion && value.emotion.quantification) {
+    const q = value.emotion.quantification;
+    const stats = q.stats || {};
+    if (Object.keys(stats).length > 0) {
+      lines.push("", "【情感量化】");
+      lines.push(`- Valence: 均值 ${stats.meanValence ?? 0}, 方差V ${stats.variance ?? 0}, 相邻撕裂 ${stats.adjVariance ?? 0}, 斜率Δ ${stats.delta ?? 0}, 矛盾指数C ${stats.conflict ?? 0}`);
+      if (q.compare) lines.push(`- 显隐对比: ${JSON.stringify(q.compare).slice(0, 120)}`);
+      if (q.complexity) lines.push(`- 复杂度: ${JSON.stringify(q.complexity).slice(0, 120)}`);
+      if (q.implicit && (q.implicit.ambiguous || []).length > 0) {
+        // v3.9.0 修正：implicit 无 hits 字段（不再输出误导性的「隐性情感句 0 处」）
+        lines.push(`- 隐性意象: 变色龙词 ${(q.implicit.ambiguous || []).length} 个（语义层裁决见下文/quantification.implicit）`);
+      }
+    }
+    if (q.semanticImplicit && (q.semanticImplicit.hits || []).length > 0) {
+      lines.push("", "【语义隐性情感】");
+      const si = q.semanticImplicit;
+      const sample = si.hits.slice(0, 3).map((h) => "[" + (h.top || "?") + "] " + h.text.slice(0, 30)).join(" / "); // v3.9.0 修正：字段是 top（情感标签）
+      lines.push(`- 命中 ${si.hits.length} 处（情感原型语义检索）: ${sample}`);
+      if (si.distribution && Object.keys(si.distribution).length > 0) lines.push(`- 分布: ${JSON.stringify(si.distribution).slice(0, 120)}`);
+    }
+  }
+  if (value.density) {
+    const d = value.density;
+    const parts = [];
+    if (typeof d.actionVerbsPer1000 === "number") parts.push(`动作动词 ${d.actionVerbsPer1000}/千字`);
+    if (typeof d.actionChainRatio === "number") parts.push(`动作链占比 ${d.actionChainRatio.toFixed(1)}%`); // v3.9.0 修正：已是百分数（0~100），不再 ×100
+    if (typeof d.objectNounsPer1000 === "number") parts.push(`物体名词 ${d.objectNounsPer1000}/千字`);
+    if (typeof d.sensePer1000 === "number") parts.push(`感官词 ${d.sensePer1000}/千字`);
+    if (parts.length > 0) {
+      lines.push("", "【细节密度】");
+      lines.push("- " + parts.join(" | "));
+      if (Array.isArray(d.actionChainExamples) && d.actionChainExamples.length > 0) lines.push(`- 动作链例: ${d.actionChainExamples.slice(0, 3).join(" / ")}`);
+    }
+  }
   lines.push("", "【节奏建议】");
   if (value.guidance) {
     for (const line of value.guidance.split("\n")) lines.push(`- ${line}`);
@@ -1571,13 +1748,9 @@ function registerNovelSentenceAnalysis(ctx, config) {
         selected = chapters;
         scope = `全书 ${chapters.length} 章`;
       }
-      let text = "";
-      const chapterTexts = [];
+      // v3.9.0 性能：先 stat 组缓存键——命中缓存时不再全量读章节文本（大书省整次读盘）
       const scopeKeyParts = [];
       for (const chapter of selected) {
-        const chapterText = await readTextFile(join(dir, chapter.file), exec);
-        text += chapterText;
-        if (chapterArg === void 0) chapterTexts.push({ chapter: chapter.file, text: chapterText });
         try {
           const info = await stat(join(dir, chapter.file));
           scopeKeyParts.push(chapter.file + ":" + info.mtimeMs + ":" + info.size);
@@ -1590,7 +1763,7 @@ function registerNovelSentenceAnalysis(ctx, config) {
           book,
           scope,
           enabled: false,
-          totalChars: text.length,
+          // v3.9.0 修正：不输出 totalChars（stat.size 是字节数，会误导为「N 字」；output 顶层无必填约束）
           totalSentences: 0,
           message: "句式模式分析当前已关闭。可在 Web GUI 侧边栏「句式分析」面板开启，或用 novel_sentence_config 设置 enabled=true。"
         };
@@ -1599,27 +1772,40 @@ function registerNovelSentenceAnalysis(ctx, config) {
       const cacheDir = join(novelDataDir(root), "analysis");
       const cacheKey = createHash("sha1").update(book + "|" + scope + "|" + scopeKeyParts.join(",")).digest("hex").slice(0, 20);
       const reportFile = join(cacheDir, book + "-" + cacheKey + ".json");
+      let cachedHit = null;
       if (!fresh) {
         try {
           const cached = JSON.parse(await readFile(reportFile, "utf8"));
           // v3.5.0 #22：缓存带算法版本校验——升级后旧的情感/句式缓存不再命中（防双计旧结果）
           if (cached && cached.ver !== CACHE_VERSION) throw new Error("cache stale");
-          if (!featureEnabled(state, "emotionCaveat") && cached.emotion) {
-            cached.emotion = cropEmotion(cached.emotion);
-          }
-          if (!featureEnabled(state, "emotionComplexity") && cached.emotion?.quantification) {
-            delete cached.emotion.quantification;
-          }
-          await enrichSemanticImplicit(state, root, book, cached, exec);
-          if (args?.brief === true && cached.categories && cached.lengths && cached.emotion) {
-        const top3b = cached.categories.slice().sort(function (a, b) { return b.count - a.count; }).slice(0, 3).map(function (c) { return c.label + " " + Math.round(c.ratio * 100) + "%"; });
-        cached.brief = scope + " " + cached.totalSentences + " 句：句式以 " + top3b.join("、") + " 为主；均句长 " + cached.lengths.avg.toFixed(1) + "；主导情绪 " + (cached.emotion.dominant || "-") + "。";
-      }
-            // v3.5.0 H2：缓存命中剥离内部 ver 键（契约：output schema 无 ver）
-      const { ver: _ver, ...rest } = cached;
-      return { ...rest, book, scope, cache: "hit", reportFile, cachedAt: cached.cachedAt ?? new Date().toISOString() };
+          cachedHit = cached;
         } catch { /* 缓存缺失/损坏，重新分析 */ }
       }
+      if (cachedHit) {
+        // v3.9.0 复查修正：先 enrich（缓存自带 semanticImplicit → 早退零读盘）再裁剪——emotionComplexity 关闭时也不会触发全量重读
+        await enrichSemanticImplicit(state, root, book, cachedHit, exec);
+        if (!featureEnabled(state, "emotionCaveat") && cachedHit.emotion) {
+          cachedHit.emotion = cropEmotion(cachedHit.emotion);
+        }
+        if (!featureEnabled(state, "emotionComplexity") && cachedHit.emotion?.quantification) {
+          delete cachedHit.emotion.quantification;
+        }
+        if (args?.brief === true && cachedHit.categories && cachedHit.lengths && cachedHit.emotion) {
+          const top3b = cachedHit.categories.slice().sort(function (a, b) { return b.count - a.count; }).slice(0, 3).map(function (c) { return c.label + " " + Math.round(c.ratio * 100) + "%"; });
+          cachedHit.brief = scope + " " + cachedHit.totalSentences + " 句：句式以 " + top3b.join("、") + " 为主；均句长 " + cachedHit.lengths.avg.toFixed(1) + "；主导情绪 " + (cachedHit.emotion.dominant || "-") + "。";
+        }
+        // v3.5.0 H2：缓存命中剥离内部 ver 键（契约：output schema 无 ver）
+        const { ver: _ver, ...rest } = cachedHit;
+        return { ...rest, book, scope, cache: "hit", reportFile, cachedAt: cachedHit.cachedAt ?? new Date().toISOString() };
+      }
+      // 缓存未命中（或 fresh）→ 此时才读章节文本
+      let text = "";
+      const chapterTexts = [];
+      for (const chapter of selected) {
+        const chapterText = await readTextFile(join(dir, chapter.file), exec);
+        text += chapterText;
+        if (chapterArg === void 0) chapterTexts.push({ chapter: chapter.file, text: chapterText });
+      }
       const options = { top, maxSentences, curveSegments };
       if (chapterTexts.length > 0) options.chapterTexts = chapterTexts;
       const result = {
@@ -1637,6 +1823,8 @@ function registerNovelSentenceAnalysis(ctx, config) {
           if (resolved) result.emotion.quantification.implicit = resolved;
         }
       } catch { /* 语义裁决失败不阻塞 */ }
+      // v3.9.0 复查修正：先 enrich 后写缓存——缓存文件必须含 semanticImplicit，命中路径才能早退复用（否则每次命中仍全量读盘重建索引）
+      await enrichSemanticImplicit(state, root, book, result, exec);
       try {
         await mkdir(cacheDir, { recursive: true });
         await atomicWriteJson(reportFile, { ...result, cachedAt: new Date().toISOString(), ver: CACHE_VERSION });
@@ -1647,7 +1835,6 @@ function registerNovelSentenceAnalysis(ctx, config) {
       if (!featureEnabled(state, "emotionComplexity") && result.emotion?.quantification) {
         delete result.emotion.quantification;
       }
-      await enrichSemanticImplicit(state, root, book, result, exec);
       if (args?.brief === true && result.categories && result.lengths && result.emotion) {
         const top3 = result.categories.slice().sort(function (a, b) { return b.count - a.count; }).slice(0, 3).map(function (c) { return c.label + " " + Math.round(c.ratio * 100) + "%"; });
         result.brief = scope + " " + result.totalSentences + " 句：句式以 " + top3.join("、") + " 为主；均句长 " + result.lengths.avg.toFixed(1) + "；主导情绪 " + (result.emotion.dominant || "-") + "。" + (result.categories.find(function (c) { return c.type === "ellipsis"; }) && result.categories.find(function (c) { return c.type === "ellipsis"; }).ratio > 0.2 ? "留白较多，注意节奏" : "");
@@ -1668,7 +1855,7 @@ function registerNovelSentenceConfig(ctx, config) {
         enabled: { type: "boolean", description: "写作助手功能总开关。" },
         autoAnalyze: { type: "boolean", description: "分析作品时是否主动使用句式分析。" },
         tools: { type: "object", additionalProperties: true, description: "各工具开关（如 { novel_plot: false }），键必须是 novel_* 工具名。" },
-        features: { type: "object", additionalProperties: true, description: "功能开关（emotionCaveat=情感净化预警 / genreTheme=题材与流派检测），如 { emotionCaveat: false }。" },
+        features: { type: "object", additionalProperties: true, description: "功能开关（emotionCaveat=情感净化预警 / genreTheme=题材与流派检测 / webnovelVibe=网文信号 / rawWriting=非净化直白模式 / semanticEmbedding=本地语义增强），如 { emotionCaveat: false }。注意：rawWriting=true 会跳过 UI 的双重确认+承诺输入流程，仅应在用户明确要求时开启。" },
         styleTolerance: { type: "object", additionalProperties: true, description: "风格基线容差（每维 { low: -20, high: 20 }，low 为负/高为正；空对象 {} 清除恢复推荐——宿主不支持 null 类型，清除一律用空对象）。" },
         creationProfile: { type: "object", additionalProperties: true, description: "原创模式设定（worldview/characters/forbidden/mainConflict/genre/extra 字符串键，留空项省略；空对象 {} 清除全部交给模型——宿主不支持 null 类型）。" },
         creationProfiles: { type: "object", additionalProperties: true, description: "按书专属原创设定（键=书名，值=同上结构；空对象 {} 清除全部书的专属设定——宿主不支持 null 类型）。" }
@@ -1748,7 +1935,9 @@ ${featLines.join("\n")}
           if (args.styleTolerance === null) patch.styleTolerance = null;
           // v3.1.0：空对象 {} = 清除（DSH schema 不支持 type 数组/剥离 null，空 object 是合规的“传了但清空”）
           else if (args.styleTolerance !== null && typeof args.styleTolerance === "object" && Object.keys(args.styleTolerance).length === 0) patch.styleTolerance = null;
-          else if (args.styleTolerance !== null && typeof args.styleTolerance === "object") patch.styleTolerance = args.styleTolerance;
+          else if (args.styleTolerance !== null && typeof args.styleTolerance === "object") {
+            patch.styleTolerance = clampStyleTolerance(args.styleTolerance); // v3.9.0：与 POST /state 共用同一钳制
+          }
         }
         // v3.1.0：原创模式设定（世界观/角色/禁忌/主线/题材/额外要求；null/空对象清除）
         if (args?.creationProfile !== void 0) {
@@ -1841,7 +2030,9 @@ function registerNovelStyleCheck(ctx, config) {
           advice: { type: "string" },
           semantic: { type: "object", additionalProperties: true },
           // v3.0.0：文笔六维基线对照（enabled=false 时仅 note）
-          metric: { type: "object", additionalProperties: true }
+          metric: { type: "object", additionalProperties: true },
+          // v3.8.0：跑偏时附原著锚段（对照修正用）
+          fixAnchors: { type: "array", items: { type: "object", additionalProperties: false, properties: { label: { type: "string" }, text: { type: "string" } }, required: ["label", "text"] } }
         },
         required: ["book", "chapter", "baselineScope", "similarity", "verdict", "diffs", "chapterFingerprint", "baselineFingerprint", "advice", "semantic"]
       },
@@ -1857,6 +2048,11 @@ function registerNovelStyleCheck(ctx, config) {
           lines.push("偏差清单:");
           for (const d of value.diffs) lines.push(`  - ${d.dimension}: ${d.note} (${d.diff > 0 ? "+" : ""}${d.diff})`);
         }
+        if (value.semantic && value.semantic.note) lines.push(`语义对比: ${value.semantic.note}` + (typeof value.semantic.similarity === "number" ? `（${(value.semantic.similarity * 100).toFixed(1)}%）` : ""));
+        if (Array.isArray(value.fixAnchors) && value.fixAnchors.length > 0) {
+          lines.push("", "【对照修正·原著锚段】逐句对比本章对应写法，只修跑偏部分，不得整章重写：");
+          for (const a of value.fixAnchors) lines.push("  [" + a.label + "] " + a.text);
+        }
         lines.push(`本章指纹: ${value.chapterFingerprint}`);
         lines.push(`基线指纹: ${value.baselineFingerprint}`);
         // v3.0.0：文笔六维基线对照
@@ -1903,6 +2099,12 @@ function registerNovelStyleCheck(ctx, config) {
       const baseline = (await bookAnalysisCached(root, book + "__base_" + target.file, baselineText, null)).analysis;
       const chapter = analyzeText(targetText, {});
       const similarity = fingerprintSimilarity(baseline, chapter);
+      // v3.8.0：偏差时附原著锚段（对照修正用，不整章重写）
+      let fixAnchors = [];
+      try {
+        const pkgA = await buildStyleAnchorPackage(root, book, others, exec, baselineChapters); // 复用已读基线章文本
+        fixAnchors = pkgA.anchors.slice(0, 2);
+      } catch { /* 锚段失败不影响判定 */ }
       const diffs = styleDiffs(baseline, chapter);
       const verdict = similarity >= 0.9 ? "high" : similarity >= 0.75 ? "medium" : "low";
       let advice = "";
@@ -1911,7 +2113,8 @@ function registerNovelStyleCheck(ctx, config) {
       } else {
         // v3.7.0 ⑦：方向全映射（原只认"偏高"，"偏长/偏低/偏短"一律输出"略少"）
       const noteMap = { "偏高": "略多", "偏低": "略少", "偏长": "略长", "偏短": "略短" };
-      advice = "续写时建议注意：" + diffs.slice(0, 4).map((d) => d.dimension + (noteMap[d.note] || d.note)).join("、") + "。若为情节需要（如章节情绪转折），可接受适度偏离，但不要持续漂移。";
+      // v3.8.0：跑偏不整章重写——对照 fixAnchors（原著锚段）逐句修正跑偏维度
+      advice = "续写风格偏差：" + diffs.slice(0, 4).map((d) => d.dimension + (noteMap[d.note] || d.note)).join("、") + "。请对照 fixAnchors 中的原著锚段，逐句对比本章对应写法，只修改跑偏的部分（句式/修饰/节奏），不要整章重写；若为情节需要（如章节情绪转折），说明原因后可接受，但不要持续漂移。";
       }
       // v2.0.0：语义级风格对比（本地 embedding，可选增强；开关开且模型可用时生效）
       let semantic = null;
@@ -1996,6 +2199,7 @@ function registerNovelStyleCheck(ctx, config) {
         metric,
         chapterFingerprint: chapter.fingerprint,
         baselineFingerprint: baseline.fingerprint,
+        fixAnchors,
         advice
       });
     }
@@ -2116,35 +2320,57 @@ const meaningful = c.split("\n").map(function (l) { return l.trim(); }).filter(B
 /** v3.1.0：列出书库中的作品名（novels 下目录，跳过创作资料；原创模式书选择器用）。 */
 /** v3.2.0：书库统计（每本：章数/总字数/近 7 天活跃字数，按活跃度排序）——写作打卡卡。 */
 // v3.5.0 #28：书库统计增量缓存——novels 目录与各书目录 mtime 未变则复用（大书库不卡页面）
+// v3.9.0：bookStats 指纹缓存（30s TTL）——指纹用文件 stat（不读内容），命中跳过全量读文本
+const bookStatsCache = { key: null, at: 0, data: null };
 async function bookStats(root) {
   const dir = join(root, "novels");
-  // v3.5.0 R2c：去掉增量缓存——统计本身要读全部章节文本（chars/recent7），缓存键只能靠 mtime/size（Windows 精度不够，同长改文不刷新）；实算最可靠且仅几百毫秒
   try {
     const entries = await readdir(dir, { withFileTypes: true });
-    const out = [];
-    const weekAgo = Date.now() - 7 * 86400000;
+    // 指纹：书目录名 + 章节文件名/size/mtime（不读内容）
+    let fp = "";
+    const bookFiles = [];
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name === "创作资料" || entry.name.startsWith(".")) continue;
       const bookPath = join(dir, entry.name);
-      let chapters = 0, chars = 0, recent7 = 0;
       try {
-        // v3.5.0 #29：只把章节文本文件（.md/.txt）计入章数与字数——图片/备份等非文本不再混入
         const files = await readdir(bookPath, { withFileTypes: true });
+        const list = [];
         for (const f of files) {
-          if (!f.isFile()) continue;
-          if (!/\.(md|markdown|txt)$/i.test(f.name)) continue; // v3.7.0：补 .markdown（与 novel_books 同口径）
+          if (!f.isFile() || !/\.(md|markdown|txt)$/i.test(f.name)) continue;
           const st = await stat(join(bookPath, f.name));
+          fp += entry.name + "/" + f.name + ":" + st.mtimeMs + ":" + st.size + ";";
+          list.push(f.name);
+        }
+        bookFiles.push({ name: entry.name, files: list });
+      } catch { /* 跳过不可读 */ }
+    }
+    // v3.9.0 修正：缓存键含书库根——多 profile/切换工作区不串数据
+    const cacheKey = root + "|" + fp;
+    if (bookStatsCache.key === cacheKey && Date.now() - bookStatsCache.at < 30000) return bookStatsCache.data;
+    const out = [];
+    const weekAgo = Date.now() - 7 * 86400000;
+    for (const book of bookFiles) {
+      const bookPath = join(dir, book.name);
+      let chapters = 0, chars = 0, recent7 = 0;
+      try {
+        for (const fname of book.files) {
+          const full = join(bookPath, fname);
+          const st = await stat(full);
           chapters += 1;
           // v3.5.0 M11：与其余工具同口径解码（GBK/UTF-16 章节字数不再按 UTF-8 误读）
-          const buf11 = await readFile(join(bookPath, f.name));
-          const txt = decodeTextBuffer(buf11, join(bookPath, f.name));
+          const buf11 = await readFile(full);
+          const txt = decodeTextBuffer(buf11, full);
           chars += txt.length;
           if (st.mtimeMs >= weekAgo) recent7 += txt.length;
         }
       } catch { /* 跳过不可读 */ }
-      out.push({ name: entry.name, chapters, chars, recent7Chars: recent7 });
+      out.push({ name: book.name, chapters, chars, recent7Chars: recent7 });
     }
-    return out.sort(function (a, b) { return b.recent7Chars - a.recent7Chars; });
+    const result = out.sort(function (a, b) { return b.recent7Chars - a.recent7Chars; });
+    bookStatsCache.key = root + "|" + fp;
+    bookStatsCache.at = Date.now();
+    bookStatsCache.data = result;
+    return result;
   } catch {
     return [];
   }
@@ -2308,6 +2534,7 @@ function createOutlineTool(config) {
             }
           }
         }
+        await noteRoot(root); // v3.9.0：outline 写操作记录书库根
         return { book, action, message: "创作资料已初始化（" + files.length + " 个文件）" };
       }
 
@@ -2337,6 +2564,7 @@ function createOutlineTool(config) {
         const content = requiredString(args, "content");
         await mkdir(dir, { recursive: true });
         await writeFile(join(dir, CREATION_FILES.bible), content, "utf8");
+        await noteRoot(root); // v3.9.0：outline 写操作记录书库根
         return { book, action, message: "创作设定已更新（" + content.length + " 字）" };
       }
 
@@ -2354,6 +2582,7 @@ function createOutlineTool(config) {
         if (new RegExp("^[-*] " + String(name).replace(/[.*+?^${}()|[\]\\]/g, function (ch) { return "\\" + ch; }) + "(：|$)", "m").test(cur2)) return { book, action, message: "人物\u201c" + name + "\u201d已存在（未重复登记）" };
         await mkdir(dir, { recursive: true });
         await writeFile(f, cur2.endsWith("\n") ? cur2 + line : cur2 + "\n" + line, "utf8");
+        await noteRoot(root); // v3.9.0：outline 写操作记录书库根
         return { book, action, message: "已登记人物“" + name + "”到" + (role === "main" ? "主要" : "次要") + "人物设定" };
       }
 
@@ -2371,6 +2600,7 @@ function createOutlineTool(config) {
         }
         await mkdir(dir, { recursive: true });
         await writeFile(f, cur2.endsWith("\n") ? cur2 + line : cur2 + "\n" + line, "utf8");
+        await noteRoot(root); // v3.9.0：outline 写操作记录书库根
         return { book, action, message: "大纲已补：第 " + number + " 章 " + title };
       }
 
@@ -2390,6 +2620,7 @@ function createOutlineTool(config) {
         const next = re.test(cur2) ? cur2.replace(re, line) : (cur2.endsWith("\n") ? cur2 + line : cur2 + "\n" + line);
         await mkdir(dir, { recursive: true });
         await writeFile(f, next, "utf8");
+        await noteRoot(root); // v3.9.0：outline 写操作记录书库根
         return { book, action, message: "第 " + number + " 章钩子已回填" };
       }
 
@@ -2397,6 +2628,7 @@ function createOutlineTool(config) {
         const content = requiredString(args, "content");
         await mkdir(dir, { recursive: true });
         await writeFile(join(dir, CREATION_FILES.status), content, "utf8");
+        await noteRoot(root); // v3.9.0：outline 写操作记录书库根
         return { book, action, message: "创作状态卡已刷新" };
       }
 
@@ -2553,10 +2785,16 @@ async function readSettings(root, book) {
     return { characters: [], locations: [], items: [], timeline: [], worldview: [] };
   }
 }
+/** v3.9.0：书库写操作后记录 lastRoot（UI「打开文件夹」依赖；吞错不阻塞主功能） */
+async function noteRoot(root) {
+  if (!root) return;
+  try { await writeSentenceState({ lastRoot: root }); } catch { /* 记录失败不影响主功能 */ }
+}
 async function writeSettings(root, book, data) {
   const file = settingsFile(root, book);
   await mkdir(dirname(file), { recursive: true });
   await atomicWriteJson(file, { book, ...data });
+  await noteRoot(root); // v3.9.0：settings 写操作统一记录书库根
 }
 function normalizeSettingEntry(entry) {
   const out = { name: String(entry.name) };
@@ -2624,7 +2862,18 @@ function registerNovelStyleReport(ctx, config) {
         },
         required: ["book", "report"]
       },
-      render: (_args, value) => [{ type: "text", text: value.report }]
+      render: (_args, value) => {
+        const lines = [value.report || ""];
+        if (Array.isArray(value.anchors) && value.anchors.length > 0) {
+          lines.push("", "【风格锚·原著段落（续写照样例写，数字只做事后校验）】");
+          for (const a of value.anchors) lines.push("  [" + a.label + "] " + a.text);
+        }
+        if (Array.isArray(value.skeletons) && value.skeletons.length > 0) {
+          lines.push("", "【句式骨架（按此形状造句）】");
+          for (const sk of value.skeletons) lines.push("  [" + sk.type + "] " + sk.text);
+        }
+        return [{ type: "text", text: lines.join("\n") }];
+      }
     },
     async execute(args, exec) {
       await assertToolEnabled(config, "novel_style_report");
@@ -2648,6 +2897,8 @@ function registerNovelStyleReport(ctx, config) {
         }
       }
       const { text, chapters } = await readBookAllText(root, book, exec);
+      // v3.8.0：风格锚包（原著代表性段落 + 句式骨架——生成端照样例写，勿只依赖数字基线）
+      const anchorPkg = await buildStyleAnchorPackage(root, book, chapters, exec, text); // 复用 readBookAllText 已读全文
       const featState = await readSentenceState();
       // v2.6.0：复用全书分析缓存（大书不再每次重算 analyzeText/detectCulture/流派题材）
       const { analysis, detection } = await bookAnalysisCached(root, book, text, featState);
@@ -2745,6 +2996,7 @@ function registerNovelStyleReport(ctx, config) {
       } else lines.push("  （测量失败）");
       lines.push("");
       lines.push("── 以上全部为插件测量数据，不包含任何风格判断 ──");
+      lines.push("【风格锚包】anchors/skeletons 字段含原著代表性段落与句式骨架——续写时照样例写，数字基线只做事后校验。");
       lines.push("请结合六个维度判断本书的风格气质、读者感受与写法特征。");
       const reportText = lines.join("\n");
       const saved = {};
@@ -2780,6 +3032,7 @@ function registerNovelStyleReport(ctx, config) {
         const dims = Object.keys(result.baseline).filter(function (k) { return result.baseline[k] && typeof result.baseline[k].mu === "number"; });
         result.brief = "全书 " + result.chars + " 字：六维基线 μ=" + dims.map(function (k) { return k + ":" + result.baseline[k].mu.toFixed(1); }).join(" ") + "；推荐容差 " + dims.map(function (k) { return result.baseline[k].recTol + "%"; }).slice(0, 3).join("/") + "…。";
       }
+      if (judgment) await noteRoot(root); // v3.9.0：判断保存记录书库根
       return cleanOutput({
         book,
         chars: result.chars,
@@ -2791,12 +3044,68 @@ function registerNovelStyleReport(ctx, config) {
         dimensions: { fingerprint: analysis.fingerprint, culture: result.culture, genre: result.genre?.dominant, theme: result.theme?.dominant, emotion: emotion.cleanDominant, vibe: Object.fromEntries(vibe.axes.slice(0, 12).map((a) => [a.name, a.score])) },
         semantic: semantic.map((s, i) => ({ ...s, discrim: i === 0 && semantic.length >= 2 ? Math.round((semantic[0].score - semantic[1].score) * 1000) / 1000 : null })),
         ...(judgment ? { saved: { savedAt: saved.savedAt, ...(saved.error ? { error: saved.error } : {}) }, savedJudgment: judgment } : {}),
-        message: judgment ? "风格画像报告已生成，判断结果已保存" : "风格画像报告已生成（仅测量数据，判断请由 AI 完成并回传保存）"
+        anchors: anchorPkg.anchors,
+        skeletons: anchorPkg.skeletons,
+        message: judgment ? (saved?.error ? "风格画像报告已生成，但判断保存失败：" + saved.error : "风格画像报告已生成，判断结果已保存") : "风格画像报告已生成（仅测量数据，判断请由 AI 完成并回传保存）"
       });
     }
   });
 }
 
+/** v3.8.0：风格锚包——从原著抽取代表性段落（anchors）与句式骨架（skeletons）。
+ * 理念：生成端只喂原文样例（LLM 擅模仿不擅服从数字），统计基线只做校验。纯规则实现，无 embedding 依赖，成本≈0。 */
+async function buildStyleAnchorPackage(root, book, chapters, exec, preloadedText) {
+  const anchors = [];
+  const skeletons = [];
+  try {
+    // v3.8.0 性能：复用调用方已读文本（preloadedText=string 全文 / {file,text}[] 数组）——大书不再双读
+    let allText = "";
+    if (typeof preloadedText === "string" && preloadedText.length > 0) {
+      allText = preloadedText;
+    } else if (Array.isArray(preloadedText)) {
+      allText = preloadedText.map(function (x) { return x.text || ""; }).join("\n");
+    } else {
+      const dir = bookDir(root, book);
+      for (const ch of chapters) allText += (await readTextFile(join(dir, ch.file), exec)) + "\n";
+    }
+    const paras = allText.split(/\n+/).map(function (p) { return p.trim(); }).filter(function (p) { return p.length >= 40; });
+    const pick = function (list, label, n) {
+      let got = 0;
+      for (const p of list) {
+        if (got >= n) break;
+        anchors.push({ label: label, text: p.slice(0, 200) });
+        got += 1;
+      }
+    };
+    const dialogue = paras.filter(function (p) { return /["“]/.test(p) && p.length <= 200; });
+    const psych = paras.filter(function (p) { return /想|觉得|心|怕|慌|记忆/.test(p) && !/["“]/.test(p) && p.length <= 200; });
+    const desc = paras.filter(function (p) { return !/["“]/.test(p) && p.length >= 80 && p.length <= 200; });
+    pick(dialogue, "对话", 2);
+    pick(psych, "心理", 1);
+    pick(desc, "描写", 2);
+    if (anchors.length === 0) {
+      for (const p of paras.slice(0, 3)) anchors.push({ label: "原文", text: p.slice(0, 200) });
+    }
+    const sentences = allText.split(/[。！？…]+/).map(function (s) { return s.replace(/\s+/g, "").trim(); }).filter(function (s) { return s.length >= 20 && s.length <= 45; });
+    const seen = new Set();
+    for (const s of sentences) {
+      if (skeletons.length >= 4) break;
+      if (seen.has(s)) continue;
+      seen.add(s);
+      let type = "陈述";
+      if (/["“]/.test(s)) type = "对话";
+      else if (/[？?]$/.test(s)) type = "疑问";
+      else if (/想|觉得|仿佛|好像|似乎/.test(s)) type = "心理";
+      skeletons.push({ type: type, text: s });
+    }
+    if (skeletons.length === 0) {
+      const firsts = allText.split(/\n+/).map(function (p) { return p.trim(); }).filter(function (p) { return p.length >= 15; }).slice(0, 4);
+      for (const ft of firsts) skeletons.push({ type: "陈述", text: ft.slice(0, 60) });
+    }
+  } catch { /* 锚包失败不影响主功能 */ }
+  return { anchors: anchors.slice(0, 4), skeletons: skeletons.slice(0, 4) };
+}
+
 function parseEvidenceCounts(arr) {
   let n = 0;
   for (const item of arr || []) {
@@ -2994,9 +3303,16 @@ function registerNovelSettings(ctx, config) {
           list.splice(index, 1);
           message = `已删除 ${categoryLabel}：${name}`;
         } else {
+          const oldDay = category === "timeline" ? list[index].day : void 0; // v3.9.0：改名同步前记录旧 day
           for (const key of ["description", "traits", "relationships", "firstSeen", "owner", "status", "lastSeen", "event", "chapter", "notes", "basis", "ritual", "day"]) {
             if (args?.[key] !== void 0) list[index][key] = String(args[key]);
           }
+          // v3.9.0：timeline 的 day 变更时同步 name（否则身份字段分裂：{name:第1天, day:第2天} 渲染/归一歧义）
+          if (category === "timeline" && args?.day !== void 0) {
+            // name 与旧 day 相同（add 时同步的别名）→ 跟随新 day
+            if (list[index].name === oldDay) list[index].name = String(args.day);
+            else if (!list[index].name) list[index].name = String(args.day);
+          }
           // v3.5.0 #13：speechStyle 对象字段（update 也要支持）
           if (args?.speechStyle !== void 0 && args.speechStyle !== null && typeof args.speechStyle === "object") {
             list[index].speechStyle = { ...(list[index].speechStyle ?? {}), ...args.speechStyle };
@@ -3010,7 +3326,8 @@ function registerNovelSettings(ctx, config) {
         await writeSettings(root, book, data);
         // v1.0.2：update 返回单条
         if (action === "update") {
-          const updated = list.find((e) => e.name === lastSettingName);
+          // v3.9.0：改名后 lastSettingName 可能已失效（name 跟随 day 变更）——直接用索引取
+          const updated = list[index];
           const result = { book, category, action, message };
           result[listKey] = updated ? [normalizeSettingEntry(updated)] : [];
           return result;
@@ -3200,6 +3517,7 @@ function registerNovelSummary(ctx, config) {
         }
         await mkdir(dirname(summariesFile(root, book)), { recursive: true });
         await atomicWriteJson(summariesFile(root, book), { book, summaries });
+        await noteRoot(root); // v3.9.0：summary 写操作记录书库根
         // v1.0.2：add/update 返回单条确认（不再返回全量列表）
         if (action === "add" || action === "update") {
           const single = summaries[index !== -1 ? index : summaries.length - 1];
@@ -4112,11 +4430,13 @@ function registerNovelRead(ctx, config) {
         // v3.5.0 #11：单行超长裁剪（防首行超长绕过上限）
         let line = allLines[i];
         if (line.length > 3000) line = line.slice(0, 3000) + "…（行过长已裁剪）";
-        chars += line.length + (i < allLines.length - 1 ? 1 : 0);
-        if (chars > READ_MAX_CHARS && lines.length > 0) {
+        // v3.9.0：先判断后累加——截断行不计入；换行只算「与上一已返回行之间」的（与 lines.join("\n") 口径一致，截断在中间时末尾换行不再多算）
+        const addChars = line.length + (lines.length > 0 ? 1 : 0);
+        if (chars + addChars > READ_MAX_CHARS && lines.length > 0) {
           hitCharCap = true;
           break;
         }
+        chars += addChars;
         lines.push({ number: i + 1, text: line });
       }
       // v3.5.0 #10：truncated 真实判定——字符上限/行数上限/未到文件尾任一即截断
@@ -4282,18 +4602,28 @@ function registerNovelNewChapter(ctx, config) {
           chars: { type: "integer" },
           // v3.7.0：强制风格基线——创建章节时自动附全书六维基线摘要（模型动笔前必得数据）
           baseline: { type: "string" },
-          reminder: { type: "string" }
+          reminder: { type: "string" },
+          // v3.8.0：风格锚包——原著代表性段落 + 句式骨架（照样例写，数字只做校验）
+          anchors: { type: "array", items: { type: "object", additionalProperties: false, properties: { label: { type: "string" }, text: { type: "string" } }, required: ["label", "text"] } },
+          skeletons: { type: "array", items: { type: "object", additionalProperties: false, properties: { type: { type: "string" }, text: { type: "string" } }, required: ["type", "text"] } }
         },
         required: ["book", "number", "file", "path", "chars"]
       },
-      render: (_args, value) => [{
-        type: "text",
-        text: `<path>${value.path}</path>
-<type>novel-chapter-created</type>
-<content>
-Created 第${String(value.number).padStart(2, "0")}章 (${value.chars} chars)
-</content>`
-      }]
+      render: (_args, value) => {
+        const lines = [`<path>${value.path}</path>`, "<type>novel-chapter-created</type>", "<content>", `已创建 第${String(value.number).padStart(2, "0")}章（${value.chars} 字）`];
+        if (value.baseline) { lines.push("", "【风格基线 μ】" + value.baseline); }
+        if (Array.isArray(value.anchors) && value.anchors.length > 0) {
+          lines.push("", "【风格锚·原著段落】动笔照此味道写（数字基线只做事后校验）：");
+          for (const a of value.anchors) lines.push("  [" + a.label + "] " + a.text);
+        }
+        if (Array.isArray(value.skeletons) && value.skeletons.length > 0) {
+          lines.push("", "【句式骨架】按此形状造句：");
+          for (const sk of value.skeletons) lines.push("  [" + sk.type + "] " + sk.text);
+        }
+        if (value.reminder) lines.push("", value.reminder);
+        lines.push("</content>");
+        return [{ type: "text", text: lines.join("\n") }];
+      }
     },
     async execute(args, exec) {
       await assertToolEnabled(config, "novel_new_chapter");
@@ -4328,9 +4658,10 @@ Created 第${String(value.number).padStart(2, "0")}章 (${value.chars} chars)
       await writeFile(filePath, text, { encoding: "utf8", signal: exec.signal });
       // v3.7.0：强制风格基线——创建章节时自动计算全书六维基线附在返回中（即使模型没先调 novel_style_report，也能拿到基线）
       let baselineLine = "";
+      let anchorPkg = { anchors: [], skeletons: [] };
+      let bTexts = [];
       try {
         const allChs = await scanChapters(dir);
-        const bTexts = [];
         for (const ch of allChs) {
           if (ch.file === fileName) continue;
           bTexts.push({ file: ch.file, text: await readTextFile(join(dir, ch.file), exec) });
@@ -4341,8 +4672,12 @@ Created 第${String(value.number).padStart(2, "0")}章 (${value.chars} chars)
           baselineLine = METRIC_ORDER.map(function (k) { return METRIC_LABELS[k] + " " + (bl[k] && typeof bl[k].mu === "number" ? bl[k].mu : "-"); }).join(" / ");
         }
       } catch { /* 基线计算失败不影响章节创建 */ }
-      const reminder = "本章已创建（第" + String(number).padStart(2, "0") + "章）。【风格基线强制流程】动笔前请对照上方 baseline 六维 μ（完整基线可再调 novel_style_report 获取每维 σ 与容差带）；写完本章后必须调用 novel_style_check 对照基线——verdict 低于 high 或任一维度出带，需修正文风或说明情节需要，不得跳过。";
-      return cleanOutput({ book, number, file: fileName, path: filePath, chars: text.length, baseline: baselineLine, reminder });
+      try {
+        anchorPkg = await buildStyleAnchorPackage(root, book, chapters, exec, bTexts); // 复用基线计算已读文本
+      } catch { /* 锚包失败不影响创建 */ }
+      const reminder = "本章已创建（第" + String(number).padStart(2, "0") + "章）。【风格基线强制流程】① 动笔前：对照上方 baseline 六维 μ，并按 anchors/skeletons 原著样例的味道与句式骨架写（数字只做校验，样例才是写法）；② 写完：必须调用 novel_style_check 对照——verdict 低于 high 或出带时，按返回的 fixAnchors 原著锚段逐句修正跑偏部分，不得整章重写；属情节需要则说明原因。";
+      await noteRoot(root); // v3.9.0：新章创建记录书库根
+      return cleanOutput({ book, number, file: fileName, path: filePath, chars: text.length, baseline: baselineLine, reminder, anchors: anchorPkg.anchors, skeletons: anchorPkg.skeletons });
     }
   });
 }

package/lib/prompts.js

@@ -22,6 +22,7 @@ const WORKFLOW_TEXT = [
   "   以及用 novel_keywords 提取的高频关键词（作者词汇偏好与意象母题），并说明这些手法/关键词在具体章节中的例证。",
   "3. 续写 / 辅助写作时：先通读最近的章节（保持人物、时间线、情节伏笔、文风与已提炼的关键词一致），再动笔。",
   "   【强制·风格基线】动笔前必须调用 novel_style_report 读取全书六维风格基线（μ/σ/容差带）并记录；novel_new_chapter 创建章节时会自动附基线 μ 摘要——若基线与你从正文感受的文风不符，以基线数据为准。",
+  "   【v3.8.0·锚包写作】novel_style_report / novel_new_chapter 返回的 anchors（原著代表性段落）与 skeletons（句式骨架）是风格锚——动笔时照锚段的味道与句式的形状写，数字基线只做事后校验；不要试图把数字翻译成写作规则。",
   "   新章节写入 novels/<书名>/ 文件夹：用 novel_new_chapter 创建章节文件，或直接用 write 工具写文件。",
   "4. 句式模式分析（增强，受 UI 开关控制）：分析作品时可调用 novel_sentence_analysis 提取句式分布（陈述/环境/心理/对话/疑问/反问/感叹/祈使/省略留白九类）、",
   "   句式排列规律（转移、高频模板、段首段尾句式、按章节的压缩节奏序列）、句长节奏、情感曲线、风格指纹与节奏建议，用于快速掌握作者的写作习惯与主观情感。",
@@ -34,7 +35,7 @@ const WORKFLOW_TEXT = [
   "   若发现异名同书（如\"旧版/精修版\"实为同一本），用 book 参数强制合并后以 apply 模式导入到 novels/<书名>/ 分类存放。",
   "6. 每次续写前先简述：上一章结尾状态 → 本章目标 → 写作计划，再给出正文。",
   "7. 工具链提示：续写/分析前可用 novel_plot 查看未回收伏笔（open 条目，含类型/优先级/提及章节）；",
-  "   【强制·写完对照】每写完一章必须调用 novel_style_check 对照基线（相似度+偏差+细节密度）——verdict 低于 high 或任一维度出带必须修正文风，或说明情节需要；novel_plot scan 自动更新伏笔提及记录；",
+  "   【强制·写完对照】每写完一章必须调用 novel_style_check 对照基线（相似度+偏差清单+六维判定）——verdict 低于 high 或任一维度出带时，按返回的 fixAnchors（原著锚段）逐句对照修正跑偏部分，不得整章重写；确属情节需要则说明原因；novel_plot scan 自动更新伏笔提及记录；",
   "   世界观一致性：续写前先确认文化基准——novel_settings category=worldview action=detect 自动判断（或人工 add/update），动笔时对照其 bannedWords/recommended 用词，避免中西意象混搭（如欧式背景不写老夫/上香/时辰）；novel_continuity_check 会扫描用语冲突候选；",
   "   语用一致性：不只管词，还要管'怎么说话'——对照 worldview 的 speechStyle（title 称谓规范/honorBad 客套禁词/ritualBadPatterns 仪式禁式/tone 语气），人物开口前检查称谓是否欧式（Miss+名）、客套是否避免'提点/承蒙/在下'、宗教仪式是否点烛而非烧香/上X柱香、对话是否口语化不文言；",
   "   novel_settings 维护五张设定表（人物/地点/道具/时间线/世界观用语规范），novel_summary 保存每章摘要（长书续写先读摘要再按需细读），novel_continuity_check 输出设定矛盾候选；",

package/lib/vibe.js

@@ -102,6 +102,8 @@ const THEME_AXIS_LINK = [
  * @returns 氛围光谱 { axes, top, conclusion, confidence, evidence }
  */
 export function computeVibe(detect, emotion, text = "") {
+  // v3.9.0 修正：外部直接传 null/undefined 不抛（v3.8 的 if (text) 防御恢复）
+  text = typeof text === "string" ? text : String(text ?? "");
   const ev = detect.evidence || {};
   const wF = parseFreq(ev.western || []);
   const mF = parseFreq(ev.modern || []);
@@ -134,8 +136,18 @@ export function computeVibe(detect, emotion, text = "") {
     for (const w of axisWords) { if (w.length >= 2 && w.length <= 4) signalLens.add(w.length); else if (w.length > 4) longWords.add(w); }
   }
   const textWordCounts = new Map();
-  if (text) {
-    for (const run of String(text).match(/[\u4e00-\u9fa5]{2,}/g) || []) {
+  // v3.9.0 性能：n-gram 滑窗限长（大书 50 万字 ~150 万键 → 上限 ~60 万键）
+  // v3.9.0 修正：头/中/尾三段等距抽样（只取头部会让集中在末尾的信号词完全丢失——实测甜宠词失真 0.089 vs 0.033）
+  const NGRAM_LIMIT = 200000;
+  let scanText = text;
+  if (scanText.length > NGRAM_LIMIT) {
+    const seg = Math.floor(scanText.length / 3);
+    const third = Math.floor(NGRAM_LIMIT / 3);
+    // v3.9.0 复查修正：第三段取 slice(-third) 覆盖真正的文末（原 seg*2 是「最后 1/3 的开头」，末尾约 1/9 永不采样）
+    scanText = scanText.slice(0, third) + scanText.slice(seg, seg + third) + scanText.slice(-third);
+  }
+  if (scanText) {
+    for (const run of String(scanText).match(/[\u4e00-\u9fa5]{2,}/g) || []) {
       for (const L of signalLens) {
         for (let i = 0; i + L <= run.length; i++) {
           const w = run.slice(i, i + L);
@@ -146,7 +158,7 @@ export function computeVibe(detect, emotion, text = "") {
     // >4 字词：直接 indexOf 计数（这些词低频出现，全文本扫一遍开销可忽略）
     for (const lw of longWords) {
       let from = 0, cnt = 0;
-      while ((from = text.indexOf(lw, from)) !== -1) { cnt++; from += lw.length; }
+      while ((from = scanText.indexOf(lw, from)) !== -1) { cnt++; from += lw.length; }
       if (cnt > 0) textWordCounts.set(lw, cnt);
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-novel-writer",
-  "version": "3.7.1",
-  "description": "小说写作助手插件（v3.7.0）：句式/情感/意象分析、伏笔设定管理、本地语义检索、氛围光谱、风格画像报告、文笔六维基线带、原创模式与创作资料、写作哨兵（衔接/OOC/大纲）。",
+  "version": "3.9.0",
+  "description": "小说写作助手插件（v3.9.0）：句式/情感/意象分析、伏笔设定管理、本地语义检索、氛围光谱、风格画像报告、文笔六维基线带、原创模式与创作资料、写作哨兵（衔接/OOC/大纲）。",
   "type": "module",
   "main": "lib/index.js",
   "exports": {

package/skills/novel-writing/SKILL.md

@@ -30,8 +30,9 @@
 ## 风格自检（v0.6.0 新增，v3.7.0 起强制）
 
 - **续写前必须读基线**：动笔前调用 `novel_style_report`（完整版，包含每维 μ/σ/容差带；或 brief 拿 μ 摘要）确认本书六维风格基线；`novel_new_chapter` 创建章节时会自动附基线 μ 摘要——若发现与自己从正文中感受到的文风不符，以基线数据为准。
+- **v3.8.0 锚包写作**：report / new_chapter 返回的 `anchors`（原著代表性段落）与 `skeletons`（句式骨架）是风格锚——动笔时**照锚段的味道与句式形状写**，数字基线只做事后校验；不要试图把数字翻译成写作规则（语言概括有损且模型不可执行）。
 - **写完必须对照**：每写完一章调用 `novel_style_check`：本章 vs 全书其余章节 → 相似度 + 偏差清单 + 建议；
-- **强制判定**：verdict 低于 high，或任一维度出带（metric verdicts 含 out），必须修正文风（对话/心理占比、句长、情绪、留白），除非确有情节需要并在回复中说明原因；
+- **强制判定（v3.8.0 对照修正）**：verdict 低于 high，或任一维度出带（metric verdicts 含 out）时，按返回的 `fixAnchors` 原著锚段**逐句对照修正跑偏部分，不得整章重写**；确属情节需要则说明原因；
 - 对照结果应体现在续写说明中（偏差维度 + 是否修正）。
 
 ## 设定管理（v0.8.0 新增）