dsh-novel-writer 0.5.0 → 0.6.0

package/INSTALL.md

@@ -1,39 +1,36 @@
-# dsh-novel-writer v0.5.0 — 安装指南（v0.3.0 × v0.4.0 合并版）
+# dsh-novel-writer v0.6.0 — 安装指南
 
-宿主端零第三方依赖；浏览器端依赖 Web GUI 自带的 react。
-本包 UI：侧边栏「句式分析」大开关面板（统一开关位置）；设置 > 插件配置 卡片仅显示状态 + 跳转按钮。
+基于 v0.5.0 合并版的工程化升级。新增：分析缓存/报告导出、风格自检、伏笔登记表、关键词三字组与疑似人名、情感词典去噪、局域网开关可选放行。
 
 ```
-dsh-novel-writer-v0.5.0/
+dsh-novel-writer-v0.6.0/
 ├── lib/
-│   ├── index.js        # 宿主端（8 个 novel_* 工具 + state 路由）
-│   ├── analysis.js     # 句式模式分析引擎（九类/情感/节奏，零依赖）
-│   └── client.js       # 浏览器端（侧边栏面板 + 设置页卡片）
-├── test/               # 引擎与 client 契约测试
-├── package.json
-├── cordis.patch.yml
-├── README.md
-├── INSTALL.md
+│   ├── index.js        # 宿主端（10 个工具 + state 路由 + 缓存）
+│   ├── analysis.js     # 句式模式分析引擎（含 fingerprintSimilarity / styleDiffs）
+│   └── client.js       # 浏览器端（侧边栏面板 + 设置页状态卡片）
+├── test/               # 引擎 + client + e2e 测试
+├── package.json / cordis.patch.yml / README.md / INSTALL.md
 └── skills/novel-writing/SKILL.md
 ```
 
 ## 安装
 
-1. 把本文件夹放入 profile 的 node_modules（或 `dsh plugin --profile web add <路径>`）；
+1. 放入 profile 的 node_modules（或 `dsh plugin --profile web add <路径>`）；
 2. profile `package.json` 的 `dsh.profile.bundles` 加入 `dsh-novel-writer`；
-3. （可选）把 `skills/novel-writing` 复制到工作区 `.dsh/skills/`；
-4. **重启 web 应用**。
+3. （可选）复制 `skills/novel-writing` 到工作区 `.dsh/skills/`；
+4. 重启 web 应用。
 
 ## 验证
 
-- 工具列表出现：novel_books / novel_chapters / novel_read / novel_keywords / novel_new_chapter /
-  novel_import / novel_sentence_analysis / novel_sentence_config；
-- 侧边栏出现「句式分析」入口；设置 > 插件配置 出现 novel-writer 状态卡片；
-- `GET /api/dsh-novel-writer/state` 返回 200 JSON。
+- 工具列表出现 10 个 novel_* 工具（含 novel_style_check / novel_plot）；
+- `novel_sentence_analysis` 返回含 `reportFile` / `cache` 字段；
+- 缓存目录 `~/.dsh/dsh-novel-writer/cache/` 出现报告 JSON；
+- 伏笔表文件 `<root>/.novel-writer/<书名>.json`。
 
-## 开关
+## 数据位置
 
-- 默认开启；**唯一开关位置：侧边栏「句式分析」面板**（总开关 enabled + 子开关 autoAnalyze）；
-- 设置 > 插件配置 卡片仅显示状态并提供「打开开关面板」跳转；
-- 持久化 `~/.dsh/dsh-novel-writer/state.json`；兼容读取 `~/.dsh/novel-writer.json`（v0.4.0 stylePattern）；
-- config 支持 `sentenceAnalysis.enabled / autoAnalyze` 与 `stylePattern`（v0.4.0 兼容）。
+| 数据 | 路径 |
+|---|---|
+| 开关状态 | `~/.dsh/dsh-novel-writer/state.json` |
+| 分析报告缓存 | `~/.dsh/dsh-novel-writer/cache/<书>-<hash>.json` |
+| 伏笔登记表 | `<书库根>/.novel-writer/<书>.json` |

package/README.md

@@ -1,56 +1,52 @@
-# dsh-novel-writer — 小说写作助手插件（v0.5.0 合并版）
+# dsh-novel-writer — 小说写作助手插件（v0.6.0 工程化版）
 
 DSH（DeepSeek Harness）小说写作助手 bundle 插件。宿主端零第三方依赖（仅 Node 内置模块），
 浏览器端仅依赖 Web GUI 自带的 react。
-**v0.5.0 = v0.3.0（深度句式分析 + 侧边栏开关）与 v0.4.0（批量导入 + 设置页卡片）的合并版**。
+**v0.6.0 在 v0.5.0（合并版）基础上完成工程化升级**：分析缓存与报告导出、风格自检、伏笔登记表、
+关键词三字组/疑似人名、情感词典去噪、祈使句与环境分类改进、局域网开关可选放行。
 
-## 功能
-
-1. **章节库**：章节存于 `novels/<书名>/第N章.md`（或 `.txt`/`.markdown`），
-   `novel_books` / `novel_chapters` / `novel_read` 浏览与读取。
-   章号任意位置 + 中文数字识别；UTF-8 / UTF-16 LE/BE / GBK 编码自动探测。
-2. **分析**：`novel_keywords` 提取全书/单章高频关键词（中文二字词组 + 英文词）。
-3. **句式模式分析**：`novel_sentence_analysis` 对全书/单章输出——
-   - 九类句式：陈述 / 环境 / 心理 / 对话 / 疑问 / 反问 / 感叹 / 祈使 / 省略留白（比例、句数、均长、例句）；
-   - 排列规律：句式转移、2/3 连句高频模板、段首/段尾句式、**按章节的压缩节奏序列**（S×8 ENV×2 PSY×3…）；
-   - 句长节奏：均值/中位数、短句/长句占比；
-   - 主观情感：情感词典（喜/怒/哀/惧/惊）+ 强度副词加权 → 主导情绪、情绪分布、情感曲线、主观性指数；
-   - 风格指纹 + 给模型的**节奏建议**（guidance）。
-   ⚠️ 风险约束：句式模式是"参考节奏"而非"模板套用"，模型在机械复刻导致僵硬时会优先回归自然表达。
-4. **原稿件批量导入**：`novel_import` 扫描存放多本小说的文件夹（支持子文件夹、多编码、任意位置章号），
-   从文件名与文件头双通道提取书名候选并分组（scan 预览），AI 确认后一键复制/移动到 `novels/<书名>/`（apply）；
-   支持 `book` 强制归并异名同书、`files` 精确指定、`move` 移动模式。
-5. **续写**：先读后写、保持文风与伏笔一致，`novel_new_chapter` 创建新章节文件。
-
-## 提供的工具
+## 工具清单（10 个）
 
 | 工具 | 说明 |
 |---|---|
 | `novel_books` | 列出章节库全部作品 |
 | `novel_chapters` | 列出某作品章节清单 |
-| `novel_read` | 阅读某章正文（offset/limit 分段） |
-| `novel_keywords` | 提取高频关键词 |
+| `novel_read` | 阅读某章正文（offset/limit 分段，编码自动探测） |
+| `novel_keywords` | 关键词：二字组 + **三字组** + **疑似人名** + 英文词 |
 | `novel_new_chapter` | 创建新章节文件 |
-| `novel_import` | **原稿件批量导入/自动分类（v0.4.0）** |
-| `novel_sentence_analysis` | **句式模式分析（v0.3.0 深度 + v0.4.0 节奏）** |
+| `novel_import` | 原稿件批量导入/自动分类（含**异名同书提示**） |
+| `novel_sentence_analysis` | 句式模式分析（九类/情感曲线/章节节奏/指纹，**带缓存与报告文件**） |
 | `novel_sentence_config` | 查看/修改句式分析开关 |
+| `novel_style_check` | **风格自检（v0.6.0 新增）**：章节 vs 全书指纹对比 + 偏差清单 |
+| `novel_plot` | **伏笔/剧情线登记表（v0.6.0 新增）**：list/add/update/done/delete |
+
+## v0.6.0 新增能力
 
-## UI 开关（统一在一处）
+1. **分析缓存 + 报告导出**：novel_sentence_analysis 结果自动缓存到 `~/.dsh/dsh-novel-writer/cache/<书名>-<hash>.json`，
+   返回值带 `reportFile` / `cache`（hit/miss）字段；章节未改动时重复分析秒回，传 `fresh=true` 强制重算。
+2. **风格自检 novel_style_check**：任意章节 vs 全书其余章节 → 余弦相似度 + 句式/句长/情绪偏差清单 + 续写建议（写完新章自动查一次，防止文风漂移）。
+3. **伏笔登记表 novel_plot**：`novels 根目录/.novel-writer/<书名>.json` 持久化；续写前 list 查看未回收伏笔。
+4. **关键词升级**：新增三字组与疑似人名（"XX说/道/问"与"XX小姐/导师"模式），人名不再被拆成"露西+西亚"。
+5. **情感词典去噪**：单字词搭配排除（"叹气"不算"气"、"笑道"不算"笑"）、否定过滤（"不害怕"不计）、副词距离窗口化（"非常开心"才加权）。
+6. **分类改进**：祈使句支持"快睡吧，明天还要上班"式（命令动词开头+吧）；环境词表扩充（晚风/晨曦/森林/群山…）。
+7. **情感曲线粒度可调**：`curveSegments` 参数（1-50，默认 20）。
+8. **novel_import 异名同书提示**：scan 结果中组名包含/高重合时列出 `maybe` 字段，提示用 `book` 合并。
+9. **局域网开关可选放行**：config `allowLanState: true` 时，state 路由对同源局域网请求放行（默认仍仅 loopback）。
 
-- **唯一开关位置：侧边栏「句式分析」面板**——状态横幅 + **总开关「启用句式分析」**（enabled）+ 子开关「分析作品时自动使用」（autoAnalyze）；
-- **设置 > 插件配置** 的 novel-writer 卡片仅**显示状态**（已启用/已关闭、自动分析开/关），并提供「打开开关面板」按钮跳转；
-- 也可让 AI 用 `novel_sentence_config` 查看/修改。
-- 状态写入 `~/.dsh/dsh-novel-writer/state.json`；同时**只读兼容** v0.4.0 的 `~/.dsh/novel-writer.json`（stylePattern）与 config.stylePattern。
-- 开关默认**开启**；宿主端路由 `/api/dsh-novel-writer/state`（loopback 围栏 + 可选注入，headless 自动跳过）。
+## UI 开关（与 v0.5.0 相同，统一在一处）
 
-## 安装（web profile）
+- 唯一开关位置：侧边栏「句式分析」面板（总开关 enabled + 子开关 autoAnalyze）；
+- 设置 > 插件配置 卡片仅显示状态 + 「打开开关面板」跳转；
+- 持久化 `~/.dsh/dsh-novel-writer/state.json`；兼容 v0.4.0 的 novel-writer.json / config.stylePattern；
+- 默认开启；路由 `/api/dsh-novel-writer/state`（loopback 围栏，可选局域网放行）。
+
+## 安装
 
 ```sh
 dsh plugin --profile web add D:/tools/dsh-novel-writer
 ```
 
-或手动：把本文件夹放入 profile 的 `node_modules`，并在 profile `package.json` 的
-`dsh.profile.bundles` 中加入 `dsh-novel-writer`。安装后**重启 web 应用**生效。
+或手动：放入 profile 的 node_modules + `dsh.profile.bundles` 加 `dsh-novel-writer`；重启 web 应用。
 
 ## 配置
 
@@ -61,23 +57,5 @@ dsh plugin --profile web add D:/tools/dsh-novel-writer
     sentenceAnalysis:
       enabled: true
       autoAnalyze: true
-    # stylePattern: true   # v0.4.0 兼容写法（任一生效即开启）
+    allowLanState: false   # true=局域网访问 GUI 时也允许保存开关
 ```
-
-## 版本记录
-
-### v0.5.0（合并版）
-- 合并 v0.3.0 与 v0.4.0：九类句式（新增"环境"）、章节压缩节奏序列、guidance 节奏建议、采样上限；
-- 新增 novel_import 批量导入（v0.4.0）；开关同时出现在侧边栏面板与官方设置页；
-- 路由改可选注入 ctx.inject(["webServer"])，headless 兼容；保留 loopback 围栏；
-- 兼容读取 v0.4.0 的 novel-writer.json / config.stylePattern；提示词内置"僵硬时优先自然表达"约束。
-
-### v0.4.0（他人改版，已并入）
-- novel_import 批量导入自动分类；novel_style_pattern 轻量句式分析（环境类/压缩序列/guidance）；
-- 官方设置页插件配置卡片；ctx.inject 可选注入；开关默认关闭 + 风险提示。
-
-### v0.3.0（本系列）
-- 句式模式分析深度版（情感曲线/句长/段落/指纹）；侧边栏开关面板；state 路由。
-
-### v0.2.0 / v0.1.0
-- 章节库、关键词、新建章节；编码探测。

package/lib/analysis.js

@@ -22,7 +22,8 @@ export const CATEGORY_LABELS = Object.freeze({
   exclamation: "感叹",
   imperative: "祈使",
   ellipsis: "省略留白"
-});
+}
+);
 
 /** 输出固定顺序。 */
 export const CATEGORY_ORDER = Object.freeze([
@@ -85,8 +86,8 @@ const QUESTION_WORDS = ["谁", "什么", "为什么", "怎么", "怎样", "如
 const IMPERATIVE_HARD = ["请", "快", "赶紧", "立刻", "马上", "别", "不要", "莫", "勿", "不许", "不准", "滚", "住手", "放手", "站住", "听我说", "给我", "让", "快点儿", "快点"];
 const IMPERATIVE_START = ["走", "来", "去", "坐", "站", "停", "开始", "出发", "算了吧", "算了", "吃", "喝", "看", "听", "说", "做", "干", "起来", "坐下", "住口"];
 
-/** 环境描写标记词（天色/天气/景物类名词，来自 v0.4.0）。 */
-const ENV_MARKERS = /夜色|月光|晨光|暮色|夕阳|黄昏|清晨|深夜|夜空|天边|星光|灯火|细雨|微风|大雨|暴雨|风雪|薄雾|浓雾|云层|远山|山影|河面|湖水|街道|巷子|烛火|窗|雨声|风声|树影|落叶|残雪|霜|天色/;
+/** 环境描写标记词（天色/天气/景物类名词，来自 v0.4.0，v0.6.0 扩充）。 */
+const ENV_MARKERS = /夜色|月光|晨光|暮色|夕阳|黄昏|清晨|深夜|夜空|天边|星光|灯火|细雨|微风|大雨|暴雨|风雪|薄雾|浓雾|云层|远山|山影|河面|湖水|街道|巷子|烛火|窗|雨声|风声|树影|落叶|残雪|霜|天色|晚风|夜风|晨曦|晚霞|晴空|雨滴|溪水|江水|海浪|沙漠|草原|森林|群山|雪地|庭院|檐下|廊下/;
 
 /** 句尾结束符。 */
 const TERMINATORS = "。！？…";
@@ -98,7 +99,8 @@ const QUOTE_PAIRS = [["“", "”"], ["「", "」"], ["『", "』"], ["‘", "
 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) => line.trim() === "");
+  // 段落分隔符 = 前后都有内容的"中间空行"；仅开头/结尾的空行不算分段。
+  const hasBlank = lines.some((line, index) => line.trim() === "" && index > 0 && index < lines.length - 1);
   const blocks = [];
   let current = [];
   for (const line of lines) {
@@ -206,11 +208,11 @@ function isExclamation(text) {
 }
 
 function isImperative(text) {
-  if (!/(吧[。！？]?|！)$/.test(text)) return false;
+  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);
+  return new RegExp("^(你|您|我们|咱们|大家)?(" + IMPERATIVE_START.join("|") + ")").test(text) && /吧/.test(text);
 }
 
 /**
@@ -236,22 +238,63 @@ export function classifySentence(raw) {
   return { type: "statement", text, quoted: false };
 }
 
-/** 情感词计数（含强度副词加权）。 */
+/** 单字情感词的多字搭配排除（"叹气"不算"气"、"笑道"不算"笑"）。 */
+const EMOTION_EXCLUDE = {
+  joy: { "笑": ["笑道", "说笑", "玩笑", "搞笑", "笑话", "苦笑", "冷笑", "嘲笑", "嬉笑", "傻笑", "微笑", "笑死", "笑呵呵", "笑眯眯"] },
+  anger: { "气": ["叹气", "运气", "客气", "一口气", "服气", "脾气", "争气", "节气", "淘气", "景气", "暖气", "口气", "名气", "勇气", "底气", "俗气", "风气", "香气", "水气", "湿气", "潮气", "和气", "生气勃勃"] },
+  sorrow: { "悲": ["慈悲"], "哭": ["哭丧"] },
+  fear: { "怕": ["哪怕", "只怕", "生怕"] },
+  surprise: { "愣": ["愣住"] }
+};
+
+/** 情感词前紧邻的否定字（"不害怕"不计入恐惧）。 */
+const EMOTION_NEGATORS = new Set(["不", "没", "无", "别", "莫", "未"]);
+
+/** 情感词计数（v0.6.0：扫描式匹配 + 搭配排除 + 否定过滤 + 副词窗口加权）。 */
 function emotionOf(text) {
   const scores = { joy: 0, anger: 0, sorrow: 0, fear: 0, surprise: 0 };
   const words = { joy: [], anger: [], sorrow: [], fear: [], surprise: [] };
-  let weight = 1;
-  for (const adverb of STRONG_ADVERBS) {
-    if (text.includes(adverb)) { weight = Math.max(weight, 1.5); break; }
-  }
-  for (const adverb of MILD_ADVERBS) {
-    if (text.includes(adverb)) { weight = Math.min(weight, 0.6); break; }
-  }
+  const hitWords = new Set();
   for (const [emotion, list] of Object.entries(EMOTION_WORDS)) {
     for (const word of list) {
-      if (text.includes(word)) {
+      let from = 0;
+      while (from < text.length) {
+        const idx = text.indexOf(word, from);
+        if (idx === -1) break;
+        // 单字词的搭配排除（如"叹气"中的"气"）
+        const exclude = EMOTION_EXCLUDE[emotion]?.[word];
+        if (exclude !== void 0) {
+          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 - 2), idx + 2);
+          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; }
+        // 副词窗口加权：词前 6 字符内出现的强/弱副词生效一次
+        const window = text.slice(Math.max(0, idx - 6), idx);
+        let weight = 1;
+        for (const adverb of STRONG_ADVERBS) {
+          if (window.includes(adverb)) { weight = Math.max(weight, 1.5); break; }
+        }
+        for (const adverb of MILD_ADVERBS) {
+          if (window.includes(adverb)) { weight = Math.min(weight, 0.6); break; }
+        }
         scores[emotion] += weight;
-        words[emotion].push(word);
+        if (!hitWords.has(word)) {
+          hitWords.add(word);
+          words[emotion].push(word);
+        }
+        from = idx + word.length;
       }
     }
   }
@@ -321,6 +364,7 @@ export function buildGuidance(ratios, topPatterns, chapterSequences) {
 export function analyzeText(text, options = {}) {
   const top = Number.isInteger(options.top) ? options.top : 8;
   const maxSentences = Number.isInteger(options.maxSentences) ? options.maxSentences : 20000;
+  const curveSegments = Number.isInteger(options.curveSegments) ? Math.min(Math.max(options.curveSegments, 1), 50) : 20;
   const blocks = splitBlocks(text);
   const sentences = [];
   const blockMeta = [];
@@ -509,7 +553,7 @@ export function analyzeText(text, options = {}) {
       })
       .sort((a, b) => b.count - a.count || a.word.localeCompare(b.word))
       .slice(0, 12),
-    curve: emotionCurve(blockMeta, 20)
+    curve: emotionCurve(blockMeta, curveSegments)
   };
 
   // 主观性指数（启发式 0-100）
@@ -616,3 +660,57 @@ function buildFingerprint(categories, lengths, style, emotion, motifs) {
   const motif = motifs.length > 0 ? motifs[0].pattern : "-";
   return parts.join(" ") + " | len:" + lengths.avg + " subj:" + style.subjectivityIndex + " emo:" + emotion.dominant + " | motif:" + motif;
 }
+
+/** 两篇文本的风格指纹相似度（0~1）：句式分布 + 句长 + 主观性的余弦相似度。 */
+export function fingerprintSimilarity(a, b) {
+  const vectorOf = (r) => {
+    const v = [];
+    const catMap = new Map((r.categories ?? []).map((x) => [x.type, x.ratio ?? 0]));
+    for (const type of CATEGORY_ORDER) v.push(catMap.get(type) ?? 0);
+    const len = r.lengths?.avg ?? 0;
+    v.push(Math.min(len, 100) / 100);
+    v.push(r.lengths?.shortRatio ?? 0);
+    v.push(r.lengths?.longRatio ?? 0);
+    v.push((r.style?.subjectivityIndex ?? 0) / 100);
+    return v;
+  };
+  const va = vectorOf(a);
+  const vb = vectorOf(b);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < va.length; i += 1) {
+    dot += va[i] * vb[i];
+    na += va[i] * va[i];
+    nb += vb[i] * vb[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return Math.round((dot / (Math.sqrt(na) * Math.sqrt(nb))) * 1000) / 1000;
+}
+
+/** 风格偏差清单：b 相对 a 的显著差异（阈值可调）。 */
+export function styleDiffs(a, b, threshold = 0.06) {
+  const diffs = [];
+  const catA = new Map((a.categories ?? []).map((x) => [x.type, x.ratio]));
+  const catB = new Map((b.categories ?? []).map((x) => [x.type, x.ratio]));
+  for (const type of CATEGORY_ORDER) {
+    const d = (catB.get(type) ?? 0) - (catA.get(type) ?? 0);
+    if (Math.abs(d) >= threshold) {
+      diffs.push({
+        dimension: CATEGORY_LABELS[type] + "占比",
+        diff: Math.round(d * 1000) / 10,
+        note: d > 0 ? "偏高" : "偏低"
+      });
+    }
+  }
+  if (b.lengths && a.lengths) {
+    const lenDiff = b.lengths.avg - a.lengths.avg;
+    if (Math.abs(lenDiff) >= 5) diffs.push({ dimension: "平均句长", diff: Math.round(lenDiff * 10) / 10, note: lenDiff > 0 ? "偏长" : "偏短" });
+    const shortDiff = (b.lengths.shortRatio ?? 0) - (a.lengths.shortRatio ?? 0);
+    if (Math.abs(shortDiff) >= 0.08) diffs.push({ dimension: "短句占比", diff: Math.round(shortDiff * 1000) / 10, note: shortDiff > 0 ? "偏高" : "偏低" });
+  }
+  if (b.emotion && a.emotion && b.emotion.dominant !== a.emotion.dominant) {
+    diffs.push({ dimension: "主导情绪", diff: 0, note: "由「" + (a.emotion.dominant ?? "?") + "」变为「" + (b.emotion.dominant ?? "?") + "」" });
+  }
+  return diffs;
+}

package/lib/index.js

@@ -25,7 +25,8 @@ import { copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, join, sep } from "node:path";
 import { homedir } from "node:os";
-import { analyzeText, CATEGORY_LABELS, CATEGORY_ORDER } from "./analysis.js";
+import { createHash } from "node:crypto";
+import { analyzeText, CATEGORY_LABELS, CATEGORY_ORDER, fingerprintSimilarity, styleDiffs } from "./analysis.js";
 
 const name = "novel-writer";
 const inject = ["tools", "systemPrompt"];
@@ -230,32 +231,52 @@ function findChapter(chapters, chapterArg) {
 /** 简单中文分词：单字频率 + 相邻双字（二元组）频率。 */
 function extractKeywords(text, top) {
   const cjkBigrams = new Map();
+  const cjkTrigrams = new Map();
   const cjkChars = new Map();
   const enWords = new Map();
+  const nameCandidates = new Map();
   const cjkRun = [];
   for (const ch of text) {
     if (/[\u4e00-\u9fff]/.test(ch)) cjkRun.push(ch);
     else if (cjkRun.length > 0) {
-      tallyCjkRun(cjkRun, cjkChars, cjkBigrams);
+      tallyCjkRun(cjkRun, cjkChars, cjkBigrams, cjkTrigrams);
       cjkRun.length = 0;
     }
   }
-  if (cjkRun.length > 0) tallyCjkRun(cjkRun, cjkChars, cjkBigrams);
+  if (cjkRun.length > 0) tallyCjkRun(cjkRun, cjkChars, cjkBigrams, cjkTrigrams);
   for (const match of text.toLowerCase().matchAll(/[a-z]{2,}/g)) {
     const word = match[0];
     if (!EN_STOP_WORDS.has(word)) enWords.set(word, (enWords.get(word) ?? 0) + 1);
   }
+  // 疑似人名/专名：2~3 字 + 动作/称谓（"露西亚说着""琉璃小姐"）
+  const namePatterns = [
+    /([\u4e00-\u9fff]{2,3})(?:说|道|问|喊|叫|想|笑|叹|答|喝|骂|念|哭|点头|摇头)/g,
+    /([\u4e00-\u9fff]{2,3})(?:小姐|大人|先生|少爷|姑娘|殿下|老师|导师|婆婆|爷爷|奶奶|夫人|老爷|公子|长老|神甫|陛下|殿下|大人|小姐)/g
+  ];
+  for (const pattern of namePatterns) {
+    for (const match of text.matchAll(pattern)) {
+      const name = match[1];
+      if (name === "那个" || name === "这个" || name === "什么" || name === "怎么" || name === "自己" || name === "她们" || name === "他们" || name === "你们") continue;
+      nameCandidates.set(name, (nameCandidates.get(name) ?? 0) + 1);
+    }
+  }
   const keywords = [];
   for (const [word, count] of cjkBigrams) {
     if (count > 1) keywords.push({ word, count, kind: "cjk-bigram" });
   }
+  for (const [word, count] of cjkTrigrams) {
+    if (count > 1) keywords.push({ word, count, kind: "cjk-trigram" });
+  }
+  for (const [word, count] of nameCandidates) {
+    if (count >= 2) keywords.push({ word, count, kind: "name-candidate" });
+  }
   for (const [word, count] of enWords) {
     if (count > 1) keywords.push({ word, count, kind: "word" });
   }
   keywords.sort((a, b) => b.count - a.count || a.word.localeCompare(b.word));
   return keywords.slice(0, top);
 }
-function tallyCjkRun(run, cjkChars, cjkBigrams) {
+function tallyCjkRun(run, cjkChars, cjkBigrams, cjkTrigrams) {
   for (let i = 0; i < run.length; i += 1) {
     const ch = run[i];
     if (!CJK_STOP_CHARS.has(ch)) cjkChars.set(ch, (cjkChars.get(ch) ?? 0) + 1);
@@ -264,6 +285,11 @@ function tallyCjkRun(run, cjkChars, cjkBigrams) {
       const meaningful = !CJK_STOP_CHARS.has(run[i]) || !CJK_STOP_CHARS.has(run[i + 1]);
       if (meaningful) cjkBigrams.set(bigram, (cjkBigrams.get(bigram) ?? 0) + 1);
     }
+    if (i + 2 < run.length) {
+      const trigram = run[i] + run[i + 1] + run[i + 2];
+      const nonStop = [run[i], run[i + 1], run[i + 2]].filter((ch) => !CJK_STOP_CHARS.has(ch)).length;
+      if (nonStop >= 2) cjkTrigrams.set(trigram, (cjkTrigrams.get(trigram) ?? 0) + 1);
+    }
   }
 }
 
@@ -378,6 +404,7 @@ function registerNovelImport(ctx, config) {
               properties: {
                 book: { type: "string" },
                 from: { type: "string", enum: ["file", "content", "forced"] },
+                maybe: { type: "array", items: { type: "string" }, description: "可能同书的其他分组名（供 AI 判断是否用 book 合并）。" },
                 files: {
                   type: "array",
                   items: {
@@ -496,7 +523,24 @@ function registerNovelImport(ctx, config) {
           }))
         });
       }
-      groups.sort((a, b) => b.files.length - a.files.length || a.book.localeCompare(b.book));
+      // v0.6.0：异名同书提示——组名包含关系或字符重合率高时列为"可能同书"
+      for (const group of groups) {
+        const maybe = [];
+        for (const other of groups) {
+          if (other === group || other.book === group.book) continue;
+          const a = String(group.book).replace(/\s/g, "");
+          const b = String(other.book).replace(/\s/g, "");
+          if (a.length < 2 || b.length < 2) continue;
+          const contained = a.includes(b) || b.includes(a);
+          const setA = new Set(a);
+          const setB = new Set(b);
+          let common = 0;
+          for (const ch of setA) if (setB.has(ch)) common += 1;
+          const overlap = common / Math.max(setA.size, setB.size, 1);
+          if (contained || overlap >= 0.6) maybe.push(other.book);
+        }
+        if (maybe.length > 0) group.maybe = maybe;
+      }
       const imported = [];
       if (mode === "apply") {
         for (const group of groups) {
@@ -611,6 +655,23 @@ function isLoopbackRequest(request) {
   try { return new URL(origin).host === hostUrl.host; } catch { return false; }
 }
 
+/**
+ * 请求放行判定：loopback 总是放行；allowLan=true 时额外放行同源局域网请求
+ * （仅校验 Host 与 origin 主机一致 + 非 cross-site）。
+ */
+function isAllowedRequest(request, allowLan) {
+  if (isLoopbackRequest(request)) return true;
+  if (allowLan !== true) return false;
+  const host = request.headers?.host;
+  if (typeof host !== "string") return false;
+  let hostUrl;
+  try { hostUrl = new URL(`http://${host}`); } catch { return false; }
+  if (request.headers?.["sec-fetch-site"] === "cross-site") return false;
+  const origin = request.headers?.origin;
+  if (origin === void 0) return true;
+  try { return new URL(origin).host === hostUrl.host; } catch { return false; }
+}
+
 /** 写一个 JSON 响应。 */
 function writeJson(res, status, body) {
   const payload = JSON.stringify(body);
@@ -631,10 +692,10 @@ async function readJsonBody(req) {
 }
 
 /** /api/dsh-novel-writer/state 路由：GET 读开关，POST 写开关。 */
-function makeStateRoutes() {
+function makeStateRoutes(allowLan) {
   const routePath = "/api/dsh-novel-writer/state";
   const handler = async (req, res) => {
-    if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: "forbidden: loopback-only" });
+    if (!isAllowedRequest(req, allowLan)) return writeJson(res, 403, { error: "forbidden: loopback-only" });
     const method = req.method ?? "GET";
     if (method === "GET") {
       const state = await readSentenceState();
@@ -659,10 +720,10 @@ function makeStateRoutes() {
  * 注册 UI 开关状态路由。用可选注入 ctx.inject(["webServer"])：
  * headless 等没有 webServer 服务的 profile 自动跳过，不会导致插件加载失败。
  */
-function registerStyleConfigRoute(ctx) {
+function registerStyleConfigRoute(ctx, config) {
   try {
     ctx.inject(["webServer"], (wctx) => {
-      const routes = makeStateRoutes();
+      const routes = makeStateRoutes(config?.allowLanState === true);
       wctx.effect?.(() => {
         const disposers = routes.map((route) => wctx.webServer.register(route));
         return () => {
@@ -742,6 +803,8 @@ function registerNovelSentenceAnalysis(ctx, config) {
         chapter: { type: "string", description: "可选。只分析该章节；省略则分析全书。" },
         top: { type: "integer", description: "返回的高频句式模板数量。默认 8。" },
         maxSentences: { type: "integer", description: "采样句数上限（超长文本保护，默认 20000）。" },
+        curveSegments: { type: "integer", description: "情感曲线分段数（1-50，默认 20）。" },
+        fresh: { type: "boolean", description: "true=强制重新分析（忽略缓存）。默认 false。" },
         root: { type: "string", description: "章节库根目录。默认取会话工作区。" }
       },
       required: ["book"],
@@ -859,6 +922,9 @@ function registerNovelSentenceAnalysis(ctx, config) {
             },
             required: ["dominant", "scores", "intensity", "topWords", "curve"]
           },
+          reportFile: { type: "string" },
+          cache: { type: "string", enum: ["hit", "miss"] },
+          cachedAt: { type: "string" },
           chapterPatterns: {
             type: "array",
             items: {
@@ -883,6 +949,8 @@ function registerNovelSentenceAnalysis(ctx, config) {
       const chapterArg = optionalString(args, "chapter");
       const top = optionalInt(args, "top", 1, 50, 8);
       const maxSentences = optionalInt(args, "maxSentences", 100, 100000, 20000);
+      const curveSegments = optionalInt(args, "curveSegments", 1, 50, 20);
+      const fresh = args?.fresh === true;
       const root = resolveRoot(config, args, exec);
       const state = await readSentenceState();
       const effective = effectiveSentenceAnalysis(config, state);
@@ -901,10 +969,17 @@ function registerNovelSentenceAnalysis(ctx, config) {
       }
       let text = "";
       const chapterTexts = [];
+      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);
+        } catch {
+          scopeKeyParts.push(chapter.file + ":?:?");
+        }
       }
       if (!effective.enabled) {
         return {
@@ -916,15 +991,30 @@ function registerNovelSentenceAnalysis(ctx, config) {
           message: "句式模式分析当前已关闭。可在 Web GUI 侧边栏「句式分析」面板开启，或用 novel_sentence_config 设置 enabled=true。"
         };
       }
-      const options = { top, maxSentences };
+      // v0.6.0：分析结果缓存 + 报告导出（用户建议的临时文件方案）
+      const cacheDir = join(homedir(), ".dsh", "dsh-novel-writer", "cache");
+      const cacheKey = createHash("sha1").update(book + "|" + scope + "|" + scopeKeyParts.join(",")).digest("hex").slice(0, 20);
+      const reportFile = join(cacheDir, book + "-" + cacheKey + ".json");
+      if (!fresh) {
+        try {
+          const cached = JSON.parse(await readFile(reportFile, "utf8"));
+          return { ...cached, book, scope, cache: "hit", reportFile, cachedAt: cached.cachedAt ?? new Date().toISOString() };
+        } catch { /* 缓存缺失/损坏，重新分析 */ }
+      }
+      const options = { top, maxSentences, curveSegments };
       if (chapterTexts.length > 0) options.chapterTexts = chapterTexts;
-      return {
+      const result = {
         book,
         scope,
         enabled: true,
         autoAnalyze: effective.autoAnalyze,
         ...analyzeText(text, options)
       };
+      try {
+        await mkdir(cacheDir, { recursive: true });
+        await writeFile(reportFile, JSON.stringify({ ...result, cachedAt: new Date().toISOString() }, null, 2), "utf8");
+      } catch { /* 缓存写失败不影响结果 */ }
+      return { ...result, cache: "miss", reportFile, cachedAt: new Date().toISOString() };
     }
   });
 }
@@ -992,6 +1082,229 @@ ${value.updated === true ? "(已保存到 state 文件)" : ""}
   });
 }
 
+
+/** v0.6.0 风格自检：某章节 vs 全书其余章节的指纹对比。 */
+function registerNovelStyleCheck(ctx, config) {
+  ctx.tools.register({
+    name: "novel_style_check",
+    description: "风格自检：对比某章节与全书其他章节的风格指纹（句式分布/句长/情绪），输出相似度与偏差清单，用于检查续写是否偏离作者文风。",
+    parameters: {
+      type: "object",
+      properties: {
+        book: { type: "string", description: "书名。" },
+        chapter: { type: "string", description: "要检查的章节（章号/文件名/标题）。" },
+        root: { type: "string", description: "章节库根目录。默认取会话工作区。" }
+      },
+      required: ["book", "chapter"],
+      additionalProperties: false
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          book: { type: "string" },
+          chapter: { type: "string" },
+          baselineScope: { type: "string" },
+          similarity: { type: "number" },
+          verdict: { type: "string", enum: ["high", "medium", "low"] },
+          diffs: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                dimension: { type: "string" },
+                diff: { type: "number" },
+                note: { type: "string" }
+              },
+              required: ["dimension", "diff", "note"]
+            }
+          },
+          chapterFingerprint: { type: "string" },
+          baselineFingerprint: { type: "string" },
+          advice: { type: "string" }
+        },
+        required: ["book", "chapter", "baselineScope", "similarity", "verdict", "diffs", "chapterFingerprint", "baselineFingerprint", "advice"]
+      },
+      render: (_args, value) => {
+        const verdictLabel = value.verdict === "high" ? "高度一致" : value.verdict === "medium" ? "大体一致" : "偏离明显";
+        const lines = [`<path>novels/${value.book}</path>`, "<type>novel-style-check</type>", "<content>", ""];
+        lines.push(`检查章节: ${value.chapter}`);
+        lines.push(`对比基线: ${value.baselineScope}`);
+        lines.push(`风格相似度: ${(value.similarity * 100).toFixed(1)}% (${verdictLabel})`);
+        if (value.diffs.length === 0) {
+          lines.push("偏差: 无明显偏差");
+        } else {
+          lines.push("偏差清单:");
+          for (const d of value.diffs) lines.push(`  - ${d.dimension}: ${d.note} (${d.diff > 0 ? "+" : ""}${d.diff})`);
+        }
+        lines.push(`本章指纹: ${value.chapterFingerprint}`);
+        lines.push(`基线指纹: ${value.baselineFingerprint}`);
+        lines.push("", "【建议】");
+        lines.push(value.advice);
+        lines.push("", "</content>");
+        return [{ type: "text", text: lines.join("\n") }];
+      }
+    },
+    async execute(args, exec) {
+      const book = sanitizeSegment(requiredString(args, "book"), "book");
+      const chapterArg = requiredString(args, "chapter");
+      const root = resolveRoot(config, args, exec);
+      const dir = bookDir(root, book);
+      const chapters = await scanChapters(dir);
+      assert(chapters.length > 1, `book "${book}" 只有 ${chapters.length} 章，无法做风格对比（至少需要 2 章）`);
+      const target = findChapter(chapters, chapterArg);
+      assert(target !== void 0, `cannot find chapter "${chapterArg}" in book "${book}"`);
+      const others = chapters.filter((ch) => ch.file !== target.file);
+      const targetText = await readTextFile(join(dir, target.file), exec);
+      let baselineText = "";
+      for (const ch of others) baselineText += await readTextFile(join(dir, ch.file), exec);
+      const baseline = analyzeText(baselineText, {});
+      const chapter = analyzeText(targetText, {});
+      const similarity = fingerprintSimilarity(baseline, chapter);
+      const diffs = styleDiffs(baseline, chapter);
+      const verdict = similarity >= 0.9 ? "high" : similarity >= 0.75 ? "medium" : "low";
+      let advice = "";
+      if (diffs.length === 0) {
+        advice = "本章与全书风格高度一致，可以放心续写。";
+      } else {
+        advice = "续写时建议注意：" + diffs.slice(0, 4).map((d) => d.dimension + (d.note === "偏高" ? "略多" : "略少")).join("、") + "。若为情节需要（如章节情绪转折），可接受适度偏离，但不要持续漂移。";
+      }
+      return {
+        book,
+        chapter: target.file,
+        baselineScope: others.length === 1 ? others[0].file : `全书除本章外的 ${others.length} 章`,
+        similarity,
+        verdict,
+        diffs,
+        chapterFingerprint: chapter.fingerprint,
+        baselineFingerprint: baseline.fingerprint,
+        advice
+      };
+    }
+  });
+}
+
+/** v0.6.0 伏笔/剧情线登记表。 */
+function plotsFile(root, book) {
+  return join(root, ".novel-writer", sanitizeSegment(book, "book") + ".json");
+}
+async function readPlots(root, book) {
+  try {
+    const parsed = JSON.parse(await readFile(plotsFile(root, book), "utf8"));
+    return Array.isArray(parsed.entries) ? parsed.entries : [];
+  } catch {
+    return [];
+  }
+}
+async function writePlots(root, book, entries) {
+  const file = plotsFile(root, book);
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, JSON.stringify({ book, entries }, null, 2), "utf8");
+}
+function registerNovelPlot(ctx, config) {
+  ctx.tools.register({
+    name: "novel_plot",
+    description: "伏笔/剧情线登记表：维护某部作品的伏笔与剧情钩子（open 待回收 / done 已回收），续写前查看可提醒模型回收伏笔、保持剧情连贯。",
+    parameters: {
+      type: "object",
+      properties: {
+        book: { type: "string", description: "书名。" },
+        action: { type: "string", enum: ["list", "add", "update", "done", "delete"], description: "list=查看（默认）；add=登记新伏笔；update=修改；done=标记已回收；delete=删除。" },
+        id: { type: "string", description: "伏笔 id（update/done/delete 时需要）。" },
+        content: { type: "string", description: "add/update 时：伏笔内容描述。" },
+        chapter: { type: "string", description: "可选：伏笔出现的章节。" },
+        note: { type: "string", description: "可选：备注（如何回收/何时回收）。" },
+        root: { type: "string", description: "章节库根目录。默认取会话工作区。" }
+      },
+      required: ["book"],
+      additionalProperties: false
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          book: { type: "string" },
+          action: { type: "string" },
+          entries: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                id: { type: "string" },
+                content: { type: "string" },
+                chapter: { type: "string" },
+                note: { type: "string" },
+                status: { type: "string", enum: ["open", "done"] },
+                createdAt: { type: "string" },
+                updatedAt: { type: "string" }
+              },
+              required: ["id", "content", "status"]
+            }
+          },
+          message: { type: "string" }
+        },
+        required: ["book", "action", "entries"]
+      },
+      render: (_args, value) => {
+        const lines = [`<path>novels/${value.book}</path>`, "<type>novel-plot</type>", "<content>", ""];
+        if (value.message) lines.push(value.message);
+        const open = value.entries.filter((e) => e.status === "open");
+        const done = value.entries.filter((e) => e.status === "done");
+        lines.push(`未回收伏笔 ${open.length} 条：`);
+        if (open.length === 0) lines.push("  （无）");
+        for (const e of open) lines.push(`  - [${e.id}] ${e.content}${e.chapter ? "（出自 " + e.chapter + "）" : ""}${e.note ? "｜" + e.note : ""}`);
+        if (done.length > 0) {
+          lines.push(`已回收 ${done.length} 条：`);
+          for (const e of done) lines.push(`  - [${e.id}] ${e.content}`);
+        }
+        lines.push("", "</content>");
+        return [{ type: "text", text: lines.join("\n") }];
+      }
+    },
+    async execute(args, exec) {
+      const book = sanitizeSegment(requiredString(args, "book"), "book");
+      const action = ["add", "update", "done", "delete"].includes(args?.action) ? args.action : "list";
+      const root = resolveRoot(config, args, exec);
+      const entries = await readPlots(root, book);
+      const now = new Date().toISOString();
+      let message = "";
+      if (action === "add") {
+        const content = optionalString(args, "content");
+        assert(content !== void 0, "novel_plot add 需要 content 参数");
+        const id = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+        entries.push({ id, content, chapter: optionalString(args, "chapter"), note: optionalString(args, "note"), status: "open", createdAt: now, updatedAt: now });
+        message = `已登记伏笔 #${id}`;
+      } else if (action === "update" || action === "done" || action === "delete") {
+        const id = optionalString(args, "id");
+        assert(id !== void 0, `novel_plot ${action} 需要 id 参数`);
+        const index = entries.findIndex((e) => e.id === id);
+        assert(index !== -1, `伏笔 #${id} 不存在（可用 novel_plot 查看列表）`);
+        if (action === "delete") {
+          entries.splice(index, 1);
+          message = `已删除伏笔 #${id}`;
+        } else if (action === "done") {
+          entries[index].status = "done";
+          entries[index].updatedAt = now;
+          message = `已标记伏笔 #${id} 为已回收`;
+        } else {
+          if (args?.content !== void 0) entries[index].content = String(args.content);
+          if (args?.note !== void 0) entries[index].note = String(args.note);
+          if (args?.chapter !== void 0) entries[index].chapter = String(args.chapter);
+          entries[index].updatedAt = now;
+          message = `已更新伏笔 #${id}`;
+        }
+      }
+      await writePlots(root, book, entries);
+      entries.sort((a, b) => (a.status === b.status ? a.createdAt.localeCompare(b.createdAt) : a.status === "open" ? -1 : 1));
+      return { book, action, entries, ...message ? { message } : {} };
+    }
+  });
+}
+
 // ---- 工具定义 ----
 
 function registerNovelBooks(ctx, config) {
@@ -1294,7 +1607,7 @@ function registerNovelKeywords(ctx, config) {
               properties: {
                 word: { type: "string" },
                 count: { type: "integer" },
-                kind: { type: "string", enum: ["cjk-bigram", "word"] }
+                kind: { type: "string", enum: ["cjk-bigram", "cjk-trigram", "name-candidate", "word"] }
               },
               required: ["word", "count", "kind"]
             }
@@ -1343,7 +1656,7 @@ function formatKeywords(value) {
   const lines = [`<path>novels/${value.book}</path>`, `<type>novel-keywords</type>`, `<content>`, `统计范围: ${value.scope} (共 ${value.totalChars} 字)`, ""];
   if (value.keywords.length === 0) lines.push("（未提取到重复出现的关键词）");
   for (const keyword of value.keywords) {
-    const kind = keyword.kind === "cjk-bigram" ? "词组" : "英文词";
+    const kind = keyword.kind === "cjk-bigram" ? "词组" : keyword.kind === "cjk-trigram" ? "三字组" : keyword.kind === "name-candidate" ? "疑似人名" : "英文词";
     lines.push(`- ${keyword.word} × ${keyword.count} (${kind})`);
   }
   lines.push("", "</content>");
@@ -1437,7 +1750,9 @@ const WORKFLOW_TEXT = [
   "   若发现异名同书（如\"萝莉/幼女\"实为同一本），用 book 参数强制合并后以 apply 模式导入到 novels/<书名>/ 分类存放。",
   "6. 续写 / 辅助写作时：先通读最近的章节（保持人物、时间线、情节伏笔、文风与已提炼的关键词一致），再动笔。",
   "   新章节写入 novels/<书名>/ 文件夹：用 novel_new_chapter 创建章节文件，或直接用 write 工具写文件。",
-  "7. 每次续写前先简述：上一章结尾状态 → 本章目标 → 写作计划，再给出正文。"
+  "7. 每次续写前先简述：上一章结尾状态 → 本章目标 → 写作计划，再给出正文。",
+  "8. 工具链提示：续写/分析前可用 novel_plot 查看未回收伏笔，保持剧情连贯；写完新章节可用 novel_style_check 做风格自检（相似度+偏差清单）；",
+  "   novel_sentence_analysis 结果自动缓存到 ~/.dsh/dsh-novel-writer/cache/（返回值含 reportFile 字段），重复分析直接命中缓存，需要重算时传 fresh=true。"
 ].join("\n");
 
 function apply(ctx, config = {}) {
@@ -1449,8 +1764,10 @@ function apply(ctx, config = {}) {
   registerNovelImport(ctx, config);
   registerNovelSentenceAnalysis(ctx, config);
   registerNovelSentenceConfig(ctx, config);
+  registerNovelStyleCheck(ctx, config);
+  registerNovelPlot(ctx, config);
   // 注册 UI 开关状态路由（可选注入，headless 自动跳过）
-  registerStyleConfigRoute(ctx);
+  registerStyleConfigRoute(ctx, config);
   ctx.systemPrompt.section({
     name: "novel-writing",
     order: 150,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-novel-writer",
-  "version": "0.5.0",
-  "description": "小说写作助手插件（v0.3.0 与 v0.4.0 合并版）：章节库管理、剧情/写作手法/高频关键词分析、句式模式分析（九类句式/排列规律/情感曲线/风格指纹/节奏建议，带 Web UI 开关）、原稿件批量导入自动分类、续写辅助（支持任意位置章号、中文数字、UTF-8/UTF-16/GBK 编码自动探测）",
+  "version": "0.6.0",
+  "description": "小说写作助手插件（v0.6.0 工程化版）：章节库管理、句式模式分析（九类/情感曲线/风格指纹/缓存报告）、风格自检、伏笔登记表、批量导入、续写辅助（关键词含三字组与疑似人名、情感词典去噪、支持任意位置章号、UTF-8/16/GBK 编码探测）",
   "type": "module",
   "main": "lib/index.js",
   "exports": {

package/skills/novel-writing/SKILL.md

@@ -10,43 +10,41 @@
 1. `novel_books` 找到用户的作品；
 2. `novel_chapters` 查看章节结构与各章字数；
 3. `novel_read` 逐章通读（长章节用 offset/limit 分段读完）；
-4. `novel_keywords` 提取高频关键词（中文词组/单字 + 英文词），作为词汇偏好与意象母题的证据；
-5. 输出分析，至少覆盖三方面：
+4. `novel_keywords` 提取高频关键词（二字组/三字组/疑似人名/英文词）；
+5. `novel_sentence_analysis` 做句式模式分析（九类分布、排列规律、情感曲线、章节节奏、风格指纹）；
+6. 输出分析，至少覆盖三方面：
    - **剧情脉络**：冲突、转折、悬念、伏笔、人物关系与目标；
    - **写作手法**：叙事视角、节奏、对话、环境与细节描写、比喻意象、留白；
    - **关键词与意象**：结合 novel_keywords 的结果，指出作者反复使用的词汇与意象，并引用具体章节佐证。
 
-## 句式模式分析（v0.5.0 合并版）
+## 句式模式分析（v0.5.0 合并 + v0.6.0 增强）
 
-- 工具 `novel_sentence_analysis`：九类句式（陈述/环境/心理/对话/疑问/反问/感叹/祈使/省略留白）——
-  - 分布：比例、句数、平均句长、例句；
-  - 排列：句式转移、2/3 连句模板、段首/段尾句式、按章节的压缩节奏序列（S×8 ENV×2 PSY×3…）；
-  - 节奏：句长均值/中位数、短句/长句占比；
-  - 主观情感：情感词典（喜/怒/哀/惧/惊）+ 强度副词加权 → 主导情绪、情绪分布、情感曲线、主观性指数；
-  - 风格指纹 + 节奏建议（guidance）。
-- 工具 `novel_sentence_config`：查看/修改开关（`enabled` / `autoAnalyze`）。
-- 开关默认开启；统一在 Web GUI 侧边栏「句式分析」面板调整（设置 > 插件配置 仅显示状态），也可用 novel_sentence_config。
-- 使用规则：
-  - 动手前先调用 `novel_sentence_config` 查看状态；
-  - `enabled=false` 时 novel_sentence_analysis 会返回关闭状态，不要强行分析；
-  - `autoAnalyze=true` 时分析作品应主动附带句式分析；false 时仅在用户明确要求时调用；
-  - **风险约束**：句式模式是参考节奏而非模板套用；若机械复刻导致僵硬，必须优先回归自然表达。
+- 九类句式：陈述/环境/心理/对话/疑问/反问/感叹/祈使/省略留白；
+- 情感曲线（喜/怒/哀/惧/惊）、句长节奏、段落结构、风格指纹、节奏建议（guidance）；
+- **缓存**：结果自动缓存（返回 `reportFile` / `cache`），章节未变重复分析秒回，`fresh=true` 强制重算；
+- 情感词典已去噪（"叹气"不算"气"、"不害怕"不计）、祈使/环境分类已增强。
 
-## 原稿件批量导入（v0.4.0 合并）
+## 风格自检（v0.6.0 新增）
 
-- 工具 `novel_import`：扫描存放多本小说稿件的文件夹（`src`），自动识别书名/章号并分组；
-- 先以 `scan` 模式查看分组建议；发现异名同书时用 `book` 参数强制合并；
-- 确认后以 `apply` 模式导入到 `novels/<书名>/`（默认复制，`move` 可移动）。
+- 写完新章节后调用 `novel_style_check`：本章 vs 全书其余章节 → 相似度 + 偏差清单 + 建议；
+- 偏差明显时主动调整文风（对话/心理占比、句长、情绪），防止漂移。
+
+## 伏笔登记表（v0.6.0 新增）
+
+- `novel_plot`：list / add / update / done / delete 管理伏笔与剧情钩子；
+- 续写前先 `novel_plot list` 查看未回收伏笔，续写中主动回收；
+- 存储于 `<书库根>/.novel-writer/<书名>.json`。
 
 ## 续写工作流
 
 1. 先通读最近的章节（必要时读完全书），保持：人物设定、时间线、情节伏笔、文风、已提炼的关键词一致；
-2. 动笔前简述：上一章结尾状态 → 本章目标 → 写作计划；
-3. 用 `novel_new_chapter` 创建新章节文件，或直接用 `write` 工具写入 `novels/<书名>/第NN章.md`；
-4. 正文用中文，保持与原文一致的叙事风格与细节密度；
-5. 若句式分析已启用且 autoAnalyze=true，续写时可参考句式指纹与节奏序列保持节奏一致，但僵硬时必须回归自然表达。
+2. `novel_plot list` 查看未回收伏笔；
+3. 动笔前简述：上一章结尾状态 → 本章目标 → 写作计划；
+4. 用 `novel_new_chapter` 创建新章节文件，或直接用 `write` 工具写入；
+5. 正文用中文，保持与原文一致的叙事风格与细节密度；句式分析开启时参考指纹与节奏序列，僵硬时回归自然表达；
+6. 写完后 `novel_style_check` 自检文风，`novel_plot add` 登记新伏笔。
 
 ## 注意事项
 
-- 用户放入章节文件的方式不限：可以自己复制进文件夹，也可以让 AI 用 `write`/`edit` 工具创建，或用 novel_import 批量导入。
+- 用户放入章节文件的方式不限：自己复制、AI 用 `write`/`edit` 创建，或用 novel_import 批量导入。
 - 分析结果与续写正文都应使用中文呈现。

package/test/e2e-test.mjs

@@ -0,0 +1,78 @@
+// 端到端测试：10 工具注册、缓存、伏笔、风格自检、路由（v0.6.0）
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { apply } from "../lib/index.js";
+
+const testRoot = join(process.cwd(), ".e2e-test");
+rmSync(testRoot, { recursive: true, force: true });
+mkdirSync(join(testRoot, "novels", "测试"), { recursive: true });
+writeFileSync(join(testRoot, "novels", "测试", "第01章.md"), "雨下了一整夜。她站在窗前，心里想着明天的事。\n“你真的要走吗？”他低声问。\n难道这就是结局？她不禁这样想。\n", "utf8");
+writeFileSync(join(testRoot, "novels", "测试", "第02章.md"), "日子照旧。她习惯了独自吃饭。窗外风急，雨打芭蕉。\n", "utf8");
+
+const registry = [];
+const routes = [];
+const ctx = {
+  tools: { register: (d) => { registry.push(d); return () => {}; } },
+  systemPrompt: { section: () => () => {} },
+  inject: (names, cb) => cb({ webServer: { register: (r) => { routes.push(r); return () => {}; } }, effect: (fn) => fn() }),
+};
+apply(ctx, { root: testRoot, sentenceAnalysis: { enabled: true, autoAnalyze: true }, allowLanState: true });
+const defs = Object.fromEntries(registry.map((d) => [d.name, d]));
+const names = registry.map((d) => d.name);
+console.log("工具数:", names.length, names.join(", "));
+if (names.length !== 10) throw new Error("expected 10 tools");
+
+const exec = { agent: { session: { header: { cwd: testRoot } } } };
+
+// 1) 分析 + 缓存（第一次 miss，第二次 hit）
+const first = await defs.novel_sentence_analysis.execute({ book: "测试" }, exec);
+console.log("首次分析 cache:", first.cache, "| reportFile:", first.reportFile?.includes("cache"));
+if (first.cache !== "miss") throw new Error("first should be miss");
+const second = await defs.novel_sentence_analysis.execute({ book: "测试" }, exec);
+console.log("二次分析 cache:", second.cache, "| 指纹一致:", second.fingerprint === first.fingerprint);
+if (second.cache !== "hit") throw new Error("second should be hit");
+const fresh = await defs.novel_sentence_analysis.execute({ book: "测试", fresh: true }, exec);
+console.log("fresh 重算 cache:", fresh.cache);
+if (fresh.cache !== "miss") throw new Error("fresh should miss");
+
+// 2) 风格自检
+const check = await defs.novel_style_check.execute({ book: "测试", chapter: "第02章.md" }, exec);
+console.log("风格自检: 相似度", check.similarity, "| verdict:", check.verdict, "| diffs:", check.diffs.length, "| advice:", !!check.advice);
+if (typeof check.similarity !== "number" || !check.advice) throw new Error("style check broken");
+
+// 3) 伏笔登记表
+const add = await defs.novel_plot.execute({ book: "测试", action: "add", content: "母神名讳之谜", chapter: "第01章", note: "第二章回收" }, exec);
+console.log("伏笔 add:", add.message, "| entries:", add.entries.length);
+const id = add.entries[0].id;
+await defs.novel_plot.execute({ book: "测试", action: "add", content: "代行者血脉", chapter: "第01章" }, exec);
+const list = await defs.novel_plot.execute({ book: "测试", action: "list" }, exec);
+console.log("伏笔 list:", list.entries.map((e) => e.content + ":" + e.status).join(" "));
+await defs.novel_plot.execute({ book: "测试", action: "done", id }, exec);
+const afterDone = await defs.novel_plot.execute({ book: "测试", action: "list" }, exec);
+console.log("done 后:", afterDone.entries.map((e) => e.content + ":" + e.status).join(" "));
+if (afterDone.entries.find((e) => e.id === id).status !== "done") throw new Error("plot done broken");
+const plotFile = join(testRoot, ".novel-writer", "测试.json");
+if (!existsSync(plotFile)) throw new Error("plot file not persisted");
+console.log("伏笔文件:", plotFile, "存在 ✓");
+
+// 4) 关键词（三字组/疑似人名）
+writeFileSync(join(testRoot, "novels", "测试", "第03章.md"), "露西亚说着话，琉璃点了点头。露西亚问导师问题，琉璃笑道。\n", "utf8");
+const kw = await defs.novel_keywords.execute({ book: "测试", top: 20 }, exec);
+console.log("关键词:", kw.keywords.map((k) => k.word + "(" + k.kind + ")").join(" "));
+if (!kw.keywords.some((k) => k.kind === "name-candidate" && (k.word.includes("露西") || k.word.includes("琉璃")))) throw new Error("name candidate missing");
+
+// 5) 路由 allowLan：非 loopback 同源放行
+const handler = routes.find((r) => r.path === "/api/dsh-novel-writer/state").handler;
+const res = { status: 0, body: "", writeHead(s) { this.status = s; }, end(b) { this.body = String(b); } };
+await handler({
+  method: "GET", url: "/api/dsh-novel-writer/state",
+  socket: { remoteAddress: "192.168.1.5" },
+  headers: { host: "192.168.1.5:3080", origin: "http://192.168.1.5:3080" },
+}, res);
+console.log("局域网 GET（allowLanState=true）:", res.status);
+if (res.status !== 200) throw new Error("allowLan route broken");
+
+// 清理缓存文件（保留状态文件）
+rmSync(testRoot, { recursive: true, force: true });
+console.log("\nALL E2E TESTS PASSED");

package/test/pattern-test.mjs

@@ -1,52 +1,48 @@
-// 句式模式分析引擎测试（v0.5.0 合并版：九类 + 压缩序列 + guidance）
-import { analyzeText, classifySentence, compressSequence, buildGuidance, splitSentences, CATEGORY_ORDER, TYPE_CODE } from "../lib/analysis.js";
+// 句式模式分析引擎测试（v0.6.0：九类 + 去噪 + 相似度）
+import { analyzeText, classifySentence, fingerprintSimilarity, styleDiffs, splitSentences } from "../lib/analysis.js";
 
 const SAMPLE = `雨下了一整夜。她站在窗前，心里想着明天的事。
 “你真的要走吗？”他低声问。
-她沉默了很久，终于开口：“嗯。”
-他走了。门关上的声音很轻，却像重锤砸在她心上。
 难道这就是结局？她不禁这样想。
-她忽然觉得胸口发闷，眼泪毫无预兆地落了下来。
 窗外风急，雨打芭蕉。
 多安静啊！
 快睡吧，明天还要上班。
 ……
 `;
 
-const sentences = splitSentences(SAMPLE);
-console.log("句子总数:", sentences.length);
-
+let ok = true;
 const checks = [
-  ["雨下了一整夜。", "statement"],
   ["窗外风急，雨打芭蕉。", "environment"],
   ["她心里一紧，想起当年那场大火。", "psychology"],
   ["「小姐，先歇下吧。」", "dialogue"],
-  ["“你真的要走吗？”", "dialogue"],
   ["难道这就是结局？", "rhetoric-question"],
-  ["你怎么能这样对我？", "rhetoric-question"],
-  ["多安静啊！", "exclamation"],
-  ["快睡吧，明天还要上班。", "imperative"]
+  ["快睡吧，明天还要上班。", "imperative"],   // v0.6.0：命令动词开头 + 吧
 ];
-let ok = true;
 for (const [text, expect] of checks) {
   const got = classifySentence(text).type;
-  const pass = got === expect;
-  if (!pass) ok = false;
-  console.log((pass ? "✓" : "✗"), expect.padEnd(20), "<=", text.slice(0, 18), "实际:", got);
+  if (got !== expect) { ok = false; console.log("✗", expect, "<=", text, "实际:", got); }
 }
+console.log("九类分类抽查:", ok ? "PASS" : "FAIL");
+
+// 情感去噪："叹气"不算"气"；"不害怕"不计
+const t1 = "她叹了口气，笑着说：\"没事。\" 她一点都不害怕，反而觉得很温暖。";
+const r1 = analyzeText(t1);
+const angerCount = r1.emotion.scores.find((s) => s.emotion === "anger").count;
+const fearCount = r1.emotion.scores.find((s) => s.emotion === "fear").count;
+console.log("情感去噪: anger(叹气不算):", angerCount, "| fear(不害怕不计):", fearCount, angerCount === 0 && fearCount === 0 ? "PASS" : "FAIL");
+if (angerCount !== 0 || fearCount !== 0) ok = false;
 
-const result = analyzeText(SAMPLE, { top: 8 });
-console.log("\n总句数:", result.totalSentences, "| 分类:", CATEGORY_ORDER.map((t) => TYPE_CODE[t] + ":" + result.categories.find((c) => c.type === t).count).join(" "));
-console.log("chapterPatterns:", JSON.stringify(result.chapterPatterns));
-console.log("guidance:", result.guidance.split("\n").slice(0, 2).join(" / "));
-console.log("fingerprint:", result.fingerprint.slice(0, 80));
-console.log("情感主导:", result.emotion.dominant, "| 环境占比:", result.style.environmentRatio);
-console.log("\n压缩序列:", compressSequence(result.categories.map((c) => TYPE_CODE[c.type])));
+// 相似度与偏差
+const r2 = analyzeText(SAMPLE);
+const sim = fingerprintSimilarity(r1, r2);
+console.log("指纹相似度(不同文本):", sim, sim >= 0 && sim <= 1 ? "PASS" : "FAIL");
+console.log("styleDiffs(自比):", styleDiffs(r1, r1).length === 0 ? "PASS" : "FAIL");
+if (styleDiffs(r1, r1).length !== 0) ok = false;
 
-// 采样上限
-const big = SAMPLE.repeat(300);
-const capped = analyzeText(big, { maxSentences: 500 });
-console.log("\nmaxSentences=500 采样:", capped.totalSentences, "(<=500:", capped.totalSentences <= 500, ")");
+// 情感曲线分段可调
+const r3 = analyzeText(SAMPLE.repeat(20), { curveSegments: 5 });
+console.log("curveSegments=5 曲线段数:", r3.emotion.curve.length, r3.emotion.curve.length === 5 ? "PASS" : "FAIL");
+if (r3.emotion.curve.length !== 5) ok = false;
 
 console.log("\n" + (ok ? "ALL PATTERN TESTS PASSED" : "SOME TESTS FAILED"));
 process.exit(ok ? 0 : 1);