dsh-novel-writer 0.7.0 → 0.8.1

package/README.md

@@ -1,64 +1,23 @@
-# dsh-novel-writer — 小说写作助手插件（v0.7.0：全工具 UI 开关）
+# dsh-novel-writer — 小说写作助手插件（v0.8.1：记忆层）
 
 DSH（DeepSeek Harness）小说写作助手 bundle 插件。宿主端零第三方依赖（仅 Node 内置模块），
 浏览器端仅依赖 Web GUI 自带的 react。
-**v0.7.0 在 v0.6.0 基础上为全部 10 个工具增加独立 UI 开关（侧边栏「写作助手功能」面板统一管理）**：分析缓存与报告导出、风格自检、伏笔登记表、
+**v0.8.1 在 v0.7.0 基础上补全「记忆层」：四张设定表、章节摘要、连贯性审计、伏笔字段化与提及追踪、细节密度指标、统一数据目录、UI 路径可视化修复**：分析缓存与报告导出、风格自检、伏笔登记表、
 关键词三字组/疑似人名、情感词典去噪、祈使句与环境分类改进、局域网开关可选放行。
 
-## 工具清单（10 个，全部带独立 UI 开关）
+## 工具清单（13 个，全部带独立 UI 开关）
 
-| 工具 | 说明 |
-|---|---|
-| `novel_books` | 列出章节库全部作品 |
-| `novel_chapters` | 列出某作品章节清单 |
-| `novel_read` | 阅读某章正文（offset/limit 分段，编码自动探测） |
-| `novel_keywords` | 关键词：二字组 + **三字组** + **疑似人名** + 英文词 |
-| `novel_new_chapter` | 创建新章节文件 |
-| `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 |
+novel_books / novel_chapters / novel_read / novel_keywords / novel_new_chapter / novel_import / novel_sentence_analysis / novel_sentence_config / novel_style_check / novel_plot / **novel_settings（设定管理）** / **novel_summary（章节摘要）** / **novel_continuity_check（连贯性审计）**
 
-## v0.6.0 新增能力
+## v0.8.1 新增能力
 
-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）。
-
-## UI 开关（v0.7.0：10 个工具全开关）
-
-- **唯一开关位置：侧边栏「写作助手功能」面板**——总开关（enabled，控制句式分析/风格自检）+ 自动分析（autoAnalyze）+ **10 个工具各自独立开关**（全部默认开启）；
-- 关闭的工具，AI 调用时会收到明确提示；novel_sentence_config 可查/改全部开关（含 tools 字段）；
-- 设置 > 插件配置 卡片仅显示状态 + 「打开开关面板」跳转；
-- 持久化 `~/.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 + `dsh.profile.bundles` 加 `dsh-novel-writer`；重启 web 应用。
-
-## 配置
-
-```yaml
-- id: novel-writer
-  config:
-    root: 'D:/我的小说库'
-    sentenceAnalysis:
-      enabled: true
-      autoAnalyze: true
-    allowLanState: false   # true=局域网访问 GUI 时也允许保存开关
+- **novel_settings（四张表）**：人物卡/地点卡/道具清单/时间线，list/add/update/delete + scan 候选提取；
+- **novel_summary**：模型生成、插件存储的每章摘要（长书续写先读摘要）；
+- **novel_continuity_check**：对照设定表扫描全书 → 数字口径/人物缺场/别名/重复条目矛盾候选；
+- **novel_plot 字段化**：type/priority/relatedCharacters/locations/payoffCondition/mentionedIn/lastMentioned + scan 自动提及追踪；
+- **细节密度指标**：动作链密度/物件名词/感官词（千字归一）进 novel_sentence_analysis 与 novel_style_check；
+- **统一数据目录**：§BT§<书库根>/.novel-writer/§BT§ 下 plots/ settings/ summaries/ analysis/ audits/（伏笔旧位置自动迁移；分析缓存与关键词报告落盘到 analysis/）；
+- **UI 路径修复**：cordis 空字符串 root 回退 lastRoot、面板刷新按钮、打开/复制按钮不再禁用、显示 dataDir。
 
 ## v0.7.0 更新内容
 

package/lib/analysis.js

@@ -599,6 +599,7 @@ export function analyzeText(text, options = {}) {
   const guidance = buildGuidance(ratios, motifs, chapterPatterns);
 
   const fingerprint = buildFingerprint(categories, lengths, style, emotion, motifs);
+  const density = densityOf(text);
 
   return {
     totalChars,
@@ -612,6 +613,7 @@ export function analyzeText(text, options = {}) {
     emotion,
     chapterPatterns,
     guidance,
+    density,
     fingerprint
   };
 }
@@ -714,3 +716,48 @@ export function styleDiffs(a, b, threshold = 0.06) {
   }
   return diffs;
 }
+
+/** v0.8.0 细节密度词表：动作动词/物件名词/感官词。 */
+const DENSITY_ACTION_VERBS = /摸|拿|推|拉|走|跑|蹲|站|坐|转|伸|握|点|掀|翻|跪|爬|钻|抱|搂|抬|放|挂|摘|系|披|踩|迈|跨|扑|撞|躲|闪|看|盯|瞥|望|听|闻|尝|咬|喝|吃|敲|拍|捏|揉|擦|吹|按|拨|拧|捡|拾|丢|抛|接|递|塞|掏|捞|舀|倒|浇|洗|叠|铺|盖|关|开|掩|合/;
+const DENSITY_OBJECT_WORDS = /油灯|灯|床|门|窗|桌|椅|凳|杯|碗|碟|盘|筷|勺|剑|刀|枪|书|本|纸|笔|衣|裙|帽|鞋|镜|烛台|蜡烛|铁罐|罐|盒|箱|马车|车|墙|柱|帘|毯|被|枕|簪|铃|钟|画|架|梯|绳|袋|篮|桶|壶|锅|铲|柴|炭|火|灰/;
+const DENSITY_SENSE = {
+  visual: /看|见|映入|光|亮|暗|色|影|闪|照|映|目光|眼神|脸|面|状|样/,
+  auditory: /听|声|音|响|钟|脚步|敲|喊|叫|低语|呢喃|咕哝|咚|砰|咔/,
+  tactile: /凉|热|疼|痛|滑|糙|冷|暖|烫|冰|湿|干|硬|软|麻|痒/,
+  olfactory: /香|臭|味|气|腥|甜|苦|酸/,
+  temperature: /热|烫|凉|冷|暖|温/
+};
+
+/** 细节密度统计（v0.8.0）：动作链/物件名词/感官词，按千字归一。 */
+export function densityOf(text) {
+  const sentences = splitSentences(text);
+  const totalChars = text.replace(/\s/g, "").length;
+  let actionVerbs = 0;
+  let actionChainSentences = 0;
+  let objectHits = 0;
+  const sense = { visual: 0, auditory: 0, tactile: 0, olfactory: 0, temperature: 0 };
+  const actionChains = [];
+  for (const sentence of sentences) {
+    let verbs = 0;
+    for (const m of sentence.matchAll(new RegExp(DENSITY_ACTION_VERBS.source, "g"))) verbs += 1;
+    if (verbs >= 2) {
+      actionChainSentences += 1;
+      if (actionChains.length < 3) actionChains.push(sentence.slice(0, 40));
+    }
+    actionVerbs += verbs;
+    for (const m of sentence.matchAll(new RegExp(DENSITY_OBJECT_WORDS.source, "g"))) objectHits += 1;
+    for (const [kind, re] of Object.entries(DENSITY_SENSE)) {
+      for (const m of sentence.matchAll(new RegExp(re.source, "g"))) sense[kind] += 1;
+    }
+  }
+  const per1000 = (n) => Math.round((n / Math.max(totalChars, 1)) * 1000 * 10) / 10;
+  const ratio = sentences.length === 0 ? 0 : Math.round((actionChainSentences / sentences.length) * 1000) / 10;
+  return {
+    actionVerbsPer1000: per1000(actionVerbs),
+    actionChainRatio: ratio,
+    actionChainExamples: actionChains,
+    objectNounsPer1000: per1000(objectHits),
+    sensePer1000: per1000(Object.values(sense).reduce((x, y) => x + y, 0)),
+    sense: { ...sense }
+  };
+}

package/lib/client.js

@@ -36,6 +36,8 @@ window.__ModuleLoader__.load({
       ".nwPanelHeader{display:flex;align-items:center;gap:10px}" +
       ".nwPanelTitle{font-size:16px;font-weight:700;flex:1;min-width:0}" +
       ".nwClose{appearance:none;font:inherit;cursor:pointer;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-secondary);width:30px;height:30px;line-height:1}" +
+      ".nwRefresh{appearance:none;font:inherit;cursor:pointer;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-secondary);font-size:11px;line-height:1;padding:5px 9px}" +
+      ".nwRefresh:hover{background:var(--dsw-alias-bg-layer-2)}" +
       ".nwDesc{color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:1.6;margin:0}" +
       ".nwBanner{display:flex;align-items:center;gap:10px;border-radius:12px;padding:14px 16px;font-size:15px;font-weight:700;border:1px solid}" +
       ".nwBannerOn{background:rgba(34,197,94,.12);border-color:#22c55e;color:#15803d}" +
@@ -132,13 +134,21 @@ window.__ModuleLoader__.load({
       "tool.novel_sentence_config.desc": "查看/修改全部开关（AI 通道）。",
       "tool.novel_style_check.desc": "本章文风与全书其余章节的相似度检查。",
       "tool.novel_plot.desc": "登记/回收剧情伏笔，续写前查看未回收项。",
-      "plot.pathLabel": "存储位置",
-      "plot.pathUnknown": "位于书库根的 .novel-writer 文件夹（每本书一个 JSON）。先让 AI 调用一次 novel_plot，此处会显示真实路径。",
+      "tool.novel_settings": "设定管理 novel_settings",
+      "tool.novel_summary": "章节摘要 novel_summary",
+      "tool.novel_continuity_check": "连贯性审计 novel_continuity_check",
+      "tool.novel_settings.desc": "四张设定表：人物卡/地点卡/道具/时间线。",
+      "tool.novel_summary.desc": "保存/读取每章摘要，长书续写先读摘要。",
+      "tool.novel_continuity_check.desc": "对照设定表扫描全书，输出矛盾候选。",
+      "plot.pathLabel": "数据目录",
+      "plot.pathUnknown": "位于书库根的 .novel-writer 文件夹（plots 伏笔 / settings 设定 / summaries 摘要 / analysis 分析报告）。先让 AI 调用一次 novel_plot 或 novel_settings，此处会显示真实路径。",
       "plot.open": "打开文件夹",
       "plot.copy": "复制路径",
       "plot.copied": "已复制",
       "plot.revealOk": "已打开文件夹",
       "plot.revealErr": "打开失败",
+      "panel.refresh": "刷新",
+      "panel.refreshed": "已刷新",
       "card.title": "小说写作助手 novel-writer",
       "card.desc": "句式模式分析：分析原文陈述/环境/心理/对话/疑问/反问/感叹等句子的排列节奏来辅助模仿文风。⚠️ 若机械套用导致文风僵硬，模型会优先回归自然表达。",
       "card.status": "写作助手功能：已启用 · 自动分析：开",
@@ -190,13 +200,21 @@ window.__ModuleLoader__.load({
       "tool.novel_sentence_config.desc": "View / change all switches (AI channel).",
       "tool.novel_style_check.desc": "Style similarity of this chapter vs the rest of the book.",
       "tool.novel_plot.desc": "Track / close plot hooks; check before continuing.",
-      "plot.pathLabel": "Storage",
-      "plot.pathUnknown": "Located in .novel-writer under the library root (one JSON per book). Ask the AI to run novel_plot once to show the real path.",
+      "tool.novel_settings": "Settings novel_settings",
+      "tool.novel_summary": "Summaries novel_summary",
+      "tool.novel_continuity_check": "Continuity novel_continuity_check",
+      "tool.novel_settings.desc": "Four tables: characters / locations / items / timeline.",
+      "tool.novel_summary.desc": "Store / read per-chapter summaries.",
+      "tool.novel_continuity_check.desc": "Scan against settings, list contradiction candidates.",
+      "plot.pathLabel": "Data dir",
+      "plot.pathUnknown": "Located in .novel-writer under the library root (plots / settings / summaries / analysis). Ask the AI to run novel_plot or novel_settings once to show the real path.",
       "plot.open": "Open folder",
       "plot.copy": "Copy path",
       "plot.copied": "Copied",
       "plot.revealOk": "Opened",
       "plot.revealErr": "Open failed",
+      "panel.refresh": "Refresh",
+      "panel.refreshed": "Refreshed",
       "card.title": "Novel Writer (dsh-novel-writer)",
       "card.desc": "Sentence-pattern analysis: reads the rhythm of statements/environment/inner-thought/dialogue/questions etc. to help mimic the author's style. ⚠️ If mechanical imitation stiffens the prose, natural expression wins.",
       "card.status": "Writing assistant: ON · auto-analyze: ON",
@@ -214,7 +232,7 @@ window.__ModuleLoader__.load({
     }
 
     // ---- 工具清单（与宿主端 ALL_TOOLS 一致）----
-    var ALL_TOOLS = ["novel_books", "novel_chapters", "novel_read", "novel_keywords", "novel_new_chapter", "novel_import", "novel_sentence_analysis", "novel_sentence_config", "novel_style_check", "novel_plot"];
+    var ALL_TOOLS = ["novel_books", "novel_chapters", "novel_read", "novel_keywords", "novel_new_chapter", "novel_import", "novel_sentence_analysis", "novel_sentence_config", "novel_style_check", "novel_plot", "novel_settings", "novel_summary", "novel_continuity_check"];
 
     // ---- 与宿主端同步 ----
     var STATE_ROUTE = "/api/dsh-novel-writer/state";
@@ -248,6 +266,7 @@ window.__ModuleLoader__.load({
         saveFailed: false,
         panelOpen: false,
         plotsDir: "",
+        dataDir: "",
         revealMsg: "",
         revealErr: false,
         revealing: false
@@ -262,15 +281,35 @@ window.__ModuleLoader__.load({
           listeners.add(fn);
           return function () { listeners.delete(fn); };
         },
-        openPlotsDir: function () {
+        refresh: function () {
+          return fetchState().then(function (remote) {
+            controller.set({
+              enabled: !!remote.enabled,
+              autoAnalyze: !!remote.autoAnalyze,
+              tools: remote.tools || {},
+              plotsDir: remote.plotsDir || "",
+              dataDir: remote.dataDir || "",
+              file: remote.file || "",
+              hostOk: true,
+              loading: false,
+              revealMsg: t("panel.refreshed"),
+              revealErr: false
+            });
+            return remote;
+          }).catch(function () {
+            controller.set({ hostOk: false, loading: false, revealMsg: t("plot.revealErr") + "：宿主端不可达", revealErr: true });
+            return null;
+          });
+        },
+        openDataDir: function () {
           controller.set({ revealMsg: "", revealErr: false, revealing: true });
           fetch("/api/dsh-novel-writer/reveal", {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ target: "plots-dir" })
+            body: JSON.stringify({ target: "data-dir" })
           }).then(function (r) { return r.json(); }).then(function (data) {
             if (data.ok === true) {
-              controller.set({ plotsDir: data.path || controller.getSnapshot().plotsDir, revealMsg: t("plot.revealOk") + "：" + (data.path || ""), revealErr: false });
+              controller.set({ dataDir: data.path || controller.getSnapshot().dataDir, revealMsg: t("plot.revealOk") + "：" + (data.path || ""), revealErr: false });
             } else {
               controller.set({ revealMsg: data.error || t("plot.revealErr"), revealErr: true });
             }
@@ -281,8 +320,11 @@ window.__ModuleLoader__.load({
           });
         },
         copyPlotsPath: function () {
-          var dir = controller.getSnapshot().plotsDir;
-          if (dir === "") return;
+          var dir = controller.getSnapshot().dataDir || controller.getSnapshot().plotsDir;
+          if (dir === "") {
+            controller.set({ revealMsg: t("plot.pathUnknown"), revealErr: true });
+            return;
+          }
           var done = function () {
             controller.set({ revealMsg: t("plot.copied") + "：" + dir, revealErr: false });
           };
@@ -403,6 +445,11 @@ window.__ModuleLoader__.load({
           "div",
           { className: "nwPanelHeader" },
           react.createElement("div", { className: "nwPanelTitle" }, t("panel.title")),
+          react.createElement(
+            "button",
+            { type: "button", className: "nwRefresh", onClick: function () { props.controller.refresh(); } },
+            t("panel.refresh")
+          ),
           react.createElement("button", { type: "button", className: "nwClose", "aria-label": t("panel.close"), onClick: props.onClose }, "×")
         ),
         react.createElement(
@@ -459,20 +506,21 @@ window.__ModuleLoader__.load({
           var desc = t("tool." + name + ".desc");
           var plotExtra = null;
           if (name === "novel_plot") {
-            var pathText = state.plotsDir !== "" ? state.plotsDir : t("plot.pathUnknown");
+            var dir = state.dataDir || state.plotsDir;
+            var pathText = dir !== "" ? dir : t("plot.pathUnknown");
             plotExtra = react.createElement(
               "div",
               { className: "nwPlotBox" },
-              react.createElement("div", { className: "nwPlotPath", title: state.plotsDir !== "" ? state.plotsDir : "" }, t("plot.pathLabel") + "：" + pathText),
+              react.createElement("div", { className: "nwPlotPath", title: dir !== "" ? dir : "" }, t("plot.pathLabel") + "：" + pathText),
               react.createElement(
                 "div",
                 { className: "nwBtnGroup" },
                 react.createElement("button", {
-                  type: "button", className: "nwBtn", disabled: state.plotsDir === "" || state.revealing,
-                  onClick: function () { props.controller.openPlotsDir(); }
+                  type: "button", className: "nwBtn", disabled: state.revealing,
+                  onClick: function () { props.controller.openDataDir(); }
                 }, t("plot.open")),
                 react.createElement("button", {
-                  type: "button", className: "nwBtn", disabled: state.plotsDir === "",
+                  type: "button", className: "nwBtn",
                   onClick: function () { props.controller.copyPlotsPath(); }
                 }, t("plot.copy"))
               ),
@@ -647,6 +695,7 @@ window.__ModuleLoader__.load({
             autoAnalyze: !!remote.autoAnalyze,
             tools: remote.tools || {},
             plotsDir: remote.plotsDir || "",
+            dataDir: remote.dataDir || "",
             file: remote.file || "",
             source: "host",
             hostOk: true,

package/lib/index.js

@@ -572,12 +572,14 @@ const SENTENCE_ANALYSIS_DEFAULTS = Object.freeze({ enabled: true, autoAnalyze: t
 /** v0.7.0：全部工具清单（每个工具都有独立 UI 开关，默认全开）。 */
 const ALL_TOOLS = Object.freeze([
   "novel_books", "novel_chapters", "novel_read", "novel_keywords", "novel_new_chapter",
-  "novel_import", "novel_sentence_analysis", "novel_sentence_config", "novel_style_check", "novel_plot"
+  "novel_import", "novel_sentence_analysis", "novel_sentence_config", "novel_style_check", "novel_plot",
+  "novel_settings", "novel_summary", "novel_continuity_check"
 ]);
 const TOOL_LABELS = Object.freeze({
   novel_books: "作品列表", novel_chapters: "章节清单", novel_read: "阅读章节", novel_keywords: "关键词分析",
   novel_new_chapter: "新建章节", novel_import: "稿件导入", novel_sentence_analysis: "句式模式分析",
-  novel_sentence_config: "开关配置", novel_style_check: "风格自检", novel_plot: "伏笔登记"
+  novel_sentence_config: "开关配置", novel_style_check: "风格自检", novel_plot: "伏笔登记",
+  novel_settings: "设定管理", novel_summary: "章节摘要", novel_continuity_check: "连贯性审计"
 });
 /** 工具级开关是否开启（默认开；state.tools[name] === false 时关闭）。 */
 function toolEnabled(state, name) {
@@ -738,12 +740,15 @@ function makeStateRoutes(allowLan, config) {
     const method = req.method ?? "GET";
     if (method === "GET") {
       const state = await readSentenceState();
-      const plotsRoot = config?.root ?? state.lastRoot;
+      // v0.8.0：修复 cordis 注入空字符串 root 时 ?? 不生效的问题
+      const root = (typeof config?.root === "string" && config.root.length > 0) ? config.root : state.lastRoot;
+      const dataDir = typeof root === "string" && root.length > 0 ? novelDataDir(root) : "";
       return writeJson(res, 200, {
         enabled: state.enabled,
         autoAnalyze: state.autoAnalyze,
         tools: state.tools ?? {},
-        plotsDir: typeof plotsRoot === "string" && plotsRoot.length > 0 ? join(plotsRoot, ".novel-writer") : "",
+        dataDir,
+        plotsDir: dataDir !== "" ? join(dataDir, "plots") : "",
         file: stateFilePath()
       });
     }
@@ -764,13 +769,14 @@ function makeStateRoutes(allowLan, config) {
     if ((req.method ?? "GET") !== "POST") return writeJson(res, 405, { error: "method not allowed" });
     const body = await readJsonBody(req);
     const target = body?.target;
-    if (target !== "plots-dir") return writeJson(res, 400, { error: 'unknown target (allowed: "plots-dir")' });
+    if (target !== "data-dir" && target !== "plots-dir") return writeJson(res, 400, { error: 'unknown target (allowed: "data-dir", "plots-dir")' });
     const state = await readSentenceState();
-    const plotsRoot = config?.root ?? state.lastRoot;
-    if (typeof plotsRoot !== "string" || plotsRoot.length === 0) {
-      return writeJson(res, 404, { error: "书库根未知：先在对话中调用一次 novel_plot（或配置插件 root），即可在 UI 中打开伏笔文件夹。" });
+    // v0.8.0：空字符串 root 回退 lastRoot
+    const root = (typeof config?.root === "string" && config.root.length > 0) ? config.root : state.lastRoot;
+    if (typeof root !== "string" || root.length === 0) {
+      return writeJson(res, 404, { error: "书库根未知：先在对话中调用一次 novel_plot / novel_settings（或配置插件 root），即可在 UI 中打开数据文件夹。" });
     }
-    const dir = join(plotsRoot, ".novel-writer");
+    const dir = target === "data-dir" ? novelDataDir(root) : join(novelDataDir(root), "plots");
     try {
       await mkdir(dir, { recursive: true });
     } catch { /* 目录已存在或创建失败都不阻塞打开 */ }
@@ -1009,7 +1015,19 @@ function registerNovelSentenceAnalysis(ctx, config) {
             }
           },
           guidance: { type: "string" },
-          fingerprint: { type: "string" }
+          fingerprint: { type: "string" },
+          density: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              actionVerbsPer1000: { type: "number" },
+              actionChainRatio: { type: "number" },
+              actionChainExamples: { type: "array", items: { type: "string" } },
+              objectNounsPer1000: { type: "number" },
+              sensePer1000: { type: "number" },
+              sense: { type: "object", additionalProperties: true }
+            }
+          }
         },
         required: ["book", "scope", "enabled", "totalChars", "totalSentences"]
       },
@@ -1063,8 +1081,8 @@ function registerNovelSentenceAnalysis(ctx, config) {
           message: "句式模式分析当前已关闭。可在 Web GUI 侧边栏「句式分析」面板开启，或用 novel_sentence_config 设置 enabled=true。"
         };
       }
-      // v0.6.0：分析结果缓存 + 报告导出（用户建议的临时文件方案）
-      const cacheDir = join(homedir(), ".dsh", "dsh-novel-writer", "cache");
+      // v0.8.0：分析结果缓存 + 报告导出（书库统一数据目录 <root>/.novel-writer/analysis）
+      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");
       if (!fresh) {
@@ -1281,16 +1299,33 @@ function registerNovelStyleCheck(ctx, config) {
 }
 
 /** v0.6.0 伏笔/剧情线登记表。 */
+/** v0.8.0：书库统一数据目录（<root>/.novel-writer/），子目录：plots/settings/summaries/analysis/audits。 */
+function novelDataDir(root) {
+  return join(root, ".novel-writer");
+}
 function plotsFile(root, book) {
-  return join(root, ".novel-writer", sanitizeSegment(book, "book") + ".json");
+  return join(novelDataDir(root), "plots", sanitizeSegment(book, "book") + ".json");
+}
+function legacyPlotsFile(root, book) {
+  return join(novelDataDir(root), sanitizeSegment(book, "book") + ".json");
 }
 async function readPlots(root, book) {
+  const file = plotsFile(root, book);
+  let parsed = null;
   try {
-    const parsed = JSON.parse(await readFile(plotsFile(root, book), "utf8"));
-    return Array.isArray(parsed.entries) ? parsed.entries : [];
-  } catch {
-    return [];
+    parsed = JSON.parse(await readFile(file, "utf8"));
+  } catch { /* 新位置不存在 */ }
+  if (!parsed) {
+    // v0.8.0 迁移：旧位置 <root>/.novel-writer/<书>.json → plots/<书>.json
+    try {
+      parsed = JSON.parse(await readFile(legacyPlotsFile(root, book), "utf8"));
+      if (Array.isArray(parsed?.entries)) {
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(parsed, null, 2), "utf8");
+      }
+    } catch { /* 无旧文件 */ }
   }
+  return Array.isArray(parsed?.entries) ? parsed.entries : [];
 }
 async function writePlots(root, book, entries) {
   const file = plotsFile(root, book);
@@ -1298,16 +1333,446 @@ async function writePlots(root, book, entries) {
   await writeFile(file, JSON.stringify({ book, entries }, null, 2), "utf8");
 }
 
+/** v0.8.0：从伏笔内容提取 2-4 字中文关键词（用于 scan 提及检测），跳过停用字。 */
+function plotKeywords(content) {
+  const text = String(content).replace(/[^\u4e00-\u9fff]/g, "");
+  const stop = new Set("的了是在我有和就都不一一个这那与及或但是因为所以如果然后而且比如比如什么怎么自己她们他们你们我们咱们没有不是别莫未".split(""));
+  const keywords = [];
+  for (const length of [4, 3, 2]) {
+    for (let i = 0; i + length <= text.length; i += 1) {
+      const sub = text.slice(i, i + length);
+      const nonStop = [...sub].filter((ch) => !stop.has(ch)).length;
+      if (nonStop >= Math.ceil(length * 0.6)) keywords.push(sub);
+    }
+  }
+  // 去重并按长度降序，最多取 8 个
+  return [...new Set(keywords)].sort((a, b) => b.length - a.length).slice(0, 8);
+}
+
 /** v0.7.0：清洗伏笔条目为 lossless JSON（剔除 undefined 字段，DSH 通道要求）。 */
 function normalizePlotEntry(entry) {
   const out = { id: entry.id, content: entry.content, status: entry.status };
-  if (entry.chapter !== void 0 && entry.chapter !== null) out.chapter = String(entry.chapter);
-  if (entry.note !== void 0 && entry.note !== null) out.note = String(entry.note);
+  for (const key of ["chapter", "note", "payoffCondition", "lastMentioned", "type", "priority"]) {
+    if (entry[key] !== void 0 && entry[key] !== null) out[key] = String(entry[key]);
+  }
+  for (const key of ["relatedCharacters", "locations", "mentionedIn"]) {
+    if (Array.isArray(entry[key])) out[key] = entry[key].map((x) => String(x));
+  }
   if (entry.createdAt !== void 0) out.createdAt = entry.createdAt;
   if (entry.updatedAt !== void 0) out.updatedAt = entry.updatedAt;
   return out;
 }
 
+
+/** v0.8.0 设定管理（四张表：人物/地点/道具/时间线）。 */
+function settingsFile(root, book) {
+  return join(novelDataDir(root), "settings", sanitizeSegment(book, "book") + ".json");
+}
+async function readSettings(root, book) {
+  try {
+    const parsed = JSON.parse(await readFile(settingsFile(root, book), "utf8"));
+    return {
+      characters: Array.isArray(parsed.characters) ? parsed.characters : [],
+      locations: Array.isArray(parsed.locations) ? parsed.locations : [],
+      items: Array.isArray(parsed.items) ? parsed.items : [],
+      timeline: Array.isArray(parsed.timeline) ? parsed.timeline : []
+    };
+  } catch {
+    return { characters: [], locations: [], items: [], timeline: [] };
+  }
+}
+async function writeSettings(root, book, data) {
+  const file = settingsFile(root, book);
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, JSON.stringify({ book, ...data }, null, 2), "utf8");
+}
+function normalizeSettingEntry(entry) {
+  const out = { name: String(entry.name) };
+  for (const key of ["description", "traits", "relationships", "firstSeen", "notes", "owner", "status", "lastSeen", "day", "event", "chapter"]) {
+    if (entry[key] !== void 0 && entry[key] !== null) out[key] = String(entry[key]);
+  }
+  for (const key of ["alias"]) {
+    if (Array.isArray(entry[key])) out[key] = entry[key].map(String);
+  }
+  return out;
+}
+function registerNovelSettings(ctx, config) {
+  ctx.tools.register({
+    name: "novel_settings",
+    description: "设定管理（四张表）：人物卡/地点卡/道具清单/时间线。list/add/update/delete 按 category 维护；scan 用规则扫描章节提取人物/道具候选供登记。用于续写时保持人物性格、环境、道具与时间线一致。",
+    parameters: {
+      type: "object",
+      properties: {
+        book: { type: "string", description: "书名。" },
+        category: { type: "string", enum: ["character", "location", "item", "timeline"], description: "表类别（list/add/update/delete/scan 需要）。" },
+        action: { type: "string", enum: ["list", "add", "update", "delete", "scan"], description: "list=查看（默认）；add=登记；update=修改；delete=删除；scan=扫描章节提取候选。" },
+        name: { type: "string", description: "条目名（人物名/地名/道具名；timeline 用 day 字段）。" },
+        description: { type: "string", description: "可选：描述。" },
+        traits: { type: "string", description: "character 专用：性格/外貌特征。" },
+        relationships: { type: "string", description: "character 专用：人际关系。" },
+        alias: { type: "array", items: { type: "string" }, description: "character 专用：别名。" },
+        firstSeen: { type: "string", description: "可选：首次出现的章节。" },
+        owner: { type: "string", description: "item 专用：当前持有者。" },
+        status: { type: "string", description: "item 专用：状态（如 在琉璃处/已遗失）。" },
+        lastSeen: { type: "string", description: "item 专用：最近出现的章节。" },
+        day: { type: "string", description: "timeline 专用：时间点（如 穿越第1天/考核前10日）。" },
+        event: { type: "string", description: "timeline 专用：事件。" },
+        chapter: { type: "string", description: "timeline 专用：对应章节。" },
+        notes: { type: "string", description: "可选：备注。" },
+        root: { type: "string", description: "章节库根目录。默认取会话工作区。" }
+      },
+      required: ["book"],
+      additionalProperties: false
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          book: { type: "string" },
+          category: { type: "string" },
+          action: { type: "string" },
+          characters: { type: "array", items: { type: "object", additionalProperties: true } },
+          locations: { type: "array", items: { type: "object", additionalProperties: true } },
+          items: { type: "array", items: { type: "object", additionalProperties: true } },
+          timeline: { type: "array", items: { type: "object", additionalProperties: true } },
+          candidates: { type: "array", items: { type: "string" } },
+          message: { type: "string" }
+        },
+        required: ["book", "category", "action"]
+      },
+      render: (_args, value) => {
+        const lines = [`<path>novels/${value.book}</path>`, "<type>novel-settings</type>", "<content>", ""];
+        if (value.message) lines.push(value.message);
+        const categoryLabel = { character: "人物卡", location: "地点卡", item: "道具清单", timeline: "时间线" }[value.category] ?? value.category;
+        const list = value.characters ?? value.locations ?? value.items ?? value.timeline ?? [];
+        lines.push(`${categoryLabel}（${list.length} 条）：`);
+        for (const e of list) {
+          const extra = [e.traits, e.description, e.relationships, e.owner, e.status, e.lastSeen, e.day + (e.event ? " " + e.event : "")].filter(Boolean).join(" | ");
+          lines.push(`  - ${e.name}${extra ? "：" + extra : ""}${e.chapter ? "（" + e.chapter + "）" : ""}`);
+        }
+        if (Array.isArray(value.candidates) && value.candidates.length > 0) {
+          lines.push("", "扫描候选（供登记）：");
+          for (const cand of value.candidates) lines.push("  ? " + cand);
+        }
+        lines.push("", "</content>");
+        return [{ type: "text", text: lines.join("\n") }];
+      }
+    },
+    async execute(args, exec) {
+      const book = sanitizeSegment(requiredString(args, "book"), "book");
+      const category = ["character", "location", "item", "timeline"].includes(args?.category) ? args.category : "character";
+      const action = ["add", "update", "delete", "scan"].includes(args?.action) ? args.action : "list";
+      const root = resolveRoot(config, args, exec);
+      const data = await readSettings(root, book);
+      const now = new Date().toISOString();
+      let message = "";
+      const categoryLabel = { character: "人物卡", location: "地点卡", item: "道具清单", timeline: "时间线" }[category] ?? category;
+      const listKey = { character: "characters", location: "locations", item: "items", timeline: "timeline" }[category];
+      const list = data[listKey];
+      if (action === "add") {
+        const name = optionalString(args, "name") ?? optionalString(args, "day");
+        assert(name !== void 0, "novel_settings add 需要 name（timeline 用 day）参数");
+        const entry = { name };
+        for (const key of ["description", "traits", "relationships", "firstSeen", "owner", "status", "lastSeen", "event", "chapter", "notes"]) {
+          if (args?.[key] !== void 0) entry[key] = String(args[key]);
+        }
+        if (Array.isArray(args?.alias)) entry.alias = args.alias.map(String);
+        list.push(entry);
+        message = `已登记 ${categoryLabel}：${name}`;
+        await writeSettings(root, book, data);
+      } else if (action === "update" || action === "delete") {
+        const name = optionalString(args, "name") ?? optionalString(args, "day");
+        assert(name !== void 0, `novel_settings ${action} 需要 name（timeline 用 day）参数`);
+        const index = list.findIndex((e) => e.name === name);
+        assert(index !== -1, `${categoryLabel}中不存在「${name}」`);
+        if (action === "delete") {
+          list.splice(index, 1);
+          message = `已删除 ${categoryLabel}：${name}`;
+        } else {
+          for (const key of ["description", "traits", "relationships", "firstSeen", "owner", "status", "lastSeen", "event", "chapter", "notes"]) {
+            if (args?.[key] !== void 0) list[index][key] = String(args[key]);
+          }
+          if (Array.isArray(args?.alias)) list[index].alias = args.alias.map(String);
+          message = `已更新 ${categoryLabel}：${name}`;
+        }
+        await writeSettings(root, book, data);
+      } else if (action === "scan") {
+        // 规则候选：人物（XX说/道/问 高频 2-3 字），道具（含 owner 的常见物件词）
+        const dir = bookDir(root, book);
+        const chapters = await scanChapters(dir);
+        let text = "";
+        for (const chapter of chapters) text += await readTextFile(join(dir, chapter.file), exec);
+        const nameCounts = new Map();
+        for (const m of text.matchAll(/([\u4e00-\u9fff]{2,3})(?:说|道|问|喊|叫|笑|叹|点头|摇头)/g)) {
+          const n = m[1];
+          if (!["那个", "这个", "什么", "怎么", "自己", "她们", "他们", "你们", "我们"].includes(n)) {
+            nameCounts.set(n, (nameCounts.get(n) ?? 0) + 1);
+          }
+        }
+        const known = new Set(list.map((e) => e.name));
+        const candidates = [...nameCounts.entries()].filter(([n, count]) => count >= 2 && !known.has(n)).map(([n, count]) => n + "（" + count + "次）").slice(0, 15);
+        message = `扫描全书，提取 ${candidates.length} 个人物候选`;
+        const result = { book, category, action, candidates, message };
+        if (category === "character") result.characters = data.characters.map(normalizeSettingEntry);
+        if (category === "location") result.locations = data.locations.map(normalizeSettingEntry);
+        if (category === "item") result.items = data.items.map(normalizeSettingEntry);
+        if (category === "timeline") result.timeline = data.timeline.map(normalizeSettingEntry);
+        return result;
+      }
+      const result = { book, category, action };
+      result.characters = data.characters.map(normalizeSettingEntry);
+      result.locations = data.locations.map(normalizeSettingEntry);
+      result.items = data.items.map(normalizeSettingEntry);
+      result.timeline = data.timeline.map(normalizeSettingEntry);
+      if (message) result.message = message;
+      return result;
+    }
+  });
+}
+
+/** v0.8.0 章节摘要（模型生成内容，插件负责存储/读取）。 */
+function summariesFile(root, book) {
+  return join(novelDataDir(root), "summaries", sanitizeSegment(book, "book") + ".json");
+}
+async function readSummaries(root, book) {
+  try {
+    const parsed = JSON.parse(await readFile(summariesFile(root, book), "utf8"));
+    return Array.isArray(parsed.summaries) ? parsed.summaries : [];
+  } catch {
+    return [];
+  }
+}
+function registerNovelSummary(ctx, config) {
+  ctx.tools.register({
+    name: "novel_summary",
+    description: "章节摘要（模型生成、插件存储）：阅读章节后把摘要存盘，续写长书时先读摘要回忆剧情，避免全文重读。add/update/get/list/delete 按章节管理。",
+    parameters: {
+      type: "object",
+      properties: {
+        book: { type: "string", description: "书名。" },
+        action: { type: "string", enum: ["list", "get", "add", "update", "delete"], description: "list=全部摘要（默认）；get=取某章；add=新增/覆盖摘要；update=修改；delete=删除。" },
+        chapter: { type: "string", description: "章节标识（章号/文件名/标题）。" },
+        summary: { type: "string", description: "add/update 时：本章摘要（200-500 字，覆盖剧情走向/关键事件/结尾状态）。" },
+        keyEvents: { type: "array", items: { type: "string" }, description: "可选：关键事件列表。" },
+        keySettings: { type: "array", items: { type: "string" }, description: "可选：本章出现的关键设定/信息。" },
+        root: { type: "string", description: "章节库根目录。默认取会话工作区。" }
+      },
+      required: ["book"],
+      additionalProperties: false
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          book: { type: "string" },
+          action: { type: "string" },
+          summaries: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                chapter: { type: "string" },
+                summary: { type: "string" },
+                keyEvents: { type: "array", items: { type: "string" } },
+                keySettings: { type: "array", items: { type: "string" } },
+                updatedAt: { type: "string" }
+              },
+              required: ["chapter", "summary"]
+            }
+          },
+          message: { type: "string" }
+        },
+        required: ["book", "action", "summaries"]
+      },
+      render: (_args, value) => {
+        const lines = [`<path>novels/${value.book}</path>`, "<type>novel-summary</type>", "<content>", ""];
+        if (value.message) lines.push(value.message);
+        for (const s of value.summaries) {
+          lines.push(`【${s.chapter}】`);
+          lines.push(s.summary);
+          if (Array.isArray(s.keyEvents) && s.keyEvents.length > 0) lines.push("关键事件：" + s.keyEvents.join("；"));
+          if (Array.isArray(s.keySettings) && s.keySettings.length > 0) lines.push("关键设定：" + s.keySettings.join("；"));
+          lines.push("");
+        }
+        lines.push("</content>");
+        return [{ type: "text", text: lines.join("\n") }];
+      }
+    },
+    async execute(args, exec) {
+      const book = sanitizeSegment(requiredString(args, "book"), "book");
+      const action = ["get", "add", "update", "delete"].includes(args?.action) ? args.action : "list";
+      const root = resolveRoot(config, args, exec);
+      const summaries = await readSummaries(root, book);
+      const now = new Date().toISOString();
+      let message = "";
+      if (action !== "list") {
+        const chapterArg = optionalString(args, "chapter");
+        assert(chapterArg !== void 0, `novel_summary ${action} 需要 chapter 参数`);
+        const index = summaries.findIndex((s) => s.chapter === chapterArg);
+        if (action === "get") {
+          const found = index !== -1 ? [summaries[index]] : [];
+          return { book, action, summaries: found.map((s) => ({ ...s })) };
+        }
+        if (action === "delete") {
+          if (index !== -1) summaries.splice(index, 1);
+          message = `已删除 ${chapterArg} 的摘要`;
+        } else {
+          const summary = optionalString(args, "summary");
+          assert(summary !== void 0, `novel_summary ${action} 需要 summary 参数`);
+          const entry = {
+            chapter: chapterArg,
+            summary,
+            keyEvents: Array.isArray(args?.keyEvents) ? args.keyEvents.map(String) : void 0,
+            keySettings: Array.isArray(args?.keySettings) ? args.keySettings.map(String) : void 0,
+            updatedAt: now
+          };
+          if (index !== -1) summaries[index] = entry;
+          else summaries.push(entry);
+          message = `已保存 ${chapterArg} 的摘要`;
+        }
+        await mkdir(dirname(summariesFile(root, book)), { recursive: true });
+        await writeFile(summariesFile(root, book), JSON.stringify({ book, summaries }, null, 2), "utf8");
+      }
+      summaries.sort((a, b) => String(a.chapter).localeCompare(String(b.chapter)));
+      const clean = summaries.map((s) => {
+        const out = { chapter: String(s.chapter), summary: String(s.summary) };
+        if (Array.isArray(s.keyEvents)) out.keyEvents = s.keyEvents.map(String);
+        if (Array.isArray(s.keySettings)) out.keySettings = s.keySettings.map(String);
+        if (s.updatedAt !== void 0) out.updatedAt = s.updatedAt;
+        return out;
+      });
+      return { book, action, summaries: clean, ...message ? { message } : {} };
+    }
+  });
+}
+
+/** v0.8.0 连贯性审计：设定表 + 全书扫描 → 矛盾候选清单。 */
+function registerNovelContinuityCheck(ctx, config) {
+  ctx.tools.register({
+    name: "novel_continuity_check",
+    description: "连贯性审计：对照设定表扫描全书，输出矛盾候选（数字写法差异、登记人物在章节中的出现分布、设定别名变体），供模型判断并修正设定。",
+    parameters: {
+      type: "object",
+      properties: {
+        book: { type: "string", description: "书名。" },
+        root: { type: "string", description: "章节库根目录。默认取会话工作区。" }
+      },
+      required: ["book"],
+      additionalProperties: false
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          book: { type: "string" },
+          candidates: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                type: { type: "string" },
+                detail: { type: "string" },
+                chapters: { type: "array", items: { type: "string" } }
+              },
+              required: ["type", "detail"]
+            }
+          },
+          reportFile: { type: "string" },
+          advice: { type: "string" }
+        },
+        required: ["book", "candidates", "advice"]
+      },
+      render: (_args, value) => {
+        const lines = [`<path>novels/${value.book}</path>`, "<type>novel-continuity-check</type>", "<content>", ""];
+        if (value.candidates.length === 0) {
+          lines.push("未发现明显矛盾候选。");
+        } else {
+          lines.push(`矛盾候选 ${value.candidates.length} 条（供人工判断）：`);
+          for (const cand of value.candidates) {
+            lines.push(`  - [${cand.type}] ${cand.detail}${Array.isArray(cand.chapters) && cand.chapters.length > 0 ? "（涉及：" + cand.chapters.join("、") + "）" : ""}`);
+          }
+        }
+        lines.push("", "【建议】" + value.advice, "", "</content>");
+        return [{ type: "text", text: lines.join("\n") }];
+      }
+    },
+    async execute(args, exec) {
+      const book = sanitizeSegment(requiredString(args, "book"), "book");
+      const root = resolveRoot(config, args, exec);
+      const dir = bookDir(root, book);
+      const chapters = await scanChapters(dir);
+      assert(chapters.length > 0, `book "${book}" has no chapter files`);
+      const settings = await readSettings(root, book);
+      const chapterTexts = [];
+      for (const chapter of chapters) {
+        chapterTexts.push({ file: chapter.file, text: await readTextFile(join(dir, chapter.file), exec) });
+      }
+      const candidates = [];
+      // 1) 数字写法差异（亿/千万/百万 口径）
+      const numberForms = new Map();
+      for (const { file, text } of chapterTexts) {
+        for (const m of text.matchAll(/\d+\s*(?:万亿|千万|百万|十万|[万亿千百])|[一二三四五六七八九十]{1,2}(?:万亿|千万|百万|十万|[万亿千百])/g)) {
+          const form = m[0].replace(/\s/g, "");
+          // 只保留"带单位"的数量表达；过滤纯数字（五十/二十九）、连词（万一）、约数（七八）
+          if (!/[万亿千百]$/.test(form)) continue;
+          if (/^[十百千万亿]$/.test(form)) continue;
+          if (!numberForms.has(form)) numberForms.set(form, []);
+          if (!numberForms.get(form).includes(file)) numberForms.get(form).push(file);
+        }
+      }
+      if (numberForms.size >= 2) {
+        const forms = [...numberForms.entries()];
+        for (let i = 0; i < forms.length; i += 1) {
+          for (let j = i + 1; j < forms.length; j += 1) {
+            const [a, ca] = forms[i];
+            const [b, cb] = forms[j];
+            if (a !== b) {
+              candidates.push({ type: "数字口径", detail: `「${a}」与「${b}」写法并存（可能指同一数量），请确认口径`, chapters: [...new Set(ca.concat(cb))] });
+            }
+          }
+        }
+      }
+      // 2) 登记人物出现分布（缺失章节提示）
+      for (const character of settings.characters) {
+        const absent = chapterTexts.filter(({ file, text }) => !text.includes(character.name)).map(({ file }) => file);
+        if (absent.length === chapterTexts.length) {
+          candidates.push({ type: "人物缺失", detail: `设定表人物「${character.name}」在全书章节中均未出现，请确认是否已出场`, chapters: absent });
+        } else if (absent.length > 0 && chapterTexts.length > 1) {
+          candidates.push({ type: "人物缺场", detail: `设定表人物「${character.name}」未出现在 ${absent.length} 个章节中（如无出场必要可忽略）`, chapters: absent.slice(0, 5) });
+        }
+        if (Array.isArray(character.alias) && character.alias.length > 0) {
+          const used = chapterTexts.filter(({ text }) => character.alias.some((al) => text.includes(al))).map(({ file }) => file);
+          if (used.length === 0) {
+            candidates.push({ type: "别名未用", detail: `人物「${character.name}」登记的别名 ${character.alias.join("、")} 在全书未出现`, chapters: [] });
+          }
+        }
+      }
+      // 3) 设定表重复条目
+      for (const key of ["characters", "locations", "items"]) {
+        const names = settings[key].map((e) => e.name);
+        const dup = names.filter((n, i) => names.indexOf(n) !== i);
+        if (dup.length > 0) candidates.push({ type: "设定重复", detail: `${key} 中存在重复条目：${[...new Set(dup)].join("、")}`, chapters: [] });
+      }
+      const advice = candidates.length === 0
+        ? "设定表与章节基本一致。建议继续登记新章节出现的新人物/新地点。"
+        : "以上为规则候选，请逐条人工判断：确认为矛盾则更新设定表（novel_settings update）或修正正文；非矛盾（如回忆/刻意缺席）可忽略。";
+      // 落盘审计报告
+      const auditDir = join(novelDataDir(root), "audits");
+      const reportFile = join(auditDir, book + "-" + createHash("sha1").update(book + "|" + chapters.map((x) => x.file).join(",")).digest("hex").slice(0, 16) + ".json");
+      try {
+        await mkdir(auditDir, { recursive: true });
+        await writeFile(reportFile, JSON.stringify({ book, generatedAt: new Date().toISOString(), candidates }, null, 2), "utf8");
+      } catch { /* 落盘失败不阻塞 */ }
+      return { book, candidates, reportFile, advice };
+    }
+  });
+}
+
 function registerNovelPlot(ctx, config) {
   ctx.tools.register({
     name: "novel_plot",
@@ -1316,11 +1781,16 @@ function registerNovelPlot(ctx, config) {
       type: "object",
       properties: {
         book: { type: "string", description: "书名。" },
-        action: { type: "string", enum: ["list", "add", "update", "done", "delete"], description: "list=查看（默认）；add=登记新伏笔；update=修改；done=标记已回收；delete=删除。" },
+        action: { type: "string", enum: ["list", "add", "update", "done", "delete", "scan"], description: "list=查看（默认）；add=登记新伏笔；update=修改；done=标记已回收；delete=删除；scan=扫描章节文本，自动更新每条 open 伏笔的提及章节（mentionedIn/lastMentioned）。" },
         id: { type: "string", description: "伏笔 id（update/done/delete 时需要）。" },
         content: { type: "string", description: "add/update 时：伏笔内容描述。" },
         chapter: { type: "string", description: "可选：伏笔出现的章节。" },
         note: { type: "string", description: "可选：备注（如何回收/何时回收）。" },
+        type: { type: "string", enum: ["剧情", "设定", "道具", "人物", "其他"], description: "可选：伏笔类型（add/update）。" },
+        priority: { type: "string", enum: ["high", "medium", "low"], description: "可选：优先级（add/update）。" },
+        relatedCharacters: { type: "array", items: { type: "string" }, description: "可选：关联人物（add/update）。" },
+        locations: { type: "array", items: { type: "string" }, description: "可选：关联地点（add/update）。" },
+        payoffCondition: { type: "string", description: "可选：回收条件（add/update）。" },
         root: { type: "string", description: "章节库根目录。默认取会话工作区。" }
       },
       required: ["book"],
@@ -1343,6 +1813,13 @@ function registerNovelPlot(ctx, config) {
                 content: { type: "string" },
                 chapter: { type: "string" },
                 note: { type: "string" },
+                type: { type: "string" },
+                priority: { type: "string" },
+                relatedCharacters: { type: "array", items: { type: "string" } },
+                locations: { type: "array", items: { type: "string" } },
+                payoffCondition: { type: "string" },
+                mentionedIn: { type: "array", items: { type: "string" } },
+                lastMentioned: { type: "string" },
                 status: { type: "string", enum: ["open", "done"] },
                 createdAt: { type: "string" },
                 updatedAt: { type: "string" }
@@ -1361,7 +1838,10 @@ function registerNovelPlot(ctx, config) {
         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 : ""}`);
+        for (const e of open) {
+          const tags = [e.type, e.priority, e.chapter ? "出自 " + e.chapter : "", e.payoffCondition ? "回收:" + e.payoffCondition : "", e.lastMentioned ? "最近提及:" + e.lastMentioned : ""].filter(Boolean).join(" | ");
+          lines.push(`  - [${e.id}] ${e.content}${tags ? "（" + tags + "）" : ""}${e.note ? "｜" + e.note : ""}`);
+        }
         if (done.length > 0) {
           lines.push(`已回收 ${done.length} 条：`);
           for (const e of done) lines.push(`  - [${e.id}] ${e.content}`);
@@ -1373,7 +1853,7 @@ function registerNovelPlot(ctx, config) {
     async execute(args, exec) {
       await assertToolEnabled(config, "novel_plot");
       const book = sanitizeSegment(requiredString(args, "book"), "book");
-      const action = ["add", "update", "done", "delete"].includes(args?.action) ? args.action : "list";
+      const action = ["add", "update", "done", "delete", "scan"].includes(args?.action) ? args.action : "list";
       const root = resolveRoot(config, args, exec);
       const entries = await readPlots(root, book);
       const now = new Date().toISOString();
@@ -1382,8 +1862,48 @@ function registerNovelPlot(ctx, config) {
         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 });
+        const entry = {
+          id,
+          content,
+          chapter: optionalString(args, "chapter"),
+          note: optionalString(args, "note"),
+          type: ["剧情", "设定", "道具", "人物", "其他"].includes(args?.type) ? args.type : void 0,
+          priority: ["high", "medium", "low"].includes(args?.priority) ? args.priority : void 0,
+          relatedCharacters: Array.isArray(args?.relatedCharacters) ? args.relatedCharacters.map(String) : void 0,
+          locations: Array.isArray(args?.locations) ? args.locations.map(String) : void 0,
+          payoffCondition: optionalString(args, "payoffCondition"),
+          status: "open",
+          createdAt: now,
+          updatedAt: now
+        };
+        entries.push(entry);
         message = `已登记伏笔 #${id}`;
+      } else if (action === "scan") {
+        // v0.8.0：扫描章节文本，更新 open 伏笔的提及章节
+        const scanChapter = optionalString(args, "chapter");
+        const dir = bookDir(root, book);
+        const chapters = await scanChapters(dir);
+        assert(chapters.length > 0, `book "${book}" has no chapter files`);
+        const targets = scanChapter !== void 0 ? [findChapter(chapters, scanChapter)] : chapters;
+        assert(targets[0] !== void 0, `cannot find chapter "${scanChapter}"`);
+        let mentioned = 0;
+        for (const chapter of targets) {
+          const chapterText = await readTextFile(join(dir, chapter.file), exec);
+          for (const entry of entries) {
+            if (entry.status !== "open") continue;
+            const keywords = plotKeywords(entry.content);
+            if (keywords.length > 0 && keywords.some((k) => chapterText.includes(k))) {
+              const mentionedIn = Array.isArray(entry.mentionedIn) ? entry.mentionedIn : [];
+              if (!mentionedIn.includes(chapter.file)) {
+                entry.mentionedIn = mentionedIn.concat(chapter.file);
+                entry.lastMentioned = chapter.file;
+                entry.updatedAt = now;
+                mentioned += 1;
+              }
+            }
+          }
+        }
+        message = `扫描 ${targets.length} 章，更新 ${mentioned} 条伏笔的提及记录`;
       } else if (action === "update" || action === "done" || action === "delete") {
         const id = optionalString(args, "id");
         assert(id !== void 0, `novel_plot ${action} 需要 id 参数`);
@@ -1400,6 +1920,11 @@ function registerNovelPlot(ctx, config) {
           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);
+          if (["剧情", "设定", "道具", "人物", "其他"].includes(args?.type)) entries[index].type = args.type;
+          if (["high", "medium", "low"].includes(args?.priority)) entries[index].priority = args.priority;
+          if (Array.isArray(args?.relatedCharacters)) entries[index].relatedCharacters = args.relatedCharacters.map(String);
+          if (Array.isArray(args?.locations)) entries[index].locations = args.locations.map(String);
+          if (args?.payoffCondition !== void 0) entries[index].payoffCondition = String(args.payoffCondition);
           entries[index].updatedAt = now;
           message = `已更新伏笔 #${id}`;
         }
@@ -1721,7 +2246,8 @@ function registerNovelKeywords(ctx, config) {
               },
               required: ["word", "count", "kind"]
             }
-          }
+          },
+          reportFile: { type: "string" }
         },
         required: ["book", "scope", "totalChars", "keywords"]
       },
@@ -1753,12 +2279,21 @@ function registerNovelKeywords(ctx, config) {
       for (const chapter of selected) {
         text += await readTextFile(join(dir, chapter.file), exec);
       }
-      return {
+      const result = {
         book,
         scope,
         totalChars: text.length,
         keywords: extractKeywords(text, top)
       };
+      // v0.8.0：关键词结果落盘到书库统一数据目录（与设定同文件夹）
+      try {
+        const reportDir = join(novelDataDir(root), "analysis");
+        const reportFile = join(reportDir, book + "-keywords-" + createHash("sha1").update(book + "|" + scope + "|" + text.length).digest("hex").slice(0, 12) + ".json");
+        await mkdir(reportDir, { recursive: true });
+        await writeFile(reportFile, JSON.stringify({ ...result, generatedAt: new Date().toISOString() }, null, 2), "utf8");
+        result.reportFile = reportFile;
+      } catch { /* 落盘失败不阻塞 */ }
+      return result;
     }
   });
 }
@@ -1864,8 +2399,9 @@ const WORKFLOW_TEXT = [
   "6. 续写 / 辅助写作时：先通读最近的章节（保持人物、时间线、情节伏笔、文风与已提炼的关键词一致），再动笔。",
   "   新章节写入 novels/<书名>/ 文件夹：用 novel_new_chapter 创建章节文件，或直接用 write 工具写文件。",
   "7. 每次续写前先简述：上一章结尾状态 → 本章目标 → 写作计划，再给出正文。",
-  "8. 工具链提示：续写/分析前可用 novel_plot 查看未回收伏笔，保持剧情连贯；写完新章节可用 novel_style_check 做风格自检（相似度+偏差清单）；",
-  "   novel_sentence_analysis 结果自动缓存到 ~/.dsh/dsh-novel-writer/cache/（返回值含 reportFile 字段），重复分析直接命中缓存，需要重算时传 fresh=true。"
+  "8. 工具链提示：续写/分析前可用 novel_plot 查看未回收伏笔（open 条目，含类型/优先级/提及章节）；写完新章节可用 novel_style_check 做风格自检（相似度+偏差+细节密度），novel_plot scan 自动更新伏笔提及记录；",
+  "   novel_settings 维护四张设定表（人物/地点/道具/时间线），novel_summary 保存每章摘要（长书续写先读摘要再按需细读），novel_continuity_check 输出设定矛盾候选；",
+  "   novel_sentence_analysis 结果自动缓存到书库数据目录 <root>/.novel-writer/analysis/（reportFile 字段），novel_keywords 结果同样落盘，需要重算时传 fresh=true。"
 ].join("\n");
 
 function apply(ctx, config = {}) {
@@ -1879,6 +2415,9 @@ function apply(ctx, config = {}) {
   registerNovelSentenceConfig(ctx, config);
   registerNovelStyleCheck(ctx, config);
   registerNovelPlot(ctx, config);
+  registerNovelSettings(ctx, config);
+  registerNovelSummary(ctx, config);
+  registerNovelContinuityCheck(ctx, config);
   // 注册 UI 开关状态路由（可选注入，headless 自动跳过）
   registerStyleConfigRoute(ctx, config);
   ctx.systemPrompt.section({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-novel-writer",
-  "version": "0.7.0",
-  "description": "小说写作助手插件（v0.7.0）：10 个工具全部带独立 UI 开关（侧边栏「写作助手功能」面板统一管理）、句式分析/风格自检/伏笔登记/批量导入、分析缓存与报告导出、情感词典去噪、编码探测",
+  "version": "0.8.1",
+  "description": "小说写作助手插件（v0.8.1 记忆层）：四张设定表（人物/地点/道具/时间线）、章节摘要、连贯性审计、伏笔字段化+提及追踪、细节密度指标、统一数据目录（plots/settings/summaries/analysis/audits）、UI 路径可视化修复",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -36,4 +36,4 @@
   },
   "dependencies": {},
   "license": "MIT"
-}
+}

package/skills/novel-writing/SKILL.md

@@ -29,6 +29,17 @@
 - 写完新章节后调用 `novel_style_check`：本章 vs 全书其余章节 → 相似度 + 偏差清单 + 建议；
 - 偏差明显时主动调整文风（对话/心理占比、句长、情绪），防止漂移。
 
+## 设定管理（v0.8.0 新增）
+
+- §BT§novel_settings§BT§：四张表（人物卡/地点卡/道具清单/时间线），list/add/update/delete/scan；
+- 登记新人物/新地点/道具去向，时间线记录"第几天/倒计时"；
+- §BT§novel_continuity_check§BT§：续写前跑一次，输出设定矛盾候选（数字口径/人物缺场/别名/重复）。
+
+## 章节摘要（v0.8.0 新增）
+
+- 读完每章后调用 §BT§novel_summary§BT§ add 保存 200-500 字摘要 + 关键事件 + 关键设定；
+- 续写长书时先 §BT§novel_summary§BT§ list 回忆剧情，再按需 §BT§novel_read§BT§ 细读。
+
 ## 伏笔登记表（v0.6.0 新增）
 
 - `novel_plot`：list / add / update / done / delete 管理伏笔与剧情钩子；

package/test/e2e-test.mjs

@@ -21,7 +21,7 @@ apply(ctx, { root: testRoot, sentenceAnalysis: { enabled: true, autoAnalyze: tru
 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");
+if (names.length !== 13) throw new Error("expected 13 tools (v0.8.0)");
 
 const exec = { agent: { session: { header: { cwd: testRoot } } } };
 
@@ -54,7 +54,7 @@ console.log("DSH schema 规则检查: 全部通过");
 
 // 1) 分析 + 缓存（第一次 miss，第二次 hit）
 const first = await defs.novel_sentence_analysis.execute({ book: "测试" }, exec);
-console.log("首次分析 cache:", first.cache, "| reportFile:", first.reportFile?.includes("cache"));
+console.log("首次分析 cache:", first.cache, "| reportFile:", first.reportFile?.includes("analysis") ? "✓ 新目录" : "✗ " + first.reportFile);
 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);
@@ -79,7 +79,7 @@ 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");
+const plotFile = join(testRoot, ".novel-writer", "plots", "测试.json");
 if (!existsSync(plotFile)) throw new Error("plot file not persisted");
 console.log("伏笔文件:", plotFile, "存在 ✓");