dsh-novel-writer 3.9.0 → 3.9.5

package/cordis.patch.yml

@@ -1,4 +1,4 @@
-# dsh-novel-writer v3.9.0 bundle patch: 16 tools (incl. novel_semantic_search) + local embedding engine.
+# dsh-novel-writer v3.9.5 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/analysis.js

@@ -106,12 +106,10 @@ const RHETORIC_MARKERS = [
   /不是[^。！？]{0,10}吗/
 ];
 
-/** 一般疑问句特征词。 */
-const QUESTION_WORDS = ["谁", "什么", "为什么", "怎么", "怎样", "如何", "哪", "几", "多少", "何时", "哪里", "哪儿", "是否", "能不能", "会不会", "要不要", "行不行", "好不好", "对不对", "有没有", "为啥", "吗", "么", "呢"];
-
-/** 祈使句动词/命令词。 */
-const IMPERATIVE_HARD = ["请", "快", "赶紧", "立刻", "马上", "别", "不要", "莫", "勿", "不许", "不准", "滚", "住手", "放手", "站住", "听我说", "给我", "让", "快点儿", "快点"];
-const IMPERATIVE_START = ["走", "来", "去", "坐", "站", "停", "开始", "出发", "算了吧", "算了", "吃", "喝", "看", "听", "说", "做", "干", "起来", "坐下", "住口"];
+/** 祈使句硬词（v3.9.1 #7）：句首出现即祈使（感叹只留给无祈使词的 !/！ 句）。 */
+const IMPERATIVE_HARD = ["不准", "不许", "禁止", "闭嘴", "住手", "住口", "站住", "停下", "小心", "当心", "注意", "赶紧", "立刻", "马上", "给我", "跟我", "起来", "坐下", "躺下", "放下", "松开", "放开", "请", "快", "别", "勿", "莫", "滚"];
+/** 祈使句动词（句首、需带命令语气：吧/标点/句尾——"走了几步"这类陈述不算）。 */
+const IMPERATIVE_VERBS = ["去", "来", "走"];
 
 /** 环境描写标记词（天色/天气/景物类名词，来自 v0.4.0，v0.6.0 扩充）。 */
 const ENV_MARKERS = /夜色|月光|晨光|暮色|夕阳|黄昏|清晨|深夜|夜空|天边|星光|灯火|细雨|微风|大雨|暴雨|风雪|薄雾|浓雾|云层|远山|山影|河面|湖水|街道|巷子|烛火|窗|雨声|风声|树影|落叶|残雪|霜|天色|晚风|夜风|晨曦|晚霞|晴空|雨滴|溪水|江水|海浪|沙漠|草原|森林|群山|雪地|庭院|檐下|廊下/;
@@ -127,7 +125,11 @@ export function splitBlocks(text) {
   const normalized = String(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
   const lines = normalized.split("\n");
   // 段落分隔符 = 前后都有内容的"中间空行"；仅开头/结尾的空行不算分段。
-  const hasBlank = lines.some((line, index) => line.trim() === "" && index > 0 && index < lines.length - 1);
+  // v3.9.1 #4：hasBlank 必须同时要求空行两侧都是非空行——文末 \n\n 不再把全文并成一块
+  const hasBlank = lines.some((line, index) =>
+    line.trim() === "" && index > 0 && index < lines.length - 1 &&
+    lines[index - 1].trim() !== "" && lines[index + 1].trim() !== ""
+  );
   const blocks = [];
   let current = [];
   for (const line of lines) {
@@ -243,16 +245,24 @@ function isExclamation(text) {
   return false;
 }
 
+/**
+ * v3.9.1 #7：硬祈使判定——句首硬祈使词（可带呼语前缀），或句首单字动词 去/来/走
+ * 且紧跟命令语气（吧/句末标点/句尾），或含"吧"的非疑问句。
+ * 疑问/反问在前置阶段已返回，这里不重复处理。
+ */
 function isImperative(text) {
-  if (!/吧/.test(text) && !/[！!]$/.test(text)) return false;
-  for (const verb of IMPERATIVE_HARD) {
-    if (text.includes(verb)) return true;
-  }
-  return new RegExp("^(你|您|我们|咱们|大家)?(" + IMPERATIVE_START.join("|") + ")").test(text) && /吧/.test(text);
+  const starts = "^(你|您|我们|咱们|大家|喂)?(" + IMPERATIVE_HARD.sort(function (a, b) { return b.length - a.length; }).join("|") + ")";
+  if (new RegExp(starts).test(text)) return true;
+  const verbRe = new RegExp("^(你|您|我们|咱们|大家|喂)?(" + IMPERATIVE_VERBS.join("|") + ")(吧|[。！？!?…]|$)");
+  if (verbRe.test(text)) return true;
+  // "太好了吧！"这类感叹式"吧"句不算祈使（太…了吧 → 感叹留给 isExclamation）
+  if (/太[^。！？]{0,12}了吧/.test(text)) return false;
+  return /吧/.test(text);
 }
 
 /**
- * 单句分类（优先级：对话 > 心理 > 反问 > 疑问 > 感叹 > 祈使 > 环境 > 省略 > 陈述）。
+ * 单句分类（优先级：对话 > 心理 > 反问 > 疑问 > 祈使 > 感叹 > 环境 > 省略 > 陈述）。
+ * v3.9.1 #7：祈使先于感叹判定——含祈使词的 !/！ 句是祈使，感叹只留给无祈使词的 !/！ 句。
  * 引语优先：引号内的直接引语算对话；引号内含心理标记（内心独白）算心理。
  */
 export function classifySentence(raw) {
@@ -267,26 +277,35 @@ export function classifySentence(raw) {
   if (hasPsychMarker(text)) return { type: "psychology", text, quoted: false };
   if (isRhetoric(text)) return { type: "rhetoric-question", text, quoted: false };
   if (isQuestion(text)) return { type: "question", text, quoted: false };
-  if (isExclamation(text)) return { type: "exclamation", text, quoted: false };
   if (isImperative(text)) return { type: "imperative", text, quoted: false };
+  if (isExclamation(text)) return { type: "exclamation", text, quoted: false };
   if (ENV_MARKERS.test(text)) return { type: "environment", text, quoted: false };
   if (/…+$/.test(text)) return { type: "ellipsis", text, quoted: false };
   return { type: "statement", text, quoted: false };
 }
 
-/** 单字情感词的多字搭配排除（"叹气"不算"气"、"笑道"不算"笑"）。 */
-const EMOTION_EXCLUDE = {
-  joy: { "笑": ["笑道", "说笑", "玩笑", "搞笑", "笑话", "苦笑", "冷笑", "嘲笑", "嬉笑", "傻笑", "微笑", "笑死", "笑呵呵", "笑眯眯"] },
-  anger: { "气": ["叹气", "运气", "客气", "一口气", "服气", "脾气", "争气", "节气", "淘气", "景气", "暖气", "口气", "名气", "勇气", "底气", "俗气", "风气", "香气", "水气", "湿气", "潮气", "和气", "生气勃勃"], "生气": ["生气勃勃"] },
-  sorrow: { "悲": ["慈悲"], "哭": ["哭丧"] },
-  fear: { "怕": ["哪怕", "只怕", "生怕"] },
-  surprise: { "愣": ["愣住"] }
-};
-
-/** 情感词前紧邻的否定字（"不害怕"不计入恐惧）。 */
-const EMOTION_NEGATORS = new Set(["不", "没", "无", "别", "莫", "未"]);
+/**
+ * v3.9.1 #6：EMOTION_EXCLUDE（单字情感词的多字搭配排除）已删除——STRONG/WEAK 情感词表
+ * 与 DUTIR 兜底词表都不含单字词（叹气/笑道里的"气/笑"从来不会被查），该排除分支是
+ * 永不触发的死代码；行为与现状一致（"叹气"不产生 anger 等）。
+ *
+ * v3.9.1 #5：情感否定统一判定。命中情感词时检查其前 1-3 字：
+ * - 单字否定：不/没/无/别/莫/未
+ * - 双/三字否定前缀：不要/不用/不必/不再/不是/并非/绝非/毫不/丝毫不/从不/从未/没有/没啥/未曾/无法/难以
+ */
+const NEGATION_PREFIXES = ["不要", "不用", "不必", "不再", "不是", "并非", "绝非", "毫不", "丝毫不", "从不", "从未", "没有", "没啥", "未曾", "无法", "难以"];
+const NEGATION_SINGLE = new Set(["不", "没", "无", "别", "莫", "未"]);
+
+/** text[idx] 起的情感词命中是否被紧邻否定语否定。 */
+function negatedAt(text, idx) {
+  if (idx <= 0 || idx >= text.length) return false;
+  if (NEGATION_SINGLE.has(text[idx - 1])) return true;
+  if (idx >= 2 && NEGATION_PREFIXES.includes(text.slice(idx - 2, idx))) return true;
+  if (idx >= 3 && NEGATION_PREFIXES.includes(text.slice(idx - 3, idx))) return true;
+  return false;
+}
 
-/** 情感词计数（v0.6.0：扫描式匹配 + 搭配排除 + 否定过滤 + 副词窗口加权）。 */
+/** 情感词计数（v0.6.0：扫描式匹配 + 否定过滤 + 副词窗口加权）。 */
 function emotionOf(text) {
   const scores = { joy: 0, anger: 0, sorrow: 0, fear: 0, surprise: 0 };
   const cleanScores = { joy: 0, anger: 0, sorrow: 0, fear: 0, surprise: 0 };
@@ -303,27 +322,8 @@ function emotionOf(text) {
       while (from < text.length) {
         const idx = text.indexOf(word, from);
         if (idx === -1) break;
-        // 单字词的搭配排除（如"叹气"中的"气"）
-        const exclude = EMOTION_EXCLUDE[emotion]?.[word];
-        if (exclude !== void 0) {
-          // v3.5.0 #54：窗口按最长排除词取（"生气勃勃"=4 字，旧窗口永远命不中）
-          const maxLen = Math.max(4, ...exclude.map(function (x) { return x.length; }));
-          const two = text.slice(Math.max(0, idx - 1), idx + 2);
-          const prevTwo = text.slice(Math.max(0, idx - 1), idx + 1);
-          const nextTwo = text.slice(idx, idx + 2);
-          const prevFour = text.slice(Math.max(0, idx - maxLen), idx + maxLen);
-          let excluded = false;
-          for (const bad of exclude) {
-            if (two.includes(bad) || prevTwo === bad || nextTwo === bad || prevFour.includes(bad)) {
-              excluded = true;
-              break;
-            }
-          }
-          if (excluded) { from = idx + word.length; continue; }
-        }
-        // 否定过滤："不害怕"不计入
-        const prevChar = idx > 0 ? text[idx - 1] : "";
-        if (EMOTION_NEGATORS.has(prevChar)) { from = idx + word.length; continue; }
+        // v3.9.1 #5：否定过滤（共享 negatedAt）——"不要害怕/不再担心/丝毫不慌"不计该次
+        if (negatedAt(text, idx)) { from = idx + word.length; continue; }
         // 副词窗口加权：词前 6 字符内出现的强/弱副词生效一次
         const window = text.slice(Math.max(0, idx - 6), idx);
         let weight = 1;
@@ -376,12 +376,15 @@ function emotionOf(text) {
       const emo = dutirLookup.get(w);
       if (!emo) continue;
       // v3.7.0 ⑥：DUTIR 兜底同样做否定过滤（"不害怕"不再计 fear——emotionOf 有过滤，兜底漏了）
-      // v3.7.0 ④：按实际出现次数计（与主词表口径一致——"恶心恶心恶心"计 3 而非 1）；否定只过滤首次位置前一字（接受）
-      const hitAt = text.indexOf(w);
-      if (hitAt > 0 && EMOTION_NEGATORS.has(text[hitAt - 1])) continue;
-      const nOccur = (text.split(w).length - 1);
+      // v3.9.1 #5：逐次 indexOf 循环——每次命中处都做 negatedAt 过滤，按通过次数计 nOcc（不再"只过滤首次+按全文出现次数"）
+      let nOccur = 0;
+      let hitPos = text.indexOf(w);
+      while (hitPos !== -1) {
+        if (!negatedAt(text, hitPos)) nOccur += 1;
+        hitPos = text.indexOf(w, hitPos + w.length);
+      }
       if (nOccur === 0) continue;
-      scores[emo] += nOccur; // v3.7.0 ④：按出现次数（与主词表口径一致）
+      scores[emo] += nOccur; // v3.7.0 ④：按通过过滤的出现次数（与主词表口径一致）
       // v3.7.0 高5：DUTIR 27k 词无强弱分级（呵呵/傻乐等口语弱词）——只进 raw，不进 clean（clean 保持小词表强词口径，"净化后情感"承诺不失效）
       words[emo].push(w);
       seenWords.add(w);
@@ -610,7 +613,7 @@ export function implicitEmotionScan(text, semResolver = null) {
   const ambiguous = [];
   const see = (label, word, n, valence) => {
     if (valence < 0) negHits += n * -valence;
-    else { posHits += n * valence; if (false) fragileHits += n; }
+    else posHits += n * valence; // v3.9.1 #9：移除 if(false) fragileHits 死分支（保留 else 逻辑）
     carrierCounts.set(label + ":" + word, (carrierCounts.get(label + ":" + word) ?? 0) + n);
   };
   // ① 单方向表（原有）——v3.5.0 M2：跳过与多方向表重叠的词（雨/黄昏/烛火等），防同一出现计 2-3 次（语境裁决交给 ②）
@@ -666,6 +669,10 @@ export function implicitEmotionScan(text, semResolver = null) {
     ambiguousRatio: total === 0 ? 0 : Math.round((ambHits / (total + ambHits)) * 100) / 100,
     fragile: fragileHits > 0,
     totalHits: negHits + posHits,
+    // v3.9.1 #11：透出内部实际使用的加权计数（与上面比率计算同源；比率口径不变）
+    negHits,
+    posHits,
+    ambHits,
     ambiguous,
     topCarriers: top
   };
@@ -690,8 +697,11 @@ export function valenceSeries(text, winChars = 100) {
       while (from < slice.length) {
         const idx = slice.indexOf(word, from);
         if (idx === -1) break;
-        sum += val; n += 1;
-        if (val > 0) pos += 1; else if (val < 0) neg += 1;
+        // v3.9.1 #5：对每个情感词命中位置做 negatedAt 过滤——被否定则该次不计词、不进 pos/neg 计数
+        if (!negatedAt(text, start + idx)) {
+          sum += val; n += 1;
+          if (val > 0) pos += 1; else if (val < 0) neg += 1;
+        }
         from = idx + word.length;
       }
     }
@@ -892,12 +902,14 @@ export function analyzeText(text, options = {}) {
   const blocks = splitBlocks(text);
   const sentences = [];
   const blockMeta = [];
+  // v3.9.1 #10：是否因 maxSentences 上限提前 break（前缀采样）——只影响 guidance 尾注，不加顶层字段
+  let truncated = false;
   for (let b = 0; b < blocks.length; b += 1) {
-    if (sentences.length >= maxSentences) break;
+    if (sentences.length >= maxSentences) { truncated = true; break; }
     const parts = splitSentences(blocks[b]);
     const meta = { sentences: [], opening: void 0, closing: void 0 };
     for (const part of parts) {
-      if (sentences.length >= maxSentences) break;
+      if (sentences.length >= maxSentences) { truncated = true; break; }
       const classified = classifySentence(part);
       const record = {
         text: part,
@@ -1152,8 +1164,8 @@ export function analyzeText(text, options = {}) {
       fpSum += parts.length - 1;
       fpText = parts.join("\u0000".repeat(w.length));
     }
-    // 剩余孤立单字"我"
-    fpSum += (fpText.match(/我/g) || []).length;
+    // v3.9.1 #8：剩余孤立单字统计 我/俺/咱 三者（原只补"我"，俺/咱方言第一人称漏计）
+    fpSum += (fpText.match(/[我俺咱]/g) || []).length;
     return fpSum;
   })();
   const firstPersonDensity = totalChars === 0 ? 0 : (firstPersonCount / totalChars) * 1000;
@@ -1192,7 +1204,11 @@ export function analyzeText(text, options = {}) {
   }
 
   const ratios = Object.fromEntries(CATEGORY_ORDER.map((type) => [type, totalSentences === 0 ? 0 : round(counts[type] / totalSentences, 4)]));
-  const guidance = buildGuidance(ratios, motifs, chapterPatterns);
+  let guidance = buildGuidance(ratios, motifs, chapterPatterns);
+  // v3.9.1 #10：因 maxSentences 前缀截断时在 guidance 末尾追加一行提示（不新增顶层字段）
+  if (truncated) {
+    guidance += "\n⚠️ 文本超过采样上限(" + maxSentences + " 句),以上统计基于前缀采样;建议分章分析。";
+  }
 
   const fingerprint = buildFingerprint(categories, lengths, style, emotion, motifs);
   const density = densityOf(text);
@@ -1321,7 +1337,8 @@ const DENSITY_OBJECT_WORDS = /油灯|灯|床|门|窗|桌|椅|凳|杯|碗|碟|盘
 const DENSITY_SENSE = {
   visual: /看|见|映入|光|亮|暗|色|影|闪|照|映|目光|眼神|脸|面|状|样/,
   auditory: /听|声|音|响|钟|脚步|敲|喊|叫|低语|呢喃|咕哝|咚|砰|咔/,
-  tactile: /凉|热|疼|痛|滑|糙|冷|暖|烫|冰|湿|干|硬|软|麻|痒/,
+  // v3.9.1 #12：温度词（冷/热/凉/暖/烫）只归 temperature 通道——从 tactile 剔除，防同一词 sensePer1000 双计
+  tactile: /疼|痛|滑|糙|冰|湿|干|硬|软|麻|痒/,
   olfactory: /香|臭|味|气|腥|甜|苦|酸/,
   temperature: /热|烫|凉|冷|暖|温/
 };

package/lib/client.js

@@ -1,5 +1,5 @@
 /**
- * dsh-novel-writer — 浏览器端（client half, v3.9.0）
+ * dsh-novel-writer — 浏览器端（client half, v3.9.5）
  *
  * 在 Web GUI 侧边栏挂载「句式分析」入口，点击后在会话区打开开关面板：
  *   - 启用句式分析（enabled）：控制 AI 是否可用 novel_sentence_analysis
@@ -181,10 +181,6 @@ var css = `
       "panel.back": "Back",
       "panel.featuresTitle": "功能开关",
       "panel.featuresHint": "情感净化预警：剔除感官/爽感词干扰后提示 AI 复核真实情绪；题材与流派检测：detect 时输出主/副题材与设定流派。",
-      "feature.emotionDeep": "情感深度检测",
-      "feature.emotionDeep.desc": "剔除感官性反应词汇的干扰，呈现作品真实的情感基调",
-      "feature.styleDetect": "风格检测",
-      "feature.styleDetect.desc": "识别世界观背景、题材类型与整体气质（如西幻、克苏鲁、甜宠）",
       "feature.webnovelVibe": "网文信号（风格检测内）",
       "feature.webnovelVibe.desc": "识别网文套路词与题材联动（打脸/秒杀/追妻火葬场），让甜宠/热血也能被识别",
       "feature.emotionCaveat": "情感净化预警（高级）",
@@ -387,10 +383,6 @@ var css = `
       "panel.autoAnalyzeHint": "When on, the AI proactively includes sentence analysis; otherwise only on explicit request.",
       "panel.featuresTitle": "Feature switches",
       "panel.featuresHint": "Emotion caveat: strip physiological/euphoric words and ask the AI to re-check real tone. Genre/theme: output main/secondary theme and setting genre on detect.",
-      "feature.emotionDeep": "Emotion Depth",
-      "feature.emotionDeep.desc": "Filters physiological reaction words to see the true mood",
-      "feature.styleDetect": "Style Detect",
-      "feature.styleDetect.desc": "Detects worldview, theme and vibe (fantasy/cthulhu/romance)",
       "feature.webnovelVibe": "Webnovel signals",
       "feature.webnovelVibe.desc": "Recognizes webnovel trope words (face-slap/one-shot kill)",
       "feature.emotionCaveat": "Emotion caveat (advanced)",
@@ -644,7 +636,6 @@ var css = `
         demoLoading: false,
         reportsGroups: null,
         reportContent: null,
-        reportLoading: false,
         features: {},
         dirs: null,
         view: "main",
@@ -1177,7 +1168,7 @@ var TOOL_GROUPS = [
           fetch("/api/dsh-novel-writer/reports?read=" + encodeURIComponent(file), { headers: { accept: "application/json" } }).then(function (r2) { if (!r2.ok) throw new Error("HTTP " + r2.status); return r2.json(); }).then(function (d) {
             if (reqId !== reportReqId) return; // v3.5.0 #47：快速切换时丢弃过期响应
             props.controller.set({ reportContent: d.ok ? JSON.stringify(d.content, null, 2) : (t("reports.readFail") + "：" + (d.error || "")) });
-          }).catch(function () { props.controller.set({ reportContent: t("reports.readFailDetail") }); });
+          }).catch(function () { if (reqId !== reportReqId) return; props.controller.set({ reportContent: t("reports.readFailDetail") }); });
         };
         var groups = state.reportsGroups || [];
         var totalFiles = groups.reduce(function (a, g) { return a + (g.files || []).length; }, 0);
@@ -1448,10 +1439,10 @@ var TOOL_GROUPS = [
           ),
           // v3.2.0：报告历史入口
           el("button", { key: "reportsEntry", type: "button", style: { display: "flex", alignItems: "center", width: "100%", marginTop: "8px", padding: "9px 12px", borderRadius: "10px", border: "1px solid #e2e8f0", background: "#fff", cursor: "pointer", textAlign: "left" }, onClick: function () {
-            props.controller.set({ reportsGroups: null, reportContent: null, reportLoading: true });
+            props.controller.set({ reportsGroups: null, reportContent: null });
             fetch("/api/dsh-novel-writer/reports", { headers: { accept: "application/json" } }).then(function (r2) { if (!r2.ok) throw new Error("HTTP " + r2.status); return r2.json(); }).then(function (d) {
-              props.controller.set({ reportsGroups: d.groups || [], reportLoading: false });
-            }).catch(function () { props.controller.set({ reportsGroups: [], reportLoading: false }); });
+              props.controller.set({ reportsGroups: d.groups || [] });
+            }).catch(function () { props.controller.set({ reportsGroups: [] }); });
             props.controller.openView("reports");
           } },
             el("span", { style: { flex: "1", fontSize: "13px", fontWeight: "600", color: "#334155" } }, "📊 " + t("reports.title")),
@@ -1596,6 +1587,10 @@ var TOOL_GROUPS = [
         if (container !== void 0 && container.isConnected === true) return;
         var column = conversationColumn();
         if (column === void 0) return;
+        // v3.9.5 修正：宿主重建会话列导致容器脱离 DOM 时，先卸载旧 React root 并移除旧容器，
+        // 避免 PanelView 的订阅闭包累积（旧 root 永不 unmount = 监听泄漏）
+        if (root !== void 0) { try { root.unmount(); } catch (error) { /* ignore */ } root = void 0; }
+        if (container !== void 0) { try { container.remove(); } catch (error) { /* ignore */ } container = void 0; }
         container = document.createElement("div");
         container.dataset.dshNovelWriterView = "";
         container.style.display = "none";
@@ -1640,6 +1635,8 @@ var TOOL_GROUPS = [
     var inject = ["slots", "locale"];
     var applied = false;
     function apply(ctx) {
+      // 注（v3.9.5）：applied 防重入依赖宿主 module materialize 语义——若宿主在同一模块实例上 disable→enable/HMR，
+      // 第二次 apply 会被静默跳过且旧 UI 已卸载；如遇此场景需宿主重新加载模块实例
       if (applied) return;
       applied = true;
       var controller = createController();
@@ -1650,26 +1647,31 @@ var TOOL_GROUPS = [
           .then(function (uc) { if (uc) controller.set({ updateCheck: uc }); })
           .catch(function () { /* 静默 */ });
         try {
+          var revAt = controller.getSnapshot().rev;
           var remote = await fetchState();
+          // v3.9.5 修正：初次加载接入 rev 竞态守卫——慢 GET 到达时若用户已操作（rev 变化），
+          // 不得用旧快照覆盖 enabled/autoAnalyze/tools/features/容差/设定等开关字段
+          var revSame = controller.getSnapshot().rev === revAt;
+          var snap = controller.getSnapshot();
           controller.set({
-            enabled: !!remote.enabled,
-            autoAnalyze: !!remote.autoAnalyze,
-            tools: remote.tools || {},
-            features: remote.features || {},
+            enabled: revSame ? !!remote.enabled : snap.enabled,
+            autoAnalyze: revSame ? !!remote.autoAnalyze : snap.autoAnalyze,
+            tools: revSame ? (remote.tools || {}) : (snap.tools || {}),
+            features: revSame ? (remote.features || {}) : (snap.features || {}),
             plotsDir: remote.plotsDir || "",
             dataDir: remote.dataDir || "",
             // v2.6.0：初始加载同样接入数据目录占用 + 语义引擎状态（与 refresh 白名单一致）
             dataDirSize: remote.dataDirSize || 0,
             embeddingStatus: remote.embeddingStatus || null,
-            styleTolerance: remote.styleTolerance || null,
-            creationProfile: remote.creationProfile || null,
-            creationProfiles: remote.creationProfiles || {},
+            styleTolerance: revSame ? (remote.styleTolerance || null) : (snap.styleTolerance || null),
+            creationProfile: revSame ? (remote.creationProfile || null) : (snap.creationProfile || null),
+            creationProfiles: revSame ? (remote.creationProfiles || {}) : (snap.creationProfiles || {}),
             books: remote.books || [],
             booksStats: typeof remote.booksStats === "undefined" ? null : (remote.booksStats || []),
             dirs: remote.dirs || null,
             file: remote.file || "",
             saveFailed: false, // v3.7.0 ③：刷新成功清除错误横幅
-              source: "host",
+            source: "host",
             hostOk: true,
             loading: false
           });
@@ -1716,11 +1718,21 @@ var TOOL_GROUPS = [
         }
         controller.set(merged);
         try {
+          var revAt2 = controller.getSnapshot().rev;
           var remote = await saveState(patch);
+          var revSame2 = controller.getSnapshot().rev === revAt2;
+          var snap2 = controller.getSnapshot();
           controller.set({
             enabled: !!remote.enabled,
             autoAnalyze: !!remote.autoAnalyze,
-            file: remote.file || controller.getSnapshot().file,
+            // v3.9.5 修正：保存成功后回读宿主完整 next（tools/features/容差/设定），
+            // 前提是期间没有更新的用户操作（rev 未变）——避免服务端钳制/规范化与 UI 长期不一致
+            tools: revSame2 && remote.tools ? remote.tools : (snap2.tools || {}),
+            features: revSame2 && remote.features ? remote.features : (snap2.features || {}),
+            styleTolerance: revSame2 && remote.styleTolerance ? remote.styleTolerance : (snap2.styleTolerance || null),
+            creationProfile: revSame2 && remote.creationProfile ? remote.creationProfile : (snap2.creationProfile || null),
+            creationProfiles: revSame2 && remote.creationProfiles ? remote.creationProfiles : (snap2.creationProfiles || {}),
+            file: remote.file || snap2.file,
             source: "host",
             hostOk: true
           });
@@ -1746,6 +1758,8 @@ var openPanel = function () {
         console.warn("[dsh-novel-writer] UI mount failed:", error);
       }
       // 官方设置页「插件配置」卡片（v0.4.0 合并；slots 服务由 inject 声明）
+      // 注（v3.9.5）：settings.plugin.item 是 keyed slot——宿主需在其 settingsScope served 集合中登记
+      // novel-writer-config 命名空间该卡片才会被渲染；若宿主未实现则此卡片为“仅侧边栏入口”模式，属预期行为
       try {
         ctx.slots.inject("settings.plugin.item", function () {
           return ctx.slots.register({

package/lib/embedding.js

@@ -12,7 +12,8 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-// v2.6.0 审查修复：Node <22.3 无 zstd——条件获取，不可用时索引缓存回退纯 JSON（插件照常加载，不崩）
+// v2.6.0 审查修复：zstd 条件获取，不可用时索引缓存回退纯 JSON（插件照常加载，不崩）
+// v3.9.1 注释修正：Node 实际在 v23.8.0 才引入 zlib 的 zstd（并非 22.3）；22.3–23.7 及更旧版本自动回退纯 JSON 是安全设计
 let zstdCompressSync = null;
 let zstdDecompressSync = null;
 try {
@@ -24,11 +25,11 @@ try {
 } catch { /* 旧 Node：回退纯 JSON 缓存 */ }
 const MODEL_DIR = path.join(__dirname, "models");
 const MODEL_NAME = "bge-small-zh-v1.5"; // v3.5.0 #55：索引缓存模型标识（换模型旧缓存作废）
-const EMBED_DIM = 128; // v3.5.0 #55：缓存向量维度（降采样后）
+const EMBED_DIM = 128; // v3.5.0 #55：缓存向量维度（降采样后）；v3.9.1：512→128 是每 4 取 1 的有损降采样，无信息量保持保证——只作维度压缩/缓存瘦身，别当作无损语义保持
 const EMBEDDING_CACHE_ROOT = ".novel-writer";
 
 let enginePromise = null;
-let engine = { available: false, error: null, tokenizer: null, session: null, ort: null, wasmPaths: null };
+let engine = { available: false, error: null, tokenizer: null, session: null, ort: null, wasmPaths: null, failedAt: null };
 
 /** 模型文件是否随包存在（纯文件探测）。 */
 function modelPresent() {
@@ -62,9 +63,12 @@ function initEngine() {
       engine.ort = ort;
       engine.available = true;
       engine.error = null;
+      engine.failedAt = null;
     } catch (e) {
       engine.available = false;
       engine.error = String(e).slice(0, 300);
+      // v3.9.1：失败粘性修复——记录失败时刻，isAvailable() 冷却 30s 后自动重试
+      engine.failedAt = Date.now();
     }
     return engine;
   })();
@@ -76,9 +80,14 @@ function status() {
   return { modelPresent: modelPresent(), loaded: engine.available, error: engine.error };
 }
 
-/** 可用性（懒加载后返回；失败不抛）。 */
+/** 可用性（懒加载后返回；失败不抛）。失败不是永久态：冷却 30s 后允许一次重载尝试。 */
 async function isAvailable() {
   if (!modelPresent()) return false;
+  // v3.9.1 失败粘性修复：initEngine 缓存了失败的 enginePromise——超过 30s 冷却即作废重试（仍失败则 failedAt 刷新，再等 30s）
+  if (!engine.available && engine.failedAt && Date.now() - engine.failedAt > 30 * 1000) {
+    enginePromise = null;
+    engine.failedAt = null;
+  }
   await initEngine();
   return engine.available;
 }
@@ -108,9 +117,10 @@ async function embed(text) {
   return cls.map((x) => x / norm);
 }
 
-/** 批量嵌入（并发 4）。 */
+/** 批量嵌入（并发 4；失败块整体重试一轮，偶发 WASM 抖动不落永久缺失）。 */
 async function embedMany(chunks) {
   const out = new Array(chunks.length);
+  const failed = [];
   let cursor = 0;
   const worker = async () => {
     while (cursor < chunks.length) {
@@ -118,11 +128,34 @@ async function embedMany(chunks) {
       // v3.5.0 #53：单块容错——一块 embed 抛错（WASM 抖动/超长）不拖垮整本书索引
       try {
         const vec = await embed(chunks[i].text);
-        out[i] = vec ? { id: chunks[i].id, text: chunks[i].text, vec } : null;
-      } catch { out[i] = null; }
+        if (vec) {
+          out[i] = { id: chunks[i].id, text: chunks[i].text, vec };
+        } else {
+          out[i] = null;
+          failed.push(i);
+        }
+      } catch {
+        out[i] = null;
+        failed.push(i);
+      }
     }
   };
   await Promise.all(Array.from({ length: 4 }, worker));
+  // v3.9.1：第一轮失败（抛错或返回 null）的块，第二轮再 embed 一次；仍失败才保留 null 由 filter 剔除
+  const retry = failed.slice();
+  if (retry.length > 0) {
+    let rc = 0;
+    const retryWorker = async () => {
+      while (rc < retry.length) {
+        const i = retry[rc]; rc += 1;
+        try {
+          const vec = await embed(chunks[i].text);
+          out[i] = vec ? { id: chunks[i].id, text: chunks[i].text, vec } : null;
+        } catch { out[i] = null; }
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(4, retry.length) }, retryWorker));
+  }
   return out.filter(Boolean);
 }
 
@@ -135,14 +168,14 @@ function cosine(a, b) {
   return dot / (Math.sqrt(na) * Math.sqrt(nb));
 }
 
-/** 语义检索（query 维度跟随索引：首次直出 512 维 / 缓存命中 128 维）。 */
+/** 语义检索（query 维度跟随索引；v3.9.1：落库索引已统一 128 维，仅对内存中可能出现的 512 维索引做防御性兼容）。 */
 async function search(query, index, k = 5) {
   const qv = await embed(query);
   if (!qv || !index || index.length === 0) return [];
-  // v2.5.0 修复轮 5：首次 built 的索引为 512 维（embedMany 直出），缓存命中为 128 维（saveIndex 降采样）——
-  // query 必须与 index 同维度，否则 cosine(128,512) 长度不等恒返回 0（首次检索全 0 分、排序无意义）
+  // v3.9.1 注释修正：原「首次 built 的索引为 512 维」描述已过期——saveIndex/buildIndexIncremental 现在统一 128 维落库；
+  // 此处保留 512/128 双维防御（cosine 要求等长，否则恒返回 0），query 为 512 维模型直出时与 128 维索引匹配需降采样
   const dim = index[0]?.vec?.length ?? 0;
-  const qvCache = dim === qv.length ? qv : qv.filter((_, i) => i % 4 === 0);
+  const qvCache = dim === qv.length ? qv : downsample(qv);
   return index
     .map((item) => ({ ...item, score: cosine(qvCache, item.vec) }))
     .sort((x, y) => y.score - x.score)
@@ -251,6 +284,19 @@ function textHash(text) {
   return createHash("sha1").update(String(text)).digest("hex").slice(0, 16);
 }
 
+/**
+ * v3.9.1 共享降采样：512 维模型直出 → 128 维（每 4 维取 1），随后做一次 L2 归一化。
+ * 降采样只压缩维度、不保证保留完整语义信息（有损）；对已是 128 维的旧缓存/复用向量只做归一化，不二次降采样。
+ * 注意：不应把 128 维缓存视为损坏——旧缓存 128 维合法。
+ */
+function downsample(vec) {
+  const raw = Array.isArray(vec) ? vec : [];
+  const v = raw.length > 128 ? raw.filter((_, i) => i % 4 === 0) : raw;
+  let norm = Math.sqrt(v.reduce((sum, x) => sum + x * x, 0));
+  if (!norm || !Number.isFinite(norm)) norm = 1;
+  return v.map((x) => x / norm);
+}
+
 /** 读取索引缓存文件（v2.6.0：zstd 压缩存储；旧版纯 JSON 自动兼容）。 */
 function readIndexData(root, book) {
   const p = cachePath(root, book);
@@ -262,16 +308,16 @@ function readIndexData(root, book) {
   try { return JSON.parse(buf.toString("utf8")); } catch { return null; }
 }
 
-/** 保存索引（v2.6.0：统一 128 维 + 4 位小数降精度 + zstd 压缩，体积约 1/10；fp=内容指纹）。 */
+/** 保存索引（v2.6.0：统一 128 维 + 4 位小数降精度 + zstd 压缩，体积约 1/10；fp=内容指纹）。v3.9.1：正文截断上限 200 字（与检索返回一致）。 */
 function saveIndex(root, book, index, fp = "") {
   try {
     const dir = path.dirname(cachePath(root, book));
     fs.mkdirSync(dir, { recursive: true });
     const compact = index.map((item) => {
-      const vec = item.vec.length > 128 ? item.vec.filter((_, i) => i % 4 === 0) : item.vec;
+      const vec = downsample(item.vec);
       return {
         id: item.id,
-        t: item.text.slice(0, 120),
+        t: item.text.slice(0, 200),
         th: item.th ?? textHash(item.text),
         ch: item.chapter ?? null,
         v: vec.map((x) => Math.round(x * 10000) / 10000)
@@ -284,24 +330,32 @@ function saveIndex(root, book, index, fp = "") {
   } catch { return false; }
 }
 
-/** 读取索引缓存（不存在返回 null）。 */
+/** 读取索引缓存（不存在返回 null）。v3.9.1：逐向量长度校验——任一 vec 维度与 EMBED_DIM 不符即视为缓存损坏（旧 128 维缓存合法，不被误杀）。 */
 function loadIndex(root, book) {
   try {
     const data = readIndexData(root, book);
     if (!data) return null;
     // v3.5.0 #55：与 loadIndexMeta 一致——model/dim 不符视为无缓存
     if (data.model !== MODEL_NAME || data.dim !== EMBED_DIM) return null;
+    if (!Array.isArray(data.items)) return null;
+    for (const item of data.items) {
+      if (!Array.isArray(item?.v) || item.v.length !== EMBED_DIM) return null;
+    }
     return data.items.map((item) => ({ id: item.id, text: item.t, vec: item.v, chapter: item.ch ?? null }));
   } catch { return null; }
 }
 
-/** 读取索引缓存 + 内容指纹（旧格式无 fp 时 fp=null，视为失效需重建；不靠版本号失效）。 */
+/** 读取索引缓存 + 内容指纹（旧格式无 fp 时 fp=null，视为失效需重建；不靠版本号失效）。v3.9.1：同 loadIndex 的逐向量长度校验。 */
 function loadIndexMeta(root, book) {
   try {
     const data = readIndexData(root, book);
     if (!data) return { items: null, fp: null };
     // v3.5.0 #55：缓存校验 model/dim——换模型/维度变化时旧缓存作废（触发重建），防 cosine 恒 0
     if (data.model !== MODEL_NAME || data.dim !== EMBED_DIM) return { items: null, fp: null };
+    if (!Array.isArray(data.items)) return { items: null, fp: null };
+    for (const item of data.items) {
+      if (!Array.isArray(item?.v) || item.v.length !== EMBED_DIM) return { items: null, fp: null };
+    }
     return {
       items: data.items.map((item) => ({ id: item.id, text: item.t, th: item.th ?? null, vec: item.v, chapter: item.ch ?? null })),
       fp: data.fp ?? null
@@ -340,7 +394,7 @@ async function buildIndexIncremental(chunks, oldItems) {
           id: chunks[i].id,
           text: chunks[i].text,
           th: textHash(chunks[i].text),
-          vec: v.vec.length > 128 ? v.vec.filter((_, j) => j % 4 === 0) : v.vec,
+          vec: downsample(v.vec),
           chapter: chunks[i].chapter ?? null
         };
       }
@@ -407,6 +461,6 @@ function chunkText(text) {
 }
 
 /** 显式释放（仅重置单例，WASM 内存由 GC 回收）。 */
-function reset() { enginePromise = null; engine = { available: false, error: null, tokenizer: null, session: null, ort: null, wasmPaths: null }; }
+function reset() { enginePromise = null; engine = { available: false, error: null, tokenizer: null, session: null, ort: null, wasmPaths: null, failedAt: null }; }
 
 export { status, isAvailable, embed, embedMany, cosine, search, saveIndex, loadIndex, loadIndexMeta, fingerprint, textHash, buildIndexIncremental, chunkText, reset, detectImplicitEmotions, IMPLICIT_EMOTION_PROTOTYPES, MODEL_DIR, cachePath, engine };