dsh-novel-writer 0.6.0 → 0.7.0

package/INSTALL.md

@@ -1,11 +1,11 @@
-# dsh-novel-writer v0.6.0 — 安装指南
+# dsh-novel-writer v0.7.0 — 安装指南
 
-基于 v0.5.0 合并版的工程化升级。新增：分析缓存/报告导出、风格自检、伏笔登记表、关键词三字组与疑似人名、情感词典去噪、局域网开关可选放行。
+基于 v0.6.0 工程化版的 UI 升级：10 个工具全部带独立 UI 开关（侧边栏「写作助手功能」面板统一管理）。
 
 ```
 dsh-novel-writer-v0.6.0/
 ├── lib/
-│   ├── index.js        # 宿主端（10 个工具 + state 路由 + 缓存）
+│   ├── index.js        # 宿主端（10 个工具全开关 + state 路由 + 缓存）
 │   ├── analysis.js     # 句式模式分析引擎（含 fingerprintSimilarity / styleDiffs）
 │   └── client.js       # 浏览器端（侧边栏面板 + 设置页状态卡片）
 ├── test/               # 引擎 + client + e2e 测试

package/README.md

@@ -1,11 +1,11 @@
-# dsh-novel-writer — 小说写作助手插件（v0.6.0 工程化版）
+# dsh-novel-writer — 小说写作助手插件（v0.7.0：全工具 UI 开关）
 
 DSH（DeepSeek Harness）小说写作助手 bundle 插件。宿主端零第三方依赖（仅 Node 内置模块），
 浏览器端仅依赖 Web GUI 自带的 react。
-**v0.6.0 在 v0.5.0（合并版）基础上完成工程化升级**：分析缓存与报告导出、风格自检、伏笔登记表、
+**v0.7.0 在 v0.6.0 基础上为全部 10 个工具增加独立 UI 开关（侧边栏「写作助手功能」面板统一管理）**：分析缓存与报告导出、风格自检、伏笔登记表、
 关键词三字组/疑似人名、情感词典去噪、祈使句与环境分类改进、局域网开关可选放行。
 
-## 工具清单（10 个）
+## 工具清单（10 个，全部带独立 UI 开关）
 
 | 工具 | 说明 |
 |---|---|
@@ -33,9 +33,10 @@ DSH（DeepSeek Harness）小说写作助手 bundle 插件。宿主端零第三
 8. **novel_import 异名同书提示**：scan 结果中组名包含/高重合时列出 `maybe` 字段，提示用 `book` 合并。
 9. **局域网开关可选放行**：config `allowLanState: true` 时，state 路由对同源局域网请求放行（默认仍仅 loopback）。
 
-## UI 开关（与 v0.5.0 相同，统一在一处）
+## UI 开关（v0.7.0：10 个工具全开关）
 
-- 唯一开关位置：侧边栏「句式分析」面板（总开关 enabled + 子开关 autoAnalyze）；
+- **唯一开关位置：侧边栏「写作助手功能」面板**——总开关（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 围栏，可选局域网放行）。
@@ -58,4 +59,11 @@ dsh plugin --profile web add D:/tools/dsh-novel-writer
       enabled: true
       autoAnalyze: true
     allowLanState: false   # true=局域网访问 GUI 时也允许保存开关
+
+## v0.7.0 更新内容
+
+- **10 个工具全部带独立 UI 开关**（侧边栏「写作助手功能」面板）：novel_books / novel_chapters / novel_read / novel_keywords / novel_new_chapter / novel_import / novel_sentence_analysis / novel_sentence_config / novel_style_check / novel_plot，默认全开；
+- UI 更名：侧边栏入口/面板/横幅由「句式分析」改为「写作助手功能」；设置页卡片同步；
+- novel_sentence_config 升级：支持 tools 参数（如 `{ novel_plot: false }`）与返回各工具开关状态；
+- 关闭的工具调用时返回明确提示（模型可见）。
 ```

package/lib/client.js

@@ -60,6 +60,24 @@ window.__ModuleLoader__.load({
       ".nwBadge{flex:none;border-radius:999px;padding:3px 10px;font-size:12px;font-weight:700;white-space:nowrap;letter-spacing:.5px}" +
       ".nwBadgeOn{background:#22c55e;color:#fff}" +
       ".nwBadgeOff{background:#e5e7eb;color:#6b7280}" +
+      ".nwSectionTitle{font-size:13px;font-weight:700;margin-top:6px}" +
+      ".nwToolsHint{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.5;margin:2px 0 4px}" +
+      ".nwToolRow{display:flex;align-items:center;gap:10px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-2);border-radius:10px;padding:8px 12px}" +
+      ".nwToolRowOn{border-color:rgba(34,197,94,.55);background:rgba(34,197,94,.05)}" +
+      ".nwToolLabel{flex:1;min-width:0;font-size:12px;line-height:1.4;color:var(--dsw-alias-label-primary)}" +
+      ".nwSwitchSmall{appearance:none;flex:none;width:40px;height:22px;border-radius:999px;border:2px solid #9ca3af;background:#9ca3af;cursor:pointer;position:relative;padding:0;transition:background .16s,border-color .16s}" +
+      ".nwSwitchSmallOn{background:#22c55e;border-color:#22c55e}" +
+      ".nwSwitchSmallKnob{position:absolute;top:2px;left:2px;width:14px;height:14px;border-radius:50%;background:#fff;transition:left .16s}" +
+      ".nwSwitchSmallOn .nwSwitchSmallKnob{left:20px}" +
+      ".nwToolDesc{font-size:11px;line-height:1.45;color:var(--dsw-alias-label-tertiary);margin-top:2px}" +
+      ".nwPlotBox{margin-top:6px;padding:6px 8px;background:rgba(127,127,127,.08);border-radius:8px}" +
+      ".nwPlotPath{font-size:11px;line-height:1.5;color:var(--dsw-alias-label-secondary);word-break:break-all}" +
+      ".nwBtnGroup{display:flex;gap:6px;margin-top:6px}" +
+      ".nwBtn{font-size:11px;line-height:1;padding:5px 10px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);cursor:pointer}" +
+      ".nwBtn:hover{background:var(--dsw-alias-bg-layer-2)}" +
+      ".nwBtn:disabled{opacity:.45;cursor:not-allowed}" +
+      ".nwPlotMsg{font-size:11px;line-height:1.5;color:var(--dsw-alias-label-secondary);margin-top:4px;word-break:break-all}" +
+      ".nwPlotErr{color:#ef4444}" +
       ".nwStatus{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.5;word-break:break-all}" +
       ".nwFoot{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.6;border-top:1px solid var(--dsw-alias-border-l2);padding-top:10px;margin-top:4px}";
     if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=\"dsh-novel-writer\"]") === null) {
@@ -72,61 +90,119 @@ window.__ModuleLoader__.load({
 
     // ---- 文案（zh / en）----
     var zh = {
-      "entry.label": "句式分析",
-      "entry.tooltip": "句式模式分析开关（dsh-novel-writer）",
-      "panel.title": "句式模式分析",
-      "panel.desc": "分析作品的句式分布（陈述/对话/心理/疑问/反问/感叹/祈使/省略留白）、排列规律、句长节奏、情感曲线与风格指纹，帮助 AI 快速掌握作者的写作习惯与主观情感。",
-      "panel.enabled": "启用句式分析",
-      "panel.enabledHint": "开启后，AI 可以调用 novel_sentence_analysis 提取句式模式报告。",
+      "entry.label": "写作助手功能",
+      "entry.tooltip": "写作助手功能开关（dsh-novel-writer）：句式分析/风格自检/伏笔登记等",
+      "panel.title": "写作助手功能",
+      "panel.desc": "管理写作助手的功能开关：句式模式分析（九类句式/情感曲线/风格指纹）、风格自检、伏笔登记、稿件导入等。关闭的工具，AI 调用时会收到提示。",
+      "panel.enabled": "启用写作助手功能",
+      "panel.enabledHint": "总开关：控制句式模式分析与风格自检（novel_sentence_analysis / novel_style_check）。",
       "panel.autoAnalyze": "分析作品时自动使用",
       "panel.autoAnalyzeHint": "开启后，AI 在分析作品时会主动附带句式分析；关闭则仅在用户明确要求时使用。",
+      "panel.toolsTitle": "工具开关",
+      "panel.toolsHint": "全部默认开启。关闭后 AI 调用该工具会收到明确提示；可随时在此重新开启。",
       "panel.loading": "正在读取开关状态…",
       "panel.saved": "状态已保存到宿主端",
       "panel.localOnly": "宿主端不可达，开关仅保存在本浏览器（重启后可能恢复默认）。",
       "panel.saveFailed": "保存到宿主端失败，已降级保存在本浏览器。",
-      "panel.foot": "提示：也可在对话中让 AI 用 novel_sentence_config 查看/修改这两个开关。重启 Web 应用后，AI 的工具列表中会出现 novel_sentence_analysis / novel_sentence_config。",
+      "panel.foot": "提示：也可在对话中让 AI 用 novel_sentence_config 查看/修改全部开关。",
       "panel.close": "关闭",
-      "banner.on": "句式分析已启用",
-      "banner.onSub": "AI 可以调用 novel_sentence_analysis",
-      "banner.off": "句式分析已关闭",
-      "banner.offSub": "AI 不会执行句式分析",
+      "banner.on": "写作助手功能已启用",
+      "banner.onSub": "句式分析 / 风格自检可用",
+      "banner.off": "写作助手功能已关闭",
+      "banner.offSub": "句式分析 / 风格自检不可用",
       "badge.on": "已开启",
       "badge.off": "已关闭",
+      "tool.novel_books": "作品列表 novel_books",
+      "tool.novel_chapters": "章节清单 novel_chapters",
+      "tool.novel_read": "阅读章节 novel_read",
+      "tool.novel_keywords": "关键词分析 novel_keywords",
+      "tool.novel_new_chapter": "新建章节 novel_new_chapter",
+      "tool.novel_import": "稿件导入 novel_import",
+      "tool.novel_sentence_analysis": "句式模式分析 novel_sentence_analysis",
+      "tool.novel_sentence_config": "开关配置 novel_sentence_config",
+      "tool.novel_style_check": "风格自检 novel_style_check",
+      "tool.novel_plot": "伏笔登记 novel_plot",
+      "tool.novel_books.desc": "列出书库中的全部作品（章节数/总字数）。",
+      "tool.novel_chapters.desc": "查看某本书的章节清单与字数。",
+      "tool.novel_read.desc": "阅读章节正文（支持分页与编码自动识别）。",
+      "tool.novel_keywords.desc": "提取高频关键词（词组/三字组/疑似人名）。",
+      "tool.novel_new_chapter.desc": "创建新章节文件（自动取下一章号）。",
+      "tool.novel_import.desc": "批量导入原稿件并自动分类到书库。",
+      "tool.novel_sentence_analysis.desc": "句式分布/排列规律/情感曲线/风格指纹。",
+      "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，此处会显示真实路径。",
+      "plot.open": "打开文件夹",
+      "plot.copy": "复制路径",
+      "plot.copied": "已复制",
+      "plot.revealOk": "已打开文件夹",
+      "plot.revealErr": "打开失败",
       "card.title": "小说写作助手 novel-writer",
       "card.desc": "句式模式分析：分析原文陈述/环境/心理/对话/疑问/反问/感叹等句子的排列节奏来辅助模仿文风。⚠️ 若机械套用导致文风僵硬，模型会优先回归自然表达。",
-      "card.status": "句式模式分析：已启用 · 自动分析：开",
-      "card.statusOff": "句式模式分析：已关闭",
-      "card.statusAutoOff": "句式模式分析：已启用 · 自动分析：关",
-      "card.hint": "开关统一在侧边栏「句式分析」面板（也可让 AI 用 novel_sentence_config 调整），本卡片仅显示状态。",
+      "card.status": "写作助手功能：已启用 · 自动分析：开",
+      "card.statusOff": "写作助手功能：已关闭",
+      "card.statusAutoOff": "写作助手功能：已启用 · 自动分析：关",
+      "card.hint": "全部开关统一在侧边栏「写作助手功能」面板（也可让 AI 用 novel_sentence_config 调整），本卡片仅显示状态。",
       "card.open": "打开开关面板"
     };
     var en = {
-      "entry.label": "Sentence Analysis",
-      "entry.tooltip": "Sentence-pattern analysis switch (dsh-novel-writer)",
-      "panel.title": "Sentence Pattern Analysis",
-      "panel.desc": "Analyzes sentence-type distribution (statement/dialogue/inner-thought/question/rhetoric/exclamation/imperative/ellipsis), arrangement patterns, rhythm, emotion curve and a style fingerprint — so the AI can quickly learn an author's habits and subjective tone.",
-      "panel.enabled": "Enable sentence analysis",
-      "panel.enabledHint": "When on, the AI may call novel_sentence_analysis for pattern reports.",
+      "entry.label": "Writing Assistant",
+      "entry.tooltip": "Writing assistant switches (dsh-novel-writer): analysis / style check / plot tracking etc.",
+      "panel.title": "Writing Assistant",
+      "panel.desc": "Manage the writing-assistant features: sentence-pattern analysis, style check, plot tracking, import, etc. Disabled tools return a clear notice when called.",
+      "panel.enabled": "Enable writing assistant",
+      "panel.enabledHint": "Master switch: controls novel_sentence_analysis and novel_style_check.",
       "panel.autoAnalyze": "Auto-use when analyzing works",
       "panel.autoAnalyzeHint": "When on, the AI proactively includes sentence analysis; otherwise only on explicit request.",
+      "panel.toolsTitle": "Tool switches",
+      "panel.toolsHint": "All on by default. Disabled tools return a clear notice; re-enable anytime here.",
       "panel.loading": "Loading switch state…",
       "panel.saved": "Saved to the host state file",
       "panel.localOnly": "Host unreachable; kept in this browser only (defaults may return after restart).",
       "panel.saveFailed": "Host save failed; fell back to this browser.",
-      "panel.foot": "Tip: ask the AI to run novel_sentence_config to view/change these switches. After restarting the Web app, novel_sentence_analysis / novel_sentence_config appear in the tool list.",
+      "panel.foot": "Tip: ask the AI to run novel_sentence_config to view/change all switches.",
       "panel.close": "Close",
-      "banner.on": "Sentence analysis is ON",
-      "banner.onSub": "novel_sentence_analysis is available",
-      "banner.off": "Sentence analysis is OFF",
-      "banner.offSub": "the AI will not run it",
+      "banner.on": "Writing assistant is ON",
+      "banner.onSub": "analysis / style check available",
+      "banner.off": "Writing assistant is OFF",
+      "banner.offSub": "analysis / style check unavailable",
       "badge.on": "ON",
       "badge.off": "OFF",
+      "tool.novel_books": "Books novel_books",
+      "tool.novel_chapters": "Chapters novel_chapters",
+      "tool.novel_read": "Read novel_read",
+      "tool.novel_keywords": "Keywords novel_keywords",
+      "tool.novel_new_chapter": "New chapter novel_new_chapter",
+      "tool.novel_import": "Import novel_import",
+      "tool.novel_sentence_analysis": "Pattern analysis novel_sentence_analysis",
+      "tool.novel_sentence_config": "Config novel_sentence_config",
+      "tool.novel_style_check": "Style check novel_style_check",
+      "tool.novel_plot": "Plot tracking novel_plot",
+      "tool.novel_books.desc": "List all books (chapters / total chars).",
+      "tool.novel_chapters.desc": "List chapters of a book with sizes.",
+      "tool.novel_read.desc": "Read chapter text (paged, auto-encoding).",
+      "tool.novel_keywords.desc": "Extract keywords (bigrams / trigrams / name candidates).",
+      "tool.novel_new_chapter.desc": "Create a new chapter file (next number auto).",
+      "tool.novel_import.desc": "Import raw drafts and auto-classify into the library.",
+      "tool.novel_sentence_analysis.desc": "Pattern distribution / rhythm / emotion curve / fingerprint.",
+      "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.",
+      "plot.open": "Open folder",
+      "plot.copy": "Copy path",
+      "plot.copied": "Copied",
+      "plot.revealOk": "Opened",
+      "plot.revealErr": "Open failed",
       "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": "Sentence analysis: ON · auto-analyze: ON",
-      "card.statusOff": "Sentence analysis: OFF",
-      "card.statusAutoOff": "Sentence analysis: ON · auto-analyze: OFF",
-      "card.hint": "Switches live in the sidebar 'Sentence Analysis' panel (or ask the AI to run novel_sentence_config); this card only shows status.",
+      "card.status": "Writing assistant: ON · auto-analyze: ON",
+      "card.statusOff": "Writing assistant: OFF",
+      "card.statusAutoOff": "Writing assistant: ON · auto-analyze: OFF",
+      "card.hint": "All switches live in the sidebar 'Writing Assistant' panel (or ask the AI to run novel_sentence_config); this card only shows status.",
       "card.open": "Open the switch panel"
     };
     function dictionary() {
@@ -137,6 +213,9 @@ window.__ModuleLoader__.load({
       return text === void 0 ? key : text;
     }
 
+    // ---- 工具清单（与宿主端 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 STATE_ROUTE = "/api/dsh-novel-writer/state";
     var STORAGE_KEY = "dsh.novelWriter.state.v1";
@@ -161,12 +240,17 @@ window.__ModuleLoader__.load({
       var state = {
         enabled: true,
         autoAnalyze: true,
+        tools: {},
         file: "",
         source: "",
         loading: true,
         hostOk: true,
         saveFailed: false,
-        panelOpen: false
+        panelOpen: false,
+        plotsDir: "",
+        revealMsg: "",
+        revealErr: false,
+        revealing: false
       };
       return {
         getSnapshot: function () { return state; },
@@ -177,6 +261,36 @@ window.__ModuleLoader__.load({
         subscribe: function (fn) {
           listeners.add(fn);
           return function () { listeners.delete(fn); };
+        },
+        openPlotsDir: 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" })
+          }).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 });
+            } else {
+              controller.set({ revealMsg: data.error || t("plot.revealErr"), revealErr: true });
+            }
+          }).catch(function () {
+            controller.set({ revealMsg: t("plot.revealErr") + "：宿主端不可达", revealErr: true });
+          }).finally(function () {
+            controller.set({ revealing: false });
+          });
+        },
+        copyPlotsPath: function () {
+          var dir = controller.getSnapshot().plotsDir;
+          if (dir === "") return;
+          var done = function () {
+            controller.set({ revealMsg: t("plot.copied") + "：" + dir, revealErr: false });
+          };
+          if (navigator.clipboard && navigator.clipboard.writeText) {
+            navigator.clipboard.writeText(dir).then(done, done);
+          } else {
+            done();
+          }
         }
       };
     }
@@ -338,6 +452,57 @@ window.__ModuleLoader__.load({
             react.createElement("span", { className: "nwBadge " + (state.autoAnalyze ? "nwBadgeOn" : "nwBadgeOff") }, state.autoAnalyze ? t("badge.on") : t("badge.off"))
           )
         ),
+        react.createElement("div", { className: "nwSectionTitle" }, t("panel.toolsTitle")),
+        react.createElement("div", { className: "nwToolsHint" }, t("panel.toolsHint")),
+        ALL_TOOLS.map(function (name) {
+          var checked = (state.tools || {})[name] !== false;
+          var desc = t("tool." + name + ".desc");
+          var plotExtra = null;
+          if (name === "novel_plot") {
+            var pathText = state.plotsDir !== "" ? state.plotsDir : 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: "nwBtnGroup" },
+                react.createElement("button", {
+                  type: "button", className: "nwBtn", disabled: state.plotsDir === "" || state.revealing,
+                  onClick: function () { props.controller.openPlotsDir(); }
+                }, t("plot.open")),
+                react.createElement("button", {
+                  type: "button", className: "nwBtn", disabled: state.plotsDir === "",
+                  onClick: function () { props.controller.copyPlotsPath(); }
+                }, t("plot.copy"))
+              ),
+              state.revealMsg !== "" ? react.createElement("div", { className: "nwPlotMsg " + (state.revealErr ? "nwPlotErr" : "") }, state.revealMsg) : null
+            );
+          }
+          return react.createElement(
+            "div",
+            { className: "nwToolRow" + (checked ? " nwToolRowOn" : ""), key: name },
+            react.createElement(
+              "div",
+              { className: "nwToolLabel", title: desc },
+              react.createElement("div", null, t("tool." + name)),
+              react.createElement("div", { className: "nwToolDesc" }, desc),
+              plotExtra
+            ),
+            react.createElement(
+              "button",
+              {
+                type: "button",
+                role: "switch",
+                "aria-checked": checked ? "true" : "false",
+                className: "nwSwitchSmall" + (checked ? " nwSwitchSmallOn" : ""),
+                disabled: state.loading,
+                onClick: function () { props.toggle({ tools: (function (patch) { patch[name] = !checked; return patch; })({}) }); }
+              },
+              react.createElement("span", { className: "nwSwitchSmallKnob" })
+            )
+          );
+        }),
         react.createElement(
           "div",
           { className: "nwStatus" },
@@ -480,6 +645,8 @@ window.__ModuleLoader__.load({
           controller.set({
             enabled: !!remote.enabled,
             autoAnalyze: !!remote.autoAnalyze,
+            tools: remote.tools || {},
+            plotsDir: remote.plotsDir || "",
             file: remote.file || "",
             source: "host",
             hostOk: true,

package/lib/index.js

@@ -26,6 +26,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, join, sep } from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
 import { analyzeText, CATEGORY_LABELS, CATEGORY_ORDER, fingerprintSimilarity, styleDiffs } from "./analysis.js";
 
 const name = "novel-writer";
@@ -442,6 +443,7 @@ function registerNovelImport(ctx, config) {
       render: (_args, value) => [{ type: "text", text: formatImport(value) }]
     },
     async execute(args, exec) {
+      await assertToolEnabled(config, "novel_import");
       const src = requiredString(args, "src");
       const mode = args?.mode === "apply" ? "apply" : "scan";
       const forcedBook = optionalString(args, "book");
@@ -567,6 +569,27 @@ function registerNovelImport(ctx, config) {
 /** 句式分析默认配置。 */
 const SENTENCE_ANALYSIS_DEFAULTS = Object.freeze({ enabled: true, autoAnalyze: true });
 
+/** 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"
+]);
+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: "伏笔登记"
+});
+/** 工具级开关是否开启（默认开；state.tools[name] === false 时关闭）。 */
+function toolEnabled(state, name) {
+  const tools = state?.tools ?? {};
+  return tools[name] !== false;
+}
+/** 断言工具开关：关闭时抛出明确提示（模型可见）。 */
+async function assertToolEnabled(config, name) {
+  const state = await readSentenceState();
+  assert(toolEnabled(state, name), `工具 ${name}（${TOOL_LABELS[name] ?? name}）当前已在「写作助手功能」UI 中关闭。可用 novel_sentence_config 或侧边栏面板重新开启。`);
+}
+
 /** 运行时状态文件路径（Web GUI 侧边栏「句式分析」开关落盘位置）。 */
 function stateFilePath() {
   return join(homedir(), ".dsh", "dsh-novel-writer", "state.json");
@@ -602,7 +625,9 @@ async function readSentenceState() {
     return {
       exists: true,
       enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : SENTENCE_ANALYSIS_DEFAULTS.enabled,
-      autoAnalyze: typeof parsed.autoAnalyze === "boolean" ? parsed.autoAnalyze : SENTENCE_ANALYSIS_DEFAULTS.autoAnalyze
+      autoAnalyze: typeof parsed.autoAnalyze === "boolean" ? parsed.autoAnalyze : SENTENCE_ANALYSIS_DEFAULTS.autoAnalyze,
+      tools: parsed.tools !== null && typeof parsed.tools === "object" ? parsed.tools : {},
+      lastRoot: typeof parsed.lastRoot === "string" ? parsed.lastRoot : void 0
     };
   } catch {
     return { exists: false, ...SENTENCE_ANALYSIS_DEFAULTS };
@@ -615,7 +640,9 @@ async function writeSentenceState(patch) {
   const next = {
     ...current,
     ...(typeof patch?.enabled === "boolean" ? { enabled: patch.enabled } : {}),
-    ...(typeof patch?.autoAnalyze === "boolean" ? { autoAnalyze: patch.autoAnalyze } : {})
+    ...(typeof patch?.autoAnalyze === "boolean" ? { autoAnalyze: patch.autoAnalyze } : {}),
+    ...(patch?.tools !== null && typeof patch?.tools === "object" ? { tools: { ...(current.tools ?? {}), ...patch.tools } } : {}),
+    ...(typeof patch?.lastRoot === "string" ? { lastRoot: patch.lastRoot } : {})
   };
   const file = stateFilePath();
   await mkdir(dirname(file), { recursive: true });
@@ -691,15 +718,34 @@ async function readJsonBody(req) {
   try { return JSON.parse(Buffer.concat(chunks).toString("utf8")); } catch { return void 0; }
 }
 
-/** /api/dsh-novel-writer/state 路由：GET 读开关，POST 写开关。 */
-function makeStateRoutes(allowLan) {
+/** 打开系统文件管理器定位到某目录（Windows: explorer /select）。 */
+function openInExplorer(dir) {
+  if (process.platform === "win32") {
+    execFile("explorer", ["/select,", dir], () => {});
+  } else if (process.platform === "darwin") {
+    execFile("open", [dir], () => {});
+  } else {
+    execFile("xdg-open", [dir], () => {});
+  }
+}
+
+/** /api/dsh-novel-writer/state 路由：GET 读开关，POST 写开关；/reveal 打开文件夹。 */
+function makeStateRoutes(allowLan, config) {
   const routePath = "/api/dsh-novel-writer/state";
+  const revealPath = "/api/dsh-novel-writer/reveal";
   const handler = async (req, res) => {
     if (!isAllowedRequest(req, allowLan)) return writeJson(res, 403, { error: "forbidden: loopback-only" });
     const method = req.method ?? "GET";
     if (method === "GET") {
       const state = await readSentenceState();
-      return writeJson(res, 200, { enabled: state.enabled, autoAnalyze: state.autoAnalyze, file: stateFilePath() });
+      const plotsRoot = config?.root ?? state.lastRoot;
+      return writeJson(res, 200, {
+        enabled: state.enabled,
+        autoAnalyze: state.autoAnalyze,
+        tools: state.tools ?? {},
+        plotsDir: typeof plotsRoot === "string" && plotsRoot.length > 0 ? join(plotsRoot, ".novel-writer") : "",
+        file: stateFilePath()
+      });
     }
     if (method === "POST") {
       const body = await readJsonBody(req);
@@ -713,7 +759,32 @@ function makeStateRoutes(allowLan) {
     }
     return writeJson(res, 405, { error: `method not allowed: ${method}` });
   };
-  return [{ kind: "exact", path: routePath, handler }];
+  const revealHandler = async (req, res) => {
+    if (!isAllowedRequest(req, allowLan)) return writeJson(res, 403, { error: "forbidden: loopback-only" });
+    if ((req.method ?? "GET") !== "POST") return writeJson(res, 405, { error: "method not allowed" });
+    const body = await readJsonBody(req);
+    const target = body?.target;
+    if (target !== "plots-dir") return writeJson(res, 400, { error: 'unknown target (allowed: "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 中打开伏笔文件夹。" });
+    }
+    const dir = join(plotsRoot, ".novel-writer");
+    try {
+      await mkdir(dir, { recursive: true });
+    } catch { /* 目录已存在或创建失败都不阻塞打开 */ }
+    try {
+      openInExplorer(dir);
+      return writeJson(res, 200, { ok: true, path: dir });
+    } catch (error) {
+      return writeJson(res, 500, { error: error instanceof Error ? error.message : String(error) });
+    }
+  };
+  return [
+    { kind: "exact", path: routePath, handler },
+    { kind: "exact", path: revealPath, handler: revealHandler }
+  ];
 }
 
 /**
@@ -723,7 +794,7 @@ function makeStateRoutes(allowLan) {
 function registerStyleConfigRoute(ctx, config) {
   try {
     ctx.inject(["webServer"], (wctx) => {
-      const routes = makeStateRoutes(config?.allowLanState === true);
+      const routes = makeStateRoutes(config?.allowLanState === true, config);
       wctx.effect?.(() => {
         const disposers = routes.map((route) => wctx.webServer.register(route));
         return () => {
@@ -945,6 +1016,7 @@ function registerNovelSentenceAnalysis(ctx, config) {
       render: (_args, value) => [{ type: "text", text: formatSentenceAnalysis(value) }]
     },
     async execute(args, exec) {
+      await assertToolEnabled(config, "novel_sentence_analysis");
       const book = sanitizeSegment(requiredString(args, "book"), "book");
       const chapterArg = optionalString(args, "chapter");
       const top = optionalInt(args, "top", 1, 50, 8);
@@ -1027,8 +1099,9 @@ function registerNovelSentenceConfig(ctx, config) {
       type: "object",
       properties: {
         action: { type: "string", enum: ["get", "set"], description: "get=查看（默认）；set=修改。" },
-        enabled: { type: "boolean", description: "set 时指定：是否启用句式模式分析。" },
-        autoAnalyze: { type: "boolean", description: "set 时指定：分析作品时是否主动使用句式分析。" }
+        enabled: { type: "boolean", description: "set 时指定：写作助手功能总开关。" },
+        autoAnalyze: { type: "boolean", description: "set 时指定：分析作品时是否主动使用句式分析。" },
+        tools: { type: "object", additionalProperties: true, description: "set 时指定：各工具开关（如 { novel_plot: false }），键必须是 novel_* 工具名。" }
       },
       additionalProperties: false
     },
@@ -1041,23 +1114,31 @@ function registerNovelSentenceConfig(ctx, config) {
           enabled: { type: "boolean" },
           autoAnalyze: { type: "boolean" },
           source: { type: "string" },
-          updated: { type: "boolean" }
+          updated: { type: "boolean" },
+          tools: { type: "object", additionalProperties: true, description: "各工具当前开关状态。" }
         },
-        required: ["file", "enabled", "autoAnalyze"]
+        required: ["file", "enabled", "autoAnalyze", "tools"]
       },
-      render: (_args, value) => [{
-        type: "text",
-        text: `<path>${value.file}</path>
+      render: (_args, value) => {
+        const toolLines = ALL_TOOLS.map((name) => `  - ${TOOL_LABELS[name] ?? name} (${name}): ${value.tools?.[name] === false ? "关闭" : "开启"}`);
+        return [{
+          type: "text",
+          text: `<path>${value.file}</path>
 <type>novel-sentence-config</type>
 <content>
-句式模式分析: ${value.enabled ? "已启用" : "已关闭"}
+写作助手功能: ${value.enabled ? "已启用" : "已关闭"}
 自动分析(autoAnalyze): ${value.autoAnalyze ? "开" : "关"}
 来源: ${value.source}
 ${value.updated === true ? "(已保存到 state 文件)" : ""}
+
+各工具开关：
+${toolLines.join("\n")}
 </content>`
-      }]
+        }];
+      }
     },
     async execute(args) {
+      await assertToolEnabled(config, "novel_sentence_config");
       const action = args?.action === "set" ? "set" : "get";
       const state = await readSentenceState();
       const effective = effectiveSentenceAnalysis(config, state);
@@ -1067,6 +1148,13 @@ ${value.updated === true ? "(已保存到 state 文件)" : ""}
         const patch = {};
         if (typeof args?.enabled === "boolean") patch.enabled = args.enabled;
         if (typeof args?.autoAnalyze === "boolean") patch.autoAnalyze = args.autoAnalyze;
+        if (args?.tools !== null && typeof args?.tools === "object") {
+          const toolsPatch = {};
+          for (const name of ALL_TOOLS) {
+            if (typeof args.tools[name] === "boolean") toolsPatch[name] = args.tools[name];
+          }
+          if (Object.keys(toolsPatch).length > 0) patch.tools = toolsPatch;
+        }
         if (Object.keys(patch).length > 0) {
           current = await writeSentenceState(patch);
           updated = true;
@@ -1077,7 +1165,9 @@ ${value.updated === true ? "(已保存到 state 文件)" : ""}
       const source = current?.exists === true
         ? "state 文件（GUI 开关）"
         : (styleFileOn ? "v0.4.0 兼容文件 novel-writer.json" : (config?.sentenceAnalysis || config?.stylePattern ? "插件 config" : "默认值"));
-      return { file: stateFilePath(), enabled: after.enabled, autoAnalyze: after.autoAnalyze, source, updated };
+      const tools = {};
+      for (const name of ALL_TOOLS) tools[name] = toolEnabled(current, name);
+      return { file: stateFilePath(), enabled: after.enabled, autoAnalyze: after.autoAnalyze, source, updated, tools };
     }
   });
 }
@@ -1148,10 +1238,14 @@ function registerNovelStyleCheck(ctx, config) {
       }
     },
     async execute(args, exec) {
+      await assertToolEnabled(config, "novel_style_check");
       const book = sanitizeSegment(requiredString(args, "book"), "book");
       const chapterArg = requiredString(args, "chapter");
       const root = resolveRoot(config, args, exec);
       const dir = bookDir(root, book);
+      const state = await readSentenceState();
+      const effective = effectiveSentenceAnalysis(config, state);
+      assert(effective.enabled, "写作助手功能（句式模式分析）当前已关闭，可在侧边栏「写作助手功能」面板开启后再做风格自检。");
       const chapters = await scanChapters(dir);
       assert(chapters.length > 1, `book "${book}" 只有 ${chapters.length} 章，无法做风格对比（至少需要 2 章）`);
       const target = findChapter(chapters, chapterArg);
@@ -1203,6 +1297,17 @@ async function writePlots(root, book, entries) {
   await mkdir(dirname(file), { recursive: true });
   await writeFile(file, JSON.stringify({ book, entries }, null, 2), "utf8");
 }
+
+/** 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);
+  if (entry.createdAt !== void 0) out.createdAt = entry.createdAt;
+  if (entry.updatedAt !== void 0) out.updatedAt = entry.updatedAt;
+  return out;
+}
+
 function registerNovelPlot(ctx, config) {
   ctx.tools.register({
     name: "novel_plot",
@@ -1266,6 +1371,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 root = resolveRoot(config, args, exec);
@@ -1299,8 +1405,9 @@ function registerNovelPlot(ctx, config) {
         }
       }
       await writePlots(root, book, entries);
+      try { await writeSentenceState({ lastRoot: root }); } catch { /* 记录失败不影响伏笔功能 */ }
       entries.sort((a, b) => (a.status === b.status ? a.createdAt.localeCompare(b.createdAt) : a.status === "open" ? -1 : 1));
-      return { book, action, entries, ...message ? { message } : {} };
+      return { book, action, entries: entries.map(normalizePlotEntry), ...message ? { message } : {} };
     }
   });
 }
@@ -1346,6 +1453,7 @@ function registerNovelBooks(ctx, config) {
       }]
     },
     async execute(args, exec) {
+      await assertToolEnabled(config, "novel_books");
       const root = resolveRoot(config, args, exec);
       const dir = novelsDir(root);
       let entries;
@@ -1430,6 +1538,7 @@ function registerNovelChapters(ctx, config) {
       }]
     },
     async execute(args, exec) {
+      await assertToolEnabled(config, "novel_chapters");
       const book = sanitizeSegment(requiredString(args, "book"), "book");
       const root = resolveRoot(config, args, exec);
       const dir = bookDir(root, book);
@@ -1512,6 +1621,7 @@ function registerNovelRead(ctx, config) {
       }]
     },
     async execute(args, exec) {
+      await assertToolEnabled(config, "novel_read");
       const book = sanitizeSegment(requiredString(args, "book"), "book");
       const chapterArg = requiredString(args, "chapter");
       const offset = optionalInt(args, "offset", 1, Number.MAX_SAFE_INTEGER, 1);
@@ -1621,6 +1731,7 @@ function registerNovelKeywords(ctx, config) {
       }]
     },
     async execute(args, exec) {
+      await assertToolEnabled(config, "novel_keywords");
       const book = sanitizeSegment(requiredString(args, "book"), "book");
       const chapterArg = optionalString(args, "chapter");
       const top = optionalInt(args, "top", 1, 100, 20);
@@ -1702,6 +1813,7 @@ Created 第${String(value.number).padStart(2, "0")}章 (${value.chars} chars)
       }]
     },
     async execute(args, exec) {
+      await assertToolEnabled(config, "novel_new_chapter");
       const book = sanitizeSegment(requiredString(args, "book"), "book");
       const explicit = optionalInt(args, "chapter", 1, 99999, void 0);
       const title = optionalString(args, "title");
@@ -1742,8 +1854,9 @@ const WORKFLOW_TEXT = [
   "   新章节写入 novels/<书名>/ 文件夹：用 novel_new_chapter 创建章节文件，或直接用 write 工具写文件。",
   "4. 句式模式分析（增强，受 UI 开关控制）：分析作品时可调用 novel_sentence_analysis 提取句式分布（陈述/环境/心理/对话/疑问/反问/感叹/祈使/省略留白九类）、",
   "   句式排列规律（转移、高频模板、段首段尾句式、按章节的压缩节奏序列）、句长节奏、情感曲线、风格指纹与节奏建议，用于快速掌握作者的写作习惯与主观情感。",
-  "   开关默认开启；统一在 Web GUI 侧边栏「句式分析」面板调整（设置 > 插件配置 仅显示状态），也可用 novel_sentence_config。动手前可先调用 novel_sentence_config 查看状态：",
-  "   - enabled=false 时 novel_sentence_analysis 会返回关闭状态，不要强行分析；",
+  "   开关默认开启；统一在 Web GUI 侧边栏「写作助手功能」面板调整（设置 > 插件配置 仅显示状态），也可用 novel_sentence_config。动手前可先调用 novel_sentence_config 查看状态：",
+  "   - 总开关 enabled=false 时 novel_sentence_analysis / novel_style_check 会拒绝执行，不要强行分析；",
+  "   - 每个工具都有独立开关（novel_sentence_config 返回 tools 字段）：关闭的工具调用时会返回明确提示，按提示引导用户开启或改用其他方式；",
   "   - autoAnalyze=true 时分析作品应主动附带句式分析；false 时仅在用户明确要求时调用。",
   "   重要：句式模式是「参考节奏」而非「模板套用」。若机械复刻导致句子僵硬、重复、模式化，必须优先回归自然表达。",
   "5. 导入/整理原稿件时：用 novel_import 扫描存放多本小说稿件的文件夹（src），先以 scan 模式查看分组建议，",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-novel-writer",
-  "version": "0.6.0",
-  "description": "小说写作助手插件（v0.6.0 工程化版）：章节库管理、句式模式分析（九类/情感曲线/风格指纹/缓存报告）、风格自检、伏笔登记表、批量导入、续写辅助（关键词含三字组与疑似人名、情感词典去噪、支持任意位置章号、UTF-8/16/GBK 编码探测）",
+  "version": "0.7.0",
+  "description": "小说写作助手插件（v0.7.0）：10 个工具全部带独立 UI 开关（侧边栏「写作助手功能」面板统一管理）、句式分析/风格自检/伏笔登记/批量导入、分析缓存与报告导出、情感词典去噪、编码探测",
   "type": "module",
   "main": "lib/index.js",
   "exports": {

package/test/e2e-test.mjs

@@ -25,6 +25,33 @@ if (names.length !== 10) throw new Error("expected 10 tools");
 
 const exec = { agent: { session: { header: { cwd: testRoot } } } };
 
+// ---- DSH schema 规则检查（additionalProperties 必须布尔；禁用 pattern/format/数值边界关键字）----
+const SCHEMA_KEYWORDS = new Set(["type", "properties", "required", "additionalProperties", "items", "enum", "const", "oneOf"]);
+const SCHEMA_BANNED = ["pattern", "format", "minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems"];
+function assertDshSchema(node, where) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) return;
+  for (const key of Object.keys(node)) {
+    const v = node[key];
+    if (!SCHEMA_KEYWORDS.has(key)) continue;
+    if (key === "additionalProperties" && typeof v !== "boolean") throw new Error(where + ".additionalProperties must be boolean: " + JSON.stringify(v).slice(0, 60));
+    if (key === "type" && typeof v !== "string") throw new Error(where + ".type must be string");
+    if (key === "properties") {
+      if (v === null || typeof v !== "object") throw new Error(where + ".properties must be object");
+      for (const field of Object.keys(v)) assertDshSchema(v[field], where + ".properties." + field);
+    } else if (typeof v === "object" && v !== null) {
+      assertDshSchema(v, where + "." + key);
+    }
+  }
+  for (const banned of SCHEMA_BANNED) {
+    if (Object.prototype.hasOwnProperty.call(node, banned)) throw new Error(where + "." + banned + " not supported by DSH");
+  }
+}
+for (const d of registry) {
+  if (d.parameters) assertDshSchema(d.parameters, d.name + ".parameters");
+  if (d.output?.schema) assertDshSchema(d.output.schema, d.name + ".output");
+}
+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"));