dsh-memory-engine 0.7.6 → 0.7.7

package/lib/client.src.js

@@ -14,11 +14,40 @@ window.__ModuleLoader__.load({
     var SLOT_FALLBACKS = ["conversation.session.header.actions", "conversation.session.header.views.actions"];
 
     /* __CANVAS_RENDERER__ */
+    /* __GRAPH_LAYOUT__ */
 
-    var defaultSettings = { hideButton: false, showGuideOnEmpty: true, autoMemory: { enabled: false, maxPerTurn: 2, dailyCap: 40 }, showAutoMemoryCostHint: true };
-    var actionStyle = { padding: "7px 12px", borderRadius: "8px", border: "1px solid #6999b8", background: "#102236", color: "#e2f4ff", font: "inherit", cursor: "pointer" };
+    var defaultSettings = { hideButton: false, showGuideOnEmpty: true, graphTheme: "classic", graphLayout: "sphere", autoMemory: { enabled: false, maxPerTurn: 2, dailyCap: 40 }, showAutoMemoryCostHint: true };
+    var actionStyle = { padding: "7px 12px", borderRadius: "8px", border: "1px solid var(--memory-border,#6999b8)", background: "var(--memory-button,#102236)", color: "var(--memory-text,#e2f4ff)", font: "inherit", cursor: "pointer" };
     var fieldStyle = { boxSizing: "border-box", padding: "10px 12px", borderRadius: "8px", border: "1px solid #35536b", background: "#091422", color: "#e2f4ff", font: "inherit", minWidth: 0 };
     var kinds = ["知识", "印象", "对话", "事件", "日记"];
+    var appearanceOptions = [
+      { key: "graphTheme", label: "配色", choices: [["classic", "经典星空"], ["neon", "赛博霓虹"], ["paper", "铅绘素描"], ["mono", "极简单色"]] },
+      { key: "graphLayout", label: "布局", choices: [["sphere", "球体"], ["flat", "平面圆"], ["spiral", "螺旋银河"]] },
+    ];
+    var appearanceStyles = {
+      classic: {},
+      neon: { "--memory-text": "#f4dfff", "--memory-muted": "#ba9aca", "--memory-accent": "#ff9de1", "--memory-border": "#704580", "--memory-panel": "#170d21ee", "--memory-button": "#271333", "--memory-shadow": "none" },
+      paper: { "--memory-text": "#303030", "--memory-muted": "#72716d", "--memory-accent": "#404040", "--memory-border": "#b5b1a9", "--memory-panel": "#f7f5f0f2", "--memory-button": "#eeece6", "--memory-shadow": "none" },
+      mono: { "--memory-text": "#eeeeee", "--memory-muted": "#aaaaaa", "--memory-accent": "#eeeeee", "--memory-border": "#666666", "--memory-panel": "#171717ee", "--memory-button": "#252525", "--memory-shadow": "none" },
+    };
+
+    function AppearanceControls(props) {
+      return React.createElement("section", { "aria-label": "图谱外观", "data-memory-engine-appearance-options": props.location,
+        style: { color: "var(--memory-text,#dbeaf8)", font: "14px/1.7 system-ui,sans-serif" } },
+        appearanceOptions.map(function (group) {
+          return React.createElement("fieldset", { key: group.key, disabled: props.busy, style: { border: 0, margin: "0 0 14px", padding: 0 } },
+            React.createElement("legend", { style: { marginBottom: "8px", color: "var(--memory-muted,#9fb7ce)" } }, group.label),
+            React.createElement("div", { style: { display: "flex", flexWrap: "wrap", gap: "8px 14px" } }, group.choices.map(function (choice) {
+              return React.createElement("label", { key: choice[0], style: { display: "inline-flex", alignItems: "center", gap: "6px", cursor: props.busy ? "wait" : "pointer" } },
+                React.createElement("input", { type: "radio", name: "memory-" + props.location + "-" + group.key, value: choice[0],
+                  "data-memory-engine-appearance-choice": group.key + ":" + choice[0],
+                  checked: props.settings[group.key] === choice[0], style: { margin: 0, accentColor: "var(--memory-accent,#a4e6ff)" },
+                  onChange: function () { var changes = {}; changes[group.key] = choice[0]; props.onChange(changes); } }), choice[1]);
+            })));
+        }), React.createElement("button", { type: "button", disabled: props.busy, style: actionStyle,
+          "data-memory-engine-appearance-reset": props.location,
+          onClick: function () { props.onChange({ graphTheme: "classic", graphLayout: "sphere" }); } }, "恢复默认"));
+    }
 
     function requestApi(url, options) {
       return fetch(url, Object.assign({ cache: "no-store" }, options)).then(function (response) {
@@ -172,6 +201,8 @@ window.__ModuleLoader__.load({
 
     function MemoryCanvas(props) {
       var canvas = React.useRef(null);
+      var appearance = React.useRef(null);
+      appearance.current = { graphTheme: props.graphTheme || "classic", graphLayout: props.graphLayout || "sphere" };
       var dataState = React.useState(null);
       var data = dataState[0];
       var setData = dataState[1];
@@ -188,7 +219,7 @@ window.__ModuleLoader__.load({
         setError("");
         readApi("/memory-engine/api/map", controller.signal).then(function (nextData) {
           if (!active) return;
-          renderer = createRenderer(canvas.current, nextData, { frameInterval: 25 });
+          renderer = createRenderer(canvas.current, nextData, Object.assign({ frameInterval: 25, layoutNodes: layoutPositions }, appearance.current));
           props.rendererRef.current = renderer;
           renderer.onSelect(function (node) { props.selectionVersion.current++; props.onSelect(node); });
           renderer.start();
@@ -207,6 +238,11 @@ window.__ModuleLoader__.load({
           if (props.rendererRef.current === renderer) props.rendererRef.current = null;
         };
       }, [retry, props.rendererRef, props.selectionVersion, props.onSelect]);
+      React.useEffect(function () {
+        if (!props.rendererRef.current) return;
+        props.rendererRef.current.setTheme(appearance.current.graphTheme);
+        props.rendererRef.current.setLayout(appearance.current.graphLayout);
+      }, [props.graphTheme, props.graphLayout]);
       return React.createElement(React.Fragment, null,
         React.createElement("canvas", {
           ref: canvas, "data-memory-engine-canvas": "true", "aria-label": "记忆神经网络",
@@ -214,21 +250,21 @@ window.__ModuleLoader__.load({
         }),
         React.createElement("div", {
           "data-memory-engine-summary": "true",
-          style: { position: "absolute", top: "16px", left: "18px", pointerEvents: "none", color: "#d8e9f8", font: "13px/1.65 system-ui,sans-serif", textShadow: "0 0 12px #3388bb88" },
-        }, React.createElement("strong", { style: { color: "#a4e6ff", fontSize: "16px" } }, "记忆神经网络"),
+          style: { position: "absolute", top: "16px", left: "18px", pointerEvents: "none", color: "var(--memory-text,#d8e9f8)", font: "13px/1.65 system-ui,sans-serif", textShadow: "var(--memory-shadow,0 0 12px #3388bb88)" },
+        }, React.createElement("strong", { style: { color: "var(--memory-accent,#a4e6ff)", fontSize: "16px" } }, "记忆神经网络"),
         React.createElement("div", null, data ? data.nodes.length + " 个神经元 · " + data.links.length + " 条突触" : "正在加载图谱……"),
-        React.createElement("div", { style: { color: "#7491a8", fontSize: "12px" } }, "大小＝重要度和连接数 · 亮度＝留存")),
+        React.createElement("div", { style: { color: "var(--memory-muted,#7491a8)", fontSize: "12px" } }, "大小＝重要度和连接数 · 亮度＝留存")),
         data ? React.createElement("section", {
           "aria-label": "复习清单",
-          style: { position: "absolute", bottom: "16px", left: "18px", width: "min(400px,calc(100% - 36px))", boxSizing: "border-box", maxHeight: "32%", overflow: "auto", padding: "15px", background: "#07111fee", border: "1px solid #3976a055", borderRadius: "14px", boxShadow: "0 0 40px #1763a033", backdropFilter: "blur(8px)", font: "12px/1.65 system-ui,sans-serif", color: "#b1c6d9" },
-        }, React.createElement("h2", { style: { fontSize: "14px", color: "#ffdb82", margin: "0 0 8px" } }, "复习清单 · 留存最低的记忆"),
+          style: { position: "absolute", bottom: "16px", left: "18px", width: "min(400px,calc(100% - 36px))", boxSizing: "border-box", maxHeight: "32%", overflow: "auto", padding: "15px", background: "var(--memory-panel,#07111fee)", border: "1px solid var(--memory-border,#3976a055)", borderRadius: "14px", boxShadow: "var(--memory-shadow,0 0 40px #1763a033)", backdropFilter: "blur(8px)", font: "12px/1.65 system-ui,sans-serif", color: "var(--memory-text,#b1c6d9)" },
+        }, React.createElement("h2", { style: { fontSize: "14px", color: "var(--memory-accent,#ffdb82)", margin: "0 0 8px" } }, "复习清单 · 留存最低的记忆"),
         data.review.map(function (item, index) {
           return React.createElement("div", { key: item.id || index, style: { display: "flex", gap: "7px", alignItems: "center", margin: "5px 0" } },
             React.createElement("span", { style: { flex: 1, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" } }, (index + 1) + ". [" + item.kind + "] " + item.title),
-            React.createElement("span", { style: { width: "52px", height: "5px", borderRadius: "5px", background: "#335066", overflow: "hidden" } },
-              React.createElement("i", { style: { display: "block", height: "100%", background: "#6bc9fa", width: Math.min(100, Math.max(0, item.retention * 100)) + "%" } })));
+            React.createElement("span", { style: { width: "52px", height: "5px", borderRadius: "5px", background: "var(--memory-border,#335066)", overflow: "hidden" } },
+              React.createElement("i", { style: { display: "block", height: "100%", background: "var(--memory-accent,#6bc9fa)", width: Math.min(100, Math.max(0, item.retention * 100)) + "%" } })));
         })) : null,
-        React.createElement("div", { style: { position: "absolute", right: "18px", bottom: "18px", pointerEvents: "none", color: "#7b99ad", font: "13px system-ui,sans-serif" } }, "拖拽旋转 · 滚轮缩放 · 点光点看关联"),
+        React.createElement("div", { style: { position: "absolute", right: "18px", bottom: "18px", pointerEvents: "none", color: "var(--memory-muted,#7b99ad)", font: "13px system-ui,sans-serif" } }, "拖拽旋转 · 滚轮缩放 · 点光点看关联"),
         error ? React.createElement("div", { role: "alert", style: { position: "absolute", inset: "40% 20% auto", textAlign: "center", color: "#d8e9f8" } },
           React.createElement("p", null, "图谱加载失败：" + error),
           React.createElement("button", { type: "button", style: actionStyle, onClick: function () { setRetry(function (value) { return value + 1; }); } }, "重试")) : null);
@@ -516,6 +552,9 @@ window.__ModuleLoader__.load({
             React.createElement("span", null, props.settings.autoImport.message), " ",
             React.createElement("button", { type: "button", "data-memory-engine-use-auto-import": "true", disabled: props.configBusy,
               onClick: props.onUseAutoImport, style: actionStyle }, "改用宽松模式")) : null,
+          React.createElement("section", { style: { marginBottom: "24px", padding: "20px", border: "1px solid var(--memory-border,#263f54)", borderRadius: "10px", background: "var(--memory-panel,#0b1624)" } },
+            React.createElement("h2", { style: { margin: "0 0 12px", fontSize: "20px", color: "var(--memory-accent,#b7e9ff)" } }, "图谱外观"),
+            React.createElement(AppearanceControls, { settings: props.settings, busy: props.configBusy, onChange: props.onAppearanceChange, location: "settings" })),
           React.createElement("section", { style: { marginBottom: "24px", paddingBottom: "20px", borderBottom: "1px solid #263f54" } },
             React.createElement("h2", { style: { margin: "0 0 12px", fontSize: "20px", color: "#b7e9ff" } }, "自动记忆"),
             React.createElement(AutoMemoryToggle, { settings: props.settings, busy: props.configBusy, onToggle: props.onToggle, location: "settings" }),
@@ -580,6 +619,21 @@ window.__ModuleLoader__.load({
       var pointer = React.useRef(null);
       var help = React.useRef(null);
       var dismissed = React.useRef(false);
+      var appearanceState = React.useState(false);
+      var appearanceOpen = appearanceState[0], setAppearanceOpen = appearanceState[1];
+      var appearancePanel = React.useRef(null);
+      var appearanceButton = React.useRef(null);
+      React.useEffect(function () {
+        if (!open || !appearanceOpen) return undefined;
+        var first = appearancePanel.current && appearancePanel.current.querySelector("input:checked");
+        if (first) first.focus();
+        function outside(event) {
+          if (appearancePanel.current && !appearancePanel.current.contains(event.target)
+              && appearanceButton.current && !appearanceButton.current.contains(event.target)) setAppearanceOpen(false);
+        }
+        window.addEventListener("pointerdown", outside);
+        return function () { window.removeEventListener("pointerdown", outside); };
+      }, [open, appearanceOpen]);
       React.useEffect(function () {
         return function () { if (configRequest.current) configRequest.current.abort(); };
       }, []);
@@ -594,6 +648,23 @@ window.__ModuleLoader__.load({
         }).finally(function () { if (!controller.signal.aborted) setConfigBusy(false); });
         return function () { controller.abort(); };
       }, [open]);
+      function saveAppearance(changes) {
+        if (configBusy || configRequest.current) return;
+        if (Object.keys(changes).every(function (key) { return settings[key] === changes[key]; })) return;
+        var previous = settings;
+        var controller = new AbortController();
+        var timer = setTimeout(function () { controller.abort(); }, 10000);
+        configRequest.current = controller;
+        setConfigBusy(true); setConfigError("");
+        setSettings(Object.assign({}, settings, changes));
+        requestApi("/memory-engine/api/config", { method: "PUT", headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(changes), signal: controller.signal }).then(function (data) {
+            if (!controller.signal.aborted) setSettings(Object.assign({}, defaultSettings, data));
+          }).catch(function (failure) {
+            setSettings(previous);
+            setConfigError("外观保存失败，已恢复原设置：" + (controller.signal.aborted ? "请求超时或已中断，请刷新确认状态" : failure.message));
+          }).finally(function () { clearTimeout(timer); configRequest.current = null; setConfigBusy(false); });
+      }
       function saveAutoMemory(enabled) {
         if (configRequest.current) return;
         var previous = settings;
@@ -639,12 +710,13 @@ window.__ModuleLoader__.load({
         dismissed.current = false;
         setGuideOpen(false);
         setSelected(null);
+        setAppearanceOpen(false);
         setTab("map");
         setOpen(Date.now());
       }
-      function closeMap() { setSelected(null); setCostHint(false); setOpen(false); }
+      function closeMap() { setSelected(null); setCostHint(false); setAppearanceOpen(false); setOpen(false); }
       function startPointer(event) {
-        if (event.target.closest("[data-memory-engine-detail], [data-memory-engine-guide-layer], [data-memory-engine-controls]")) { pointer.current = null; return; }
+        if (event.target.closest("[data-memory-engine-detail], [data-memory-engine-guide-layer], [data-memory-engine-controls], [data-memory-engine-appearance-panel]")) { pointer.current = null; return; }
         pointer.current = { x: event.clientX, y: event.clientY, moved: 0, version: selectionVersion.current };
       }
       function movePointer(event) {
@@ -677,7 +749,12 @@ window.__ModuleLoader__.load({
       }, [open, retry, settings.showGuideOnEmpty]);
       React.useEffect(function () {
         if (!open) return undefined;
-        function onEscape() { if (guideOpen) closeGuide(); else if (selected) setSelected(null); else closeMap(); }
+        function onEscape() {
+          if (guideOpen) closeGuide();
+          else if (appearanceOpen) { setAppearanceOpen(false); if (appearanceButton.current) appearanceButton.current.focus(); }
+          else if (selected) setSelected(null);
+          else closeMap();
+        }
         function onKey(event) {
           if (event.key !== "Escape") return;
           if (event.target && event.target.closest && event.target.closest("[data-memory-engine-confirm]")) return;
@@ -687,7 +764,7 @@ window.__ModuleLoader__.load({
         }
         window.addEventListener("keydown", onKey, true);
         return function () { window.removeEventListener("keydown", onKey, true); };
-      }, [open, guideOpen, selected]);
+      }, [open, guideOpen, selected, appearanceOpen]);
       var button = React.createElement("button", {
         type: "button",
         onClick: openMap,
@@ -701,12 +778,15 @@ window.__ModuleLoader__.load({
         role: "dialog",
         "aria-modal": "true",
         "aria-label": "记忆图谱",
+        "data-memory-engine-theme": settings.graphTheme, "data-memory-engine-layout": settings.graphLayout,
         onPointerDownCapture: startPointer, onPointerMoveCapture: movePointer,
         onPointerCancelCapture: function () { pointer.current = null; }, onClick: dismissOutside,
-        style: { position: "fixed", inset: 0, maxWidth: "none", maxHeight: "none", zIndex: 9999, background: "#03060c" },
-      }, tab === "map" ? React.createElement(MemoryCanvas, { key: open, rendererRef: renderer, selectionVersion: selectionVersion, onSelect: setSelected })
+        style: Object.assign({ position: "fixed", inset: 0, maxWidth: "none", maxHeight: "none", zIndex: 9999, background: "#03060c", colorScheme: settings.graphTheme === "paper" ? "light" : "dark" }, appearanceStyles[settings.graphTheme]),
+      }, tab === "map" ? React.createElement(MemoryCanvas, { key: open, rendererRef: renderer, selectionVersion: selectionVersion, onSelect: setSelected,
+        graphTheme: settings.graphTheme, graphLayout: settings.graphLayout })
         : tab === "memories" ? React.createElement(MemoryList, { onChanged: function () { setRetry(function (value) { return value + 1; }); } })
           : React.createElement(MemorySettings, { settings: settings, configBusy: configBusy, onToggle: toggleAutoMemory, onUseAutoImport: useAutoImport,
+            onAppearanceChange: saveAppearance,
             onCleared: function () { openMap(); setGuideOpen(true); } }),
       tab !== "map" ? React.createElement("strong", { style: { position: "absolute", top: "23px", left: "24px", font: "600 18px system-ui,sans-serif", color: "#b7e9ff" } }, "记忆管理") : null,
       React.createElement("style", null, "@keyframes dsh-memory-detail-in{from{opacity:0;transform:translateX(24px)}to{opacity:1;transform:translateX(0)}}@media(prefers-reduced-motion:reduce){[data-memory-engine-detail]{animation:none!important}}"),
@@ -716,9 +796,11 @@ window.__ModuleLoader__.load({
       }, React.createElement("div", { role: "tablist", "aria-label": "记忆面板", style: { display: "flex", gap: "4px", marginRight: "8px" } },
         [["map", "图谱"], ["memories", "记忆"], ["settings", "设置"]].map(function (entry) {
           return React.createElement("button", { key: entry[0], type: "button", role: "tab", "aria-selected": tab === entry[0], "data-memory-engine-tab": entry[0],
-            onClick: function () { setSelected(null); setTab(entry[0]); },
-            style: Object.assign({}, actionStyle, { background: tab === entry[0] ? "#204762" : "#091422", borderColor: tab === entry[0] ? "#8acded" : "#35536b" }) }, entry[1]);
-        })), React.createElement(AutoMemoryToggle, { settings: settings, busy: configBusy, onToggle: toggleAutoMemory, location: "header" }), React.createElement("button", {
+            onClick: function () { setSelected(null); setAppearanceOpen(false); setTab(entry[0]); },
+            style: Object.assign({}, actionStyle, { background: tab === entry[0] ? "var(--memory-button,#204762)" : "var(--memory-panel,#091422)", borderColor: tab === entry[0] ? "var(--memory-accent,#8acded)" : "var(--memory-border,#35536b)" }) }, entry[1]);
+        })), React.createElement("button", { ref: appearanceButton, type: "button", "data-memory-engine-appearance": "true", "aria-expanded": appearanceOpen,
+          "aria-haspopup": "dialog", onClick: function () { setAppearanceOpen(!appearanceOpen); }, style: actionStyle }, "外观"),
+        React.createElement(AutoMemoryToggle, { settings: settings, busy: configBusy, onToggle: toggleAutoMemory, location: "header" }), React.createElement("button", {
         ref: help, type: "button", onClick: function () { setGuideOpen(true); },
         "aria-label": "查看使用指南", title: "使用指南", style: actionStyle,
       }, "?"), React.createElement("button", {
@@ -726,8 +808,15 @@ window.__ModuleLoader__.load({
         onClick: closeMap,
         "aria-label": "关闭记忆图谱",
         style: actionStyle,
-      }, "关闭 ×")), configError ? React.createElement("p", { role: "alert", "data-memory-engine-config-error": "true",
-        style: { position: "absolute", top: "50px", right: "18px", zIndex: 2, color: "#ff9c9c", background: "#271923", padding: "8px 12px", borderRadius: "8px", maxWidth: "min(600px,90vw)" } }, configError) : null,
+      }, "关闭 ×")), appearanceOpen ? React.createElement("section", { ref: appearancePanel, role: "dialog", "aria-label": "外观", "data-memory-engine-appearance-panel": "true",
+        style: { position: "absolute", top: "62px", right: "18px", zIndex: 3, boxSizing: "border-box", width: "min(380px,calc(100vw - 36px))", maxHeight: "calc(100vh - 90px)", overflowY: "auto",
+          padding: "18px", border: "1px solid var(--memory-border,#3976a0)", borderRadius: "12px", background: "var(--memory-panel,#07111f)", boxShadow: "0 12px 35px #0004" } },
+        React.createElement("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: "14px", color: "var(--memory-text,#dbeaf8)" } },
+          React.createElement("strong", null, "外观"), React.createElement("button", { type: "button", "aria-label": "关闭外观", style: actionStyle,
+            onClick: function () { setAppearanceOpen(false); if (appearanceButton.current) appearanceButton.current.focus(); } }, "×")),
+        React.createElement(AppearanceControls, { settings: settings, busy: configBusy, onChange: saveAppearance, location: "header" })) : null,
+      configError ? React.createElement("p", { role: "alert", "data-memory-engine-config-error": "true",
+        style: { position: "absolute", top: "50px", left: "18px", zIndex: 4, color: "#ff9c9c", background: "#271923", padding: "8px 12px", borderRadius: "8px", maxWidth: "min(600px,90vw)" } }, configError) : null,
       costHint ? React.createElement(ConfirmationDialog, { title: "开启自动记忆", message: "自动记忆会在每轮对话后调用一次模型，大约每轮几分钱。可以随时在这里关掉。实际费用以模型及计费方案为准。",
         submitLabel: "知道了，开启", busy: configBusy, onClose: function () { setCostHint(false); }, onConfirm: function () { saveAutoMemory(true); } }) : null,
       selected ? React.createElement(MemoryDetails, {

package/lib/config-write.js

@@ -15,6 +15,8 @@ const writable = new Map([
   ['autoMemory.maxPerTurn', value => Number.isSafeInteger(value) && value >= 1 && value <= 5],
   ['autoMemory.dailyCap', value => Number.isSafeInteger(value) && value >= 0 && value <= 500],
   ['spinSpeed', value => Number.isFinite(value) && value >= 0.05 && value <= 1.5],
+  ['graphTheme', value => ['classic', 'neon', 'paper', 'mono'].includes(value)],
+  ['graphLayout', value => ['sphere', 'flat', 'spiral'].includes(value)],
   ['showGuideOnEmpty', value => typeof value === 'boolean'],
   ['hideButton', value => typeof value === 'boolean'],
 ]);

package/lib/config.js

@@ -14,6 +14,7 @@ export function readUiConfig(home = defaultHome(), options = {}) {
   const config = readConfig(home);
   return { hideButton: config.hideButton === true, showGuideOnEmpty: config.showGuideOnEmpty !== false,
     hasPersona: readPersona(config, options) !== null, personaTitle: config.personaTitle, spinSpeed: config.spinSpeed,
+    graphTheme: config.graphTheme, graphLayout: config.graphLayout,
     autoMemory: { enabled: config.autoMemory.enabled, maxPerTurn: config.autoMemory.maxPerTurn, dailyCap: config.autoMemory.dailyCap },
     showAutoMemoryCostHint: config.showAutoMemoryCostHint !== false,
     autoImport: { enabled: config.autoImport.enabled, sourceCount: config.autoImport.sources.length },
@@ -52,9 +53,13 @@ export function readConfig(home = defaultHome(), { warn } = {}) {
     if (value.spinSpeed !== undefined && (!Number.isFinite(value.spinSpeed) || value.spinSpeed < 0.05 || value.spinSpeed > 1.5)) {
       throw new Error('spinSpeed 必须是 0.05～1.5 的数字');
     }
-    return { ...value, personaTitle: value.personaTitle?.trim() || '角色卡', spinSpeed: value.spinSpeed ?? 0.35, ...automationConfig(value, warn) };
+    for (const [key, choices] of [['graphTheme', ['classic', 'neon', 'paper', 'mono']], ['graphLayout', ['sphere', 'flat', 'spiral']]]) {
+      if (value[key] !== undefined && !choices.includes(value[key])) throw new Error(`${key} 必须是 ${choices.join('、')}`);
+    }
+    return { ...value, personaTitle: value.personaTitle?.trim() || '角色卡', spinSpeed: value.spinSpeed ?? 0.35,
+      graphTheme: value.graphTheme ?? 'classic', graphLayout: value.graphLayout ?? 'sphere', ...automationConfig(value, warn) };
   } catch (error) {
-    if (error.code === 'ENOENT') return { personaTitle: '角色卡', spinSpeed: 0.35, ...automationConfig({}, warn) };
+    if (error.code === 'ENOENT') return { personaTitle: '角色卡', spinSpeed: 0.35, graphTheme: 'classic', graphLayout: 'sphere', ...automationConfig({}, warn) };
     throw new Error(`无法读取 ${file}：${error.message}`);
   }
 }

package/lib/index.js

@@ -83,13 +83,15 @@ export function createTools(defineTool, store = new MemoryStore(), { map = gener
       name: 'memory_forget',
       description: '删除本地记忆。id/q/older_than_days 三选一。q 批量删除先报告数量，用户确认后带 confirm=true 再调用。',
       parameters: {
-        id: { type: 'string', description: '精确删除的记忆 id' },
+        memoryId: { type: 'string', description: '精确删除的记忆 id' },
         q: { type: 'string', description: '按关键词批量删除，必须二次确认' },
         older_than_days: { type: 'number', description: '仅删除超过此天数且留存低于 0.15 的条目' },
         confirm: { type: 'boolean', description: '收到用户对本次关键词批删的确认后才设为 true' },
       }, output,
       async execute(args) {
-        const result = store.forget(args);
+        // id 是 JSON Schema 保留字（draft-04），宿主不转换参数表时会被拒；对外叫 memoryId，内部接受旧的 id。
+        if (args.memoryId === undefined && args.id !== undefined) args.memoryId = args.id;
+        const result = store.forget({ ...args, id: args.memoryId ?? args.id });
         return result.needsConfirmation ? `匹配到 ${result.count} 条，确认请带 confirm=true 再调一次。`
           : `已删除 ${result.count} 条记忆。`;
       },
@@ -138,11 +140,13 @@ export function createTools(defineTool, store = new MemoryStore(), { map = gener
       name: 'memory_map', description: '把当前本地记忆生成可离线打开的神经网络 HTML 图谱，返回文件路径、节点和关联边数量。',
       parameters: {
         out: { type: 'string', description: '输出 HTML 路径，默认 DSH_HOME/memory-engine/starmap.html' },
-        title: { type: 'string', description: '页面标题，默认“我的记忆神经网络”' },
+        pageTitle: { type: 'string', description: '页面标题，默认“我的记忆神经网络”' },
         open: { type: 'boolean', description: '默认 false；true 时用系统默认浏览器打开' },
       }, output,
       async execute(args) {
-        const result = map(store, args);
+        // title 是 JSON Schema 的保留关键字：宿主若不转换参数表，直接发 title 会被 DeepSeek 拒绝（400）。
+        // 所以对外叫 pageTitle，内部仍接受旧的 title 作为别名。
+        const result = map(store, { ...args, title: args.pageTitle ?? args.title });
         if (args.open === true) await openMap(result.file);
         return mapReport(result);
       },

package/lib/index.js.bak-before-titlefix

@@ -0,0 +1,235 @@
+import { MemoryStore } from './store.js';
+import { chars, titleOf } from './decay.js';
+import { generateMap, mapReport, openMap } from './map.js';
+import { registerMemoryRoutes } from './routes.js';
+import { createAutoMemory } from './auto-memory.js';
+import { createAutoImport } from './auto-import.js';
+
+export const name = 'memory-engine';
+export const inject = ['tools', 'webServer'];
+
+function report(ctx, error) {
+  try {
+    const logger = typeof ctx?.logger === 'function' ? ctx.logger(name) : ctx?.logger;
+    logger?.error?.(`memory-engine: ${error?.message ?? String(error)}`);
+  } catch { /* Error reporting must not take down the host. */ }
+}
+
+function warn(ctx, message) {
+  try {
+    const logger = typeof ctx?.logger === 'function' ? ctx.logger(name) : ctx?.logger;
+    if (logger?.warn) logger.warn(message);
+    else console.warn(`[dsh-memory-engine] ${message}`);
+  } catch { /* Preview failures must not affect the memory tools. */ }
+}
+
+export function createTools(defineTool, store = new MemoryStore(), { map = generateMap, warning = message => warn(null, message) } = {}) {
+  const output = { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: value }] };
+  return [
+    defineTool({
+      name: 'memory_save',
+      description: '把值得记住的事保存到跨会话的本地记忆。与 QQ 桥接记忆独立。重复正文自动合并。'
+        + '该存：对方的称呼/偏好/忌讳/习惯、答应过的事、情绪特别重的瞬间、新学到的知识、当天小结。'
+        + '不该存：寒暄、重复内容、纯事务性对话。一天三五条足够，存前可先用 memory_recall 查重。',
+      parameters: {
+        text: { type: 'string', required: true, description: '记忆正文，最多 2000 字' },
+        kind: { type: 'string', description: '分类，默认对话；可用知识/印象/日记/对话/事件或自定义' },
+        heat: { type: 'number', description: '1=热，2=温，3=冷；省略按情绪推断' },
+        who: { type: 'string', description: '跟谁有关' },
+        ts: { type: 'number', description: '事情发生的毫秒时间戳，默认现在' },
+      }, output,
+      async execute(args) {
+        const memory = store.save(args);
+        if (memory.merged) return `已合并到既有记忆（第 ${memory.merged.index} 条，相似度 ${memory.merged.similarity.toFixed(2)}）：${chars(memory.text, 40)}`;
+        return `已记住：${chars(memory.text, 40)}（重要度 ${['', '热', '温', '冷'][memory.heat]}）`;
+      },
+    }),
+    defineTool({
+      name: 'memory_recall',
+      description: '按话题查跨会话的本地记忆，并联想相关条目。q 使用具体关键词，如「手冲」「阅读 书签」。与 QQ 桥接记忆独立。',
+      parameters: {
+        q: { type: 'string', required: true, description: '要查的话题或关键词' },
+        limit: { type: 'number', description: '默认 8，最大 20' },
+        hops: { type: 'number', description: '联想跳数，默认 1；0 只查直接命中，最大 2' },
+        kind: { type: 'string', description: '只看某一分类' },
+      }, output,
+      async execute(args) {
+        const hits = store.recall(args);
+        if (!hits.length) return `【没有找到】「${args.q}」在记忆库里没有相关内容。`;
+        const quote = words => words.map(word => `「${word}」`).join('');
+        let index = 0;
+        const describe = hit => `${++index}. [${hit.kind}] ${titleOf(hit)}（留存 ${hit.retention.toFixed(2)}；id=${hit.id}）`;
+        const sections = [];
+        for (const via of ['direct', 'partial']) {
+          const group = hits.filter(hit => hit.via === via);
+          if (!group.length) continue;
+          const terms = group[0].terms;
+          const matched = terms.filter(term => group.some(hit => hit.matched.includes(term)));
+          const missed = terms.filter(term => !matched.includes(term));
+          const label = via === 'direct' ? '直接命中' : '部分命中';
+          const summary = `【${label} ${group.length} 条】` + (via === 'partial' ? '（覆盖不足 50%，不是直接命中）' : '')
+            + `命中${quote(matched)}` + (missed.length ? `；未命中${quote(missed)}` : '；全部查询词均命中');
+          sections.push([summary, ...group.map(hit => `${describe(hit)}\n`
+            + `   覆盖 ${hit.matched.length}/${hit.terms.length}；命中${quote(hit.matched)}`
+            + (hit.missed.length ? `；未命中${quote(hit.missed)}` : '') + `\n   ${hit.snippet}`)].join('\n\n'));
+        }
+        const spread = hits.filter(hit => hit.via === 'spread');
+        if (spread.length) sections.push(['【联想到的（不是直接命中）】', ...spread.map(hit => `${describe(hit)}\n`
+          + `   从「${hit.from.title}」（id=${hit.from.id}）联想：完整标题「${hit.from.term}」出现在关联正文中。\n   ${hit.snippet}`)].join('\n\n'));
+        return sections.join('\n\n');
+      },
+    }),
+    defineTool({
+      name: 'memory_forget',
+      description: '删除本地记忆。id/q/older_than_days 三选一。q 批量删除先报告数量，用户确认后带 confirm=true 再调用。',
+      parameters: {
+        id: { type: 'string', description: '精确删除的记忆 id' },
+        q: { type: 'string', description: '按关键词批量删除，必须二次确认' },
+        older_than_days: { type: 'number', description: '仅删除超过此天数且留存低于 0.15 的条目' },
+        confirm: { type: 'boolean', description: '收到用户对本次关键词批删的确认后才设为 true' },
+      }, output,
+      async execute(args) {
+        const result = store.forget(args);
+        return result.needsConfirmation ? `匹配到 ${result.count} 条，确认请带 confirm=true 再调一次。`
+          : `已删除 ${result.count} 条记忆。`;
+      },
+    }),
+    defineTool({
+      name: 'memory_dedupe', description: '检测全库相似重复记忆。默认只预览；用户确认后显式 dry_run=false 才备份并合并。',
+      parameters: {
+        threshold: { type: 'number', description: 'LCS 相似度阈值，默认 0.7，范围 0.5–0.95' },
+        dry_run: { type: 'boolean', description: '默认 true，只报告；false 备份后执行合并' },
+      }, output,
+      async execute(args) {
+        const result = store.dedupe(args);
+        if (!result.dryRun) return `已合并 ${result.groups.length} 组，删除 ${result.removed} 条。备份：${result.backup}（耗时 ${result.elapsedMs.toFixed(0)}ms）`;
+        const involved = result.groups.reduce((sum, group) => sum + group.texts.length, 0);
+        return [`发现 ${result.groups.length} 组重复（共 ${involved} 条 → 可合并为 ${result.groups.length} 条）`,
+          ...result.groups.map((group, index) => `组 ${index + 1}：${group.texts.length} 条 → 保留「${chars(group.memory.text, 80)}」（boosts 合计 ${group.memory.boosts}）\n`
+            + group.texts.map(text => `  - ${chars(text, 80)}`).join('\n')),
+          '确认执行请带 dry_run=false', `耗时 ${result.elapsedMs.toFixed(0)}ms`].join('\n');
+      },
+    }),
+    defineTool({
+      name: 'memory_import', description: '从 JSON、Markdown 目录、逐行纯文本或 qq-bridge 导入本地记忆。默认只预览，显式 dry_run=false 才备份并导入；不会修改来源。新增后自动生成图谱。',
+      parameters: {
+        source: { type: 'string', required: true, description: 'qq-bridge / json / markdown / text' },
+        path: { type: 'string', description: 'json/text 的本地文件绝对路径，或 markdown 的目录绝对路径；qq-bridge 无需此参数' },
+        dry_run: { type: 'boolean', description: '默认 true，只报告；false 先备份本插件记忆再导入' },
+      }, output,
+      async execute(args) {
+        const result = args.source === 'qq-bridge' ? store.importBridge(args) : await store.importFile(args);
+        if (result.missing) return '找不到桥接目录，可用 QQ_BRIDGE_DIR 环境变量指定';
+        let mapLine;
+        if (!result.dryRun && result.imported > 0) {
+          try { mapLine = `已同步生成神经网络图：${map(store).file}`; }
+          catch (error) { warning(`图谱生成失败，记忆已成功导入：${error.message}`); }
+        }
+        return [result.dryRun ? `将从 ${args.source} 导入：` : `已从 ${args.source} 导入：`,
+          ...Object.entries(result.counts).map(([kind, count]) => `- ${kind} ${count} 条（${result.dryRun ? '可新增' : '新增'} ${result.added[kind]} 条）`),
+          `合计 ${result.candidates} 条；其中 ${result.skipped} 条与现有或本批重复会被跳过。`,
+          `${result.dryRun ? '预计导入后' : '导入后'}总数：${result.total} 条（新增 ${result.imported} 条）`,
+          ...(result.dryRun ? ['确认执行请带 dry_run=false'] : [`备份：${result.backup}`]),
+          ...(result.warnings.length ? ['来源提示：', ...result.warnings] : []),
+          `耗时 ${(result.elapsedMs / 1000).toFixed(2)} 秒`, ...(mapLine ? [mapLine] : [])].join('\n');
+      },
+    }),
+    defineTool({
+      name: 'memory_map', description: '把当前本地记忆生成可离线打开的神经网络 HTML 图谱，返回文件路径、节点和关联边数量。',
+      parameters: {
+        out: { type: 'string', description: '输出 HTML 路径，默认 DSH_HOME/memory-engine/starmap.html' },
+        title: { type: 'string', description: '页面标题，默认“我的记忆神经网络”' },
+        open: { type: 'boolean', description: '默认 false；true 时用系统默认浏览器打开' },
+      }, output,
+      async execute(args) {
+        const result = map(store, args);
+        if (args.open === true) await openMap(result.file);
+        return mapReport(result);
+      },
+    }),
+    defineTool({
+      name: 'memory_stats', description: '查看本地记忆总数、分类、衰减状态、最老日期和存储路径及体积。',
+      parameters: {}, output,
+      async execute() {
+        const stats = store.stats();
+        const kinds = Object.entries(stats.kinds).map(([kind, count]) => `${kind} ${count}`).join(' / ');
+        const body = `记忆引擎状态\n- 总条数：${stats.total}${kinds ? `（${kinds}）` : ''}\n`
+          + `- 快忘了的（留存<0.3）：${stats.fading} 条\n`
+          + `- 最老：${stats.oldest === null ? '暂无' : `${new Date(stats.oldest).toISOString().slice(0, 10)}（${stats.ageDays} 天前）`}\n`
+          + `- 存储：${stats.file}（${(stats.bytes / 1024).toFixed(1)} KB）`;
+        // 库是空的时，替 agent 把「接下来该做什么」说出来（见 README「装完是空库」）。
+        if (stats.total === 0) {
+          return body + '\n\n记忆库还是空的。插件不会自己读聊天记录，记忆要靠两件事之一进来：\n'
+            + '① 在提示词里告诉 agent 该记什么，聊天时就调 memory_save（推荐）\n'
+            + '② 用 memory_import 把旧记忆导进来（支持 json / markdown / text）\n'
+            + '建议主动把这两条简短告诉主人，并提醒他点开图谱可以看到上手引导页。';
+        }
+        return body;
+      },
+    }),
+  ];
+}
+
+// 宿主 SDK 的 defineTool 在不同 DSH 版本间签名一致（实测 0.1.0-rc.8 ~ 0.2.2-alpha.2 都是
+// defineTool(options)），但**包不一定能解析到**——比如插件被装在宿主 node_modules 之外。
+// 解析失败时退回一个直通实现：工具照常注册，只是少了宿主的返回值包装。
+async function resolveDefineTool(warning) {
+  try {
+    const sdk = await import('@deepseek-ai/dsh-tools');
+    if (typeof sdk.defineTool === 'function') {
+      const version = sdk.version ?? '';
+      if (version) warning(`宿主 dsh-tools 版本 ${version}`);
+      return sdk.defineTool;
+    }
+    warning('@deepseek-ai/dsh-tools 没有导出 defineTool，改用内置直通实现');
+  } catch (error) {
+    warning(`解析 @deepseek-ai/dsh-tools 失败（${error.message}），改用内置直通实现`);
+  }
+  return options => options;
+}
+
+export function apply(ctx) {
+  try {
+    if (typeof ctx?.tools?.register !== 'function') throw new Error('tools 服务不可用');
+    // ctx.effect 是较新宿主才有的生命周期钩子。没有它就直接注册——
+    // 否则老版本 DSH 上插件会「装上了但一个工具都没有」，这是最糟的失败方式。
+    const setup = async () => {
+      const disposers = [];
+      try {
+        const defineTool = await resolveDefineTool(message => warn(ctx, message));
+        const store = new MemoryStore();
+        for (const tool of createTools(defineTool, store, { warning: message => warn(ctx, message) })) disposers.push(ctx.tools.register(tool));
+        try {
+          disposers.push(registerMemoryRoutes(ctx.webServer, { store, warn: message => warn(ctx, message),
+            listSessions: () => ctx.get('sessionQuery')?.listSessions() }));
+        } catch (error) {
+          warn(ctx, `图谱路由注册失败，记忆工具仍可用：${error.message}`);
+        }
+        for (const create of [createAutoMemory, createAutoImport]) {
+          try {
+            const automation = create({ ctx, store, warn: message => warn(ctx, message) });
+            disposers.push(() => automation.dispose());
+          } catch (error) { warn(ctx, `自动任务初始化失败，记忆工具仍可用：${error.message}`); }
+        }
+        const timer = setTimeout(() => {
+          try { if (store.read().length > 0) generateMap(store); }
+          catch (error) { warn(ctx, `启动时图谱生成失败：${error.message}`); }
+        }, 3000);
+        timer.unref();
+        disposers.push(() => clearTimeout(timer));
+        return () => { for (const dispose of disposers.reverse()) dispose(); };
+      } catch (error) {
+        for (const dispose of disposers.reverse()) { try { dispose(); } catch { /* keep unwinding */ } }
+        report(ctx, error);
+      }
+    };
+
+    if (typeof ctx.effect === 'function') {
+      const registration = ctx.effect(setup, 'memory-engine.tools');
+      // Await setup without returning its disposer as a second plugin teardown.
+      return Promise.resolve(registration).then(() => undefined, error => { report(ctx, error); });
+    }
+    warn(ctx, '宿主没有 ctx.effect，直接用注册式初始化（功能不减少）');
+    return Promise.resolve(setup()).then(() => undefined, error => { report(ctx, error); });
+  } catch (error) { report(ctx, error); }
+}

package/lib/map.js

@@ -21,6 +21,7 @@ export function computeMapData(store, { warn } = {}) {
   return { generatedAt: now, nodes, links: scored.links, review: scored.review,
     core: core ? { id: core.id, title: core.title, preview: Array.from(core.text).slice(0, 120).join('') + (Array.from(core.text).length > 120 ? '…' : '') } : null,
     spinSpeed: config.spinSpeed,
+    graphTheme: config.graphTheme, graphLayout: config.graphLayout,
     stats: { total: nodes.length, byKind: kinds, forgettingSoon: nodes.filter(node => node.retention < 0.3).length } };
 }