@modusensus/dsh-mneme 0.1.2 → 0.1.4

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![dsh-plugin](https://img.shields.io/badge/dsh-plugin-awesome-orange)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-106%20passed-success)](https://github.com/modusensus/dsh-mneme)
+[![tests](https://img.shields.io/badge/tests-129%20passed-success)](https://github.com/modusensus/dsh-mneme)
 
 > 给 DeepSeek Harness 的跨会话记忆插件：让 Agent 记住你、记住项目、自动整理记忆。**Mneme**（Μνήμη）——希腊记忆女神 Mnemosyne 之名，掌管记忆与梦境，正如 autoDream 在后台巩固记忆。
 
@@ -47,6 +47,16 @@
 
 侧边栏"记忆"按钮 → 模态面板：按类型浏览、全文搜索、查看详情。
 
+### 用户设置（画像 / 规则）与自定义指令 ⚙️
+
+侧边栏"设置"按钮 → 设置面板：
+
+- **用户画像**：一段自由文本描述用户自己（角色、背景、偏好），**每轮注入**到系统提示，让 Agent 始终遵循
+- **规则**：Agent 必须遵守的行为规则列表（如"回答先给结论"），同样每轮注入
+- **自定义指令**：注册斜杠命令（`/名称`），触发时把用户定义的指令内容交给 Agent。命令持久化到 SQLite，启动时自动注册到 DSH 命令表，增删实时生效
+
+> 画像与规则通过独立的 `[用户设置]` 注入区块（优先级高于记忆库），即使记忆为空也会注入。
+
 ## 📦 安装
 
 ### 前置条件
@@ -150,7 +160,7 @@ src/
 lib/
 ├── client.js         # Web 面板（手写 ModuleLoader bundle）
 └── *.js              # src 的同步分发产物
-test/                 # 106 个 node:test 测试
+test/                 # 129 个 node:test 测试
 ```
 
 ## 🧪 开发
@@ -158,7 +168,7 @@ test/                 # 106 个 node:test 测试
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 106 个测试（--test-isolation=none 用于受限沙箱，禁止子进程 spawn）
+npm test           # 运行 129 个测试（--test-isolation=none 用于受限沙箱，禁止子进程 spawn）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```
 

package/lib/api.js

@@ -5,19 +5,41 @@ function sendJson(res, status, payload) {
   res.end(JSON.stringify(payload));
 }
 
-export function createApi(ctx, service) {
+/** Collect the request body as text (tolerant of empty/invalid bodies). */
+function readBody(req) {
+  return new Promise((resolve) => {
+    let body = "";
+    req.on("data", (chunk) => { body += chunk; });
+    req.on("end", () => resolve(body));
+    req.on("error", () => resolve(""));
+  });
+}
+
+function parseBody(text) {
+  try {
+    return JSON.parse(text || "{}");
+  } catch {
+    return {};
+  }
+}
+
+export function createApi(ctx, service, settings, commands) {
   const disposers = [];
 
+  const register = (route) => {
+    disposers.push(ctx.webServer.register(route));
+  };
+
   // /api/dsh-mneme prefix fallback → 404 JSON for unknown sub-paths
-  disposers.push(ctx.webServer.register({
+  register({
     kind: "prefix",
     path: "/api/dsh-mneme",
     handler(req, res) {
       sendJson(res, 404, { error: "not-found" });
     }
-  }));
+  });
 
-  disposers.push(ctx.webServer.register({
+  register({
     kind: "exact",
     path: "/api/dsh-mneme/list",
     handler(req, res) {
@@ -32,9 +54,9 @@ export function createApi(ctx, service) {
         sendJson(res, 500, { error: "internal" });
       }
     }
-  }));
+  });
 
-  disposers.push(ctx.webServer.register({
+  register({
     kind: "exact",
     path: "/api/dsh-mneme/search",
     handler(req, res) {
@@ -48,10 +70,85 @@ export function createApi(ctx, service) {
         sendJson(res, 500, { error: "internal" });
       }
     }
-  }));
+  });
+
+  // --- user profile ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/profile",
+    handler(req, res) {
+      try {
+        if (req.method === "PUT" || req.method === "POST") {
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            settings.setProfile(typeof body.profile === "string" ? body.profile : "");
+            sendJson(res, 200, { profile: settings.getProfile() });
+          });
+        }
+        sendJson(res, 200, { profile: settings.getProfile() });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- rules ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/rules",
+    handler(req, res) {
+      try {
+        if (req.method === "PUT" || req.method === "POST") {
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            settings.setRules(Array.isArray(body.rules) ? body.rules : []);
+            sendJson(res, 200, { rules: settings.getRules() });
+          });
+        }
+        sendJson(res, 200, { rules: settings.getRules() });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- custom commands ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/commands",
+    handler(req, res) {
+      try {
+        if (req.method === "POST") {
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            try {
+              const command = commands.add({
+                name: body.name,
+                description: body.description,
+                instruction: body.instruction
+              });
+              sendJson(res, 200, { command });
+            } catch (error) {
+              sendJson(res, 400, { error: error.message });
+            }
+          });
+        }
+        if (req.method === "DELETE") {
+          const url = new URL(req.url, "http://localhost");
+          const id = url.searchParams.get("id");
+          const removed = id ? commands.remove(id) : false;
+          sendJson(res, 200, { removed });
+          return;
+        }
+        sendJson(res, 200, { commands: commands.list() });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
 
   return {
-    routes: 3,
+    routes: 6,
     dispose: () => {
       for (const dispose of disposers) dispose();
     }

package/lib/client.js

@@ -23,7 +23,25 @@ window.__ModuleLoader__.load({
         "memory.tab.preference": "偏好",
         "memory.tab.project": "项目",
         "memory.tab.decision": "决策",
-        "memory.tab.history": "历史"
+        "memory.tab.history": "历史",
+        "memory.settings.open": "设置",
+        "memory.settings.title": "记忆库设置",
+        "memory.settings.profile": "用户画像",
+        "memory.settings.profileHint": "描述你自己（角色、背景、偏好），Agent 会在每轮遵循",
+        "memory.settings.profileSave": "保存画像",
+        "memory.settings.profileSaved": "画像已保存",
+        "memory.settings.rules": "规则",
+        "memory.settings.rulesHint": "Agent 必须遵守的行为规则，每轮注入",
+        "memory.settings.ruleAdd": "添加规则",
+        "memory.settings.rulePlaceholder": "例如：回答时总是先给结论",
+        "memory.settings.commands": "自定义指令",
+        "memory.settings.commandsHint": "注册斜杠命令（/名称），触发时把指令内容交给 Agent",
+        "memory.settings.cmdName": "命令名",
+        "memory.settings.cmdDesc": "描述",
+        "memory.settings.cmdInstruction": "指令内容",
+        "memory.settings.cmdAdd": "添加命令",
+        "memory.settings.cmdDelete": "删除",
+        "memory.settings.empty": "暂无内容"
       },
       en: {
         "memory.panel.title": "Memory",
@@ -34,7 +52,25 @@ window.__ModuleLoader__.load({
         "memory.tab.preference": "Preferences",
         "memory.tab.project": "Projects",
         "memory.tab.decision": "Decisions",
-        "memory.tab.history": "History"
+        "memory.tab.history": "History",
+        "memory.settings.open": "Settings",
+        "memory.settings.title": "Memory Settings",
+        "memory.settings.profile": "User Profile",
+        "memory.settings.profileHint": "Describe yourself — the agent follows this every turn",
+        "memory.settings.profileSave": "Save Profile",
+        "memory.settings.profileSaved": "Profile saved",
+        "memory.settings.rules": "Rules",
+        "memory.settings.rulesHint": "Behavior rules the agent must follow every turn",
+        "memory.settings.ruleAdd": "Add Rule",
+        "memory.settings.rulePlaceholder": "e.g. Always lead with a conclusion",
+        "memory.settings.commands": "Custom Commands",
+        "memory.settings.commandsHint": "Register slash commands (/name) whose instruction is handed to the agent",
+        "memory.settings.cmdName": "Name",
+        "memory.settings.cmdDesc": "Description",
+        "memory.settings.cmdInstruction": "Instruction",
+        "memory.settings.cmdAdd": "Add Command",
+        "memory.settings.cmdDelete": "Delete",
+        "memory.settings.empty": "Nothing yet"
       }
     };
 
@@ -134,6 +170,163 @@ window.__ModuleLoader__.load({
       );
     }
 
+    const h = react.createElement;
+
+    // --- Settings panel: user profile, rules, custom commands ---
+    function SettingsPanel({ t, onClose }) {
+      const [profile, setProfile] = react.useState("");
+      const [rules, setRules] = react.useState([]);
+      const [commands, setCommands] = react.useState([]);
+      const [newRule, setNewRule] = react.useState("");
+      const [newCmd, setNewCmd] = react.useState({ name: "", description: "", instruction: "" });
+      const [saved, setSaved] = react.useState(false);
+      const [cmdError, setCmdError] = react.useState("");
+
+      const load = react.useCallback(async () => {
+        try {
+          const [p, r, c] = await Promise.all([
+            fetch("/api/dsh-mneme/profile").then((res) => res.json()),
+            fetch("/api/dsh-mneme/rules").then((res) => res.json()),
+            fetch("/api/dsh-mneme/commands").then((res) => res.json())
+          ]);
+          setProfile(p.profile || "");
+          setRules(Array.isArray(r.rules) ? r.rules : []);
+          setCommands(Array.isArray(c.commands) ? c.commands : []);
+        } catch { /* ignore */ }
+      }, []);
+
+      react.useEffect(() => { load(); }, [load]);
+
+      async function saveProfile() {
+        try {
+          await fetch("/api/dsh-mneme/profile", {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ profile })
+          });
+          setSaved(true);
+          setTimeout(() => setSaved(false), 1500);
+        } catch { /* ignore */ }
+      }
+
+      async function putRules(next) {
+        await fetch("/api/dsh-mneme/rules", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ rules: next })
+        });
+      }
+
+      async function addRule() {
+        const text = newRule.trim();
+        if (!text) return;
+        const next = [...rules, text];
+        await putRules(next);
+        setRules(next);
+        setNewRule("");
+      }
+
+      async function removeRule(index) {
+        const next = rules.filter((_, i) => i !== index);
+        await putRules(next);
+        setRules(next);
+      }
+
+      async function addCommand() {
+        const name = newCmd.name.trim();
+        const instruction = newCmd.instruction.trim();
+        if (!name || !instruction) return;
+        try {
+          const res = await fetch("/api/dsh-mneme/commands", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name, description: newCmd.description, instruction })
+          });
+          const data = await res.json();
+          if (!res.ok) { setCmdError(data.error || "failed"); return; }
+          setCmdError("");
+          setCommands([...commands, data.command]);
+          setNewCmd({ name: "", description: "", instruction: "" });
+        } catch { setCmdError("failed"); }
+      }
+
+      async function removeCommand(id) {
+        await fetch(`/api/dsh-mneme/commands?id=${encodeURIComponent(id)}`, { method: "DELETE" });
+        setCommands(commands.filter((c) => c.id !== id));
+      }
+
+      const inputStyle = { ...styles.search, marginBottom: 8 };
+      const labelStyle = { fontSize: 12, fontWeight: 600, margin: "12px 0 4px" };
+      const hintStyle = { fontSize: 11, color: "var(--dsw-alias-label-tertiary, #999)", marginBottom: 8 };
+      const rowStyle = { display: "flex", justifyContent: "space-between", alignItems: "center", gap: 8, padding: "6px 0", borderBottom: "1px solid var(--dsw-alias-border-l1, #eee)" };
+
+      return createPortal(
+        h("div", { style: styles.overlay },
+          h("div", { style: styles.panel },
+            h("div", { style: styles.header },
+              h("span", { style: styles.title }, t("memory.settings.title")),
+              h("button", { style: styles.close, onClick: onClose }, "×")
+            ),
+            h("div", { style: { overflowY: "auto" } },
+              // profile
+              h("div", { style: labelStyle }, t("memory.settings.profile")),
+              h("div", { style: hintStyle }, t("memory.settings.profileHint")),
+              h("textarea", {
+                style: { ...inputStyle, minHeight: 72, resize: "vertical", fontFamily: "inherit" },
+                value: profile,
+                placeholder: t("memory.settings.profile"),
+                onChange: (e) => setProfile(e.target.value)
+              }),
+              h("div", null,
+                h("button", { style: styles.footerButton, onClick: saveProfile }, t("memory.settings.profileSave")),
+                saved && h("span", { style: { fontSize: 12, color: "var(--dsw-alias-state-success, #2a7)" } }, t("memory.settings.profileSaved"))
+              ),
+              // rules
+              h("div", { style: labelStyle }, t("memory.settings.rules")),
+              h("div", { style: hintStyle }, t("memory.settings.rulesHint")),
+              rules.length === 0 && h("div", { style: styles.hint }, t("memory.settings.empty")),
+              rules.map((rule, i) =>
+                h("div", { key: i, style: rowStyle },
+                  h("span", { style: { fontSize: 13, flex: 1 } }, rule),
+                  h("button", { style: { ...styles.footerButton, color: "var(--dsw-alias-state-error, #c33)" }, onClick: () => removeRule(i) }, "×")
+                )
+              ),
+              h("div", { style: { display: "flex", gap: 6 } },
+                h("input", {
+                  style: { ...inputStyle, flex: 1, marginBottom: 0 },
+                  value: newRule,
+                  placeholder: t("memory.settings.rulePlaceholder"),
+                  onChange: (e) => setNewRule(e.target.value)
+                }),
+                h("button", { style: styles.footerButton, onClick: addRule }, t("memory.settings.ruleAdd"))
+              ),
+              // custom commands
+              h("div", { style: labelStyle }, t("memory.settings.commands")),
+              h("div", { style: hintStyle }, t("memory.settings.commandsHint")),
+              commands.length === 0 && h("div", { style: styles.hint }, t("memory.settings.empty")),
+              commands.map((cmd) =>
+                h("div", { key: cmd.id, style: rowStyle },
+                  h("div", { style: { flex: 1 } },
+                    h("div", { style: { fontSize: 13, fontWeight: 600 } }, `/${cmd.name}`),
+                    h("div", { style: { fontSize: 11, color: "var(--dsw-alias-label-tertiary, #999)" } }, cmd.description || cmd.instruction)
+                  ),
+                  h("button", { style: { ...styles.footerButton, color: "var(--dsw-alias-state-error, #c33)" }, onClick: () => removeCommand(cmd.id) }, t("memory.settings.cmdDelete"))
+                )
+              ),
+              h("div", { style: { display: "grid", gap: 6, marginTop: 6 } },
+                h("input", { style: { ...inputStyle, marginBottom: 0 }, value: newCmd.name, placeholder: t("memory.settings.cmdName"), onChange: (e) => setNewCmd({ ...newCmd, name: e.target.value }) }),
+                h("input", { style: { ...inputStyle, marginBottom: 0 }, value: newCmd.description, placeholder: t("memory.settings.cmdDesc"), onChange: (e) => setNewCmd({ ...newCmd, description: e.target.value }) }),
+                h("textarea", { style: { ...inputStyle, marginBottom: 0, minHeight: 48, resize: "vertical", fontFamily: "inherit" }, value: newCmd.instruction, placeholder: t("memory.settings.cmdInstruction"), onChange: (e) => setNewCmd({ ...newCmd, instruction: e.target.value }) }),
+                h("button", { style: styles.footerButton, onClick: addCommand }, t("memory.settings.cmdAdd")),
+                cmdError && h("div", { style: { fontSize: 12, color: "var(--dsw-alias-state-error, #c33)" } }, cmdError)
+              )
+            )
+          )
+        ),
+        document.body
+      );
+    }
+
     const styles = {
       overlay: { position: "fixed", inset: 0, background: "rgba(0,0,0,0.4)", zIndex: 1000, display: "flex", alignItems: "center", justifyContent: "center" },
       panel: { background: "var(--dsw-alias-bg-base, #fff)", borderRadius: 12, width: 640, maxWidth: "90vw", maxHeight: "80vh", display: "flex", flexDirection: "column", padding: 16, boxShadow: "0 8px 40px rgba(0,0,0,0.2)" },
@@ -168,12 +361,18 @@ window.__ModuleLoader__.load({
             inject: () => ({})
           }, () => {
             const [open, setOpen] = react.useState(false);
+            const [openSettings, setOpenSettings] = react.useState(false);
             return react.createElement(react.Fragment, null,
               react.createElement("button", {
                 onClick: () => setOpen(true),
                 style: { ...styles.footerButton, ...(open ? styles.footerButtonActive : {}) }
               }, t("memory.panel.open")),
-              open && react.createElement(MemoryPanel, { t, onClose: () => setOpen(false) })
+              react.createElement("button", {
+                onClick: () => setOpenSettings(true),
+                style: { ...styles.footerButton, ...(openSettings ? styles.footerButtonActive : {}) }
+              }, t("memory.settings.open")),
+              open && react.createElement(MemoryPanel, { t, onClose: () => setOpen(false) }),
+              openSettings && react.createElement(SettingsPanel, { t, onClose: () => setOpenSettings(false) })
             );
           })
         );

package/lib/commands.js

@@ -0,0 +1,64 @@
+// Custom slash-command manager: keeps the DSH command registry in sync with
+// user-defined commands persisted in SQLite. Commands are registered on boot
+// and (re)registered on add/remove through the API.
+//
+// Each custom command's handler returns the user-authored instruction as a
+// success result; the DSH UI surfaces it as a model-directed instruction.
+export function createCommandManager({ ctx, settings, logger }) {
+  const registered = new Map(); // name -> disposer
+
+  function registerOne(command) {
+    if (registered.has(command.name)) return;
+    let dispose;
+    try {
+      dispose = ctx.commands.register({
+        name: command.name,
+        description: command.description || `自定义指令 ${command.name}`,
+        handler: () => ({ kind: "success", text: command.instruction })
+      });
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme: failed to register command /${command.name}: ${String(error)}`);
+      return;
+    }
+    registered.set(command.name, dispose);
+  }
+
+  function unregisterOne(name) {
+    const dispose = registered.get(name);
+    if (dispose) {
+      try {
+        dispose();
+      } catch {
+        /* ignore double-dispose */
+      }
+      registered.delete(name);
+    }
+  }
+
+  /** Register every stored command (boot-time sync). */
+  function sync() {
+    for (const command of settings.listCommands()) registerOne(command);
+  }
+
+  /** Add (or replace) a command and register it live. */
+  function add({ name, description, instruction }) {
+    const command = settings.addCommand({ name, description, instruction });
+    registerOne(command);
+    return command;
+  }
+
+  /** Remove a command by id and unregister it live. */
+  function remove(id) {
+    const existing = settings.listCommands().find((c) => c.id === id);
+    if (!existing) return false;
+    if (!settings.removeCommand(id)) return false;
+    unregisterOne(existing.name);
+    return true;
+  }
+
+  function dispose() {
+    for (const name of [...registered.keys()]) unregisterOne(name);
+  }
+
+  return { sync, add, remove, list: () => settings.listCommands(), dispose };
+}

package/lib/dream.js

@@ -62,6 +62,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   let running = false;
   let disposed = false;
   let baseline = { count: 0, chars: 0 };
+  let inFlight = null;
 
   function shouldTrigger(service) {
     const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
@@ -81,8 +82,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       running = true;
       // Defer the onRun invocation so a synchronous throw cannot escape the
       // timer callback (which would crash the process) and skip the teardown.
-      // Errors are logged, never swallowed silently.
-      Promise.resolve()
+      // Errors are logged, never swallowed silently. inFlight lets dispose()
+      // await the running consolidation before the caller closes the store.
+      inFlight = Promise.resolve()
         .then(() => (onRun ? onRun() : Promise.resolve({ ok: true, skipped: true })))
         .then((result) => {
           // Refresh the baseline only for a successful run (design §5.3: an
@@ -105,17 +107,19 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         })
         .finally(() => {
           running = false;
+          inFlight = null;
         });
     }, delayMs);
     return true;
   }
 
-  function dispose() {
+  async function dispose() {
     disposed = true;
     if (pendingTimer) { clearTimeout(pendingTimer); pendingTimer = null; }
-    // An in-flight run is left to complete naturally: its LLM calls are
-    // already paid for and aborting would discard the work. The caller is
-    // responsible for closing the store only after the run has finished.
+    // An in-flight run is left to complete naturally (its LLM calls are
+    // already paid for and aborting would discard the work). Await it so the
+    // caller can close the store only after every write has landed.
+    if (inFlight) await inFlight.catch(() => {});
   }
 
   async function runDream(ctx, service, config) {

package/lib/index.js

@@ -6,13 +6,15 @@ import { createInjector } from "./inject.js";
 import { createSummarizer } from "./summarize.js";
 import { createDreamScheduler } from "./dream.js";
 import { createApi } from "./api.js";
+import { createSettings } from "./settings.js";
+import { createCommandManager } from "./commands.js";
 import { Config } from "./config.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
 export const name = "dsh-mneme";
-export const inject = ["tools", "systemPrompt", "webServer", "llm", "agentDefaultModel"];
+export const inject = ["tools", "systemPrompt", "webServer", "llm", "agentDefaultModel", "commands"];
 export { Config };
 
 // Arrow (not function declaration): cordis 4 treats any apply with a
@@ -33,10 +35,28 @@ export const apply = (ctx, config) => {
   const mirror = createMirror(memoryDir);
   const service = createService({ store, mirror, config: cfg });
 
+  // User-configurable settings (profile, rules) and custom commands share the
+  // same SQLite file but live in dedicated tables, isolated from memories.
+  const settings = createSettings(store.db);
+
+  // Custom commands: register persisted commands into the DSH command registry
+  // on boot; add/remove re-register live through the API.
+  let commands = null;
+  if (ctx.commands) {
+    commands = createCommandManager({ ctx, settings, logger: ctx.logger });
+    commands.sync();
+  }
+
   // Human edits in mirror files win on every sync; merge them back first.
-  // TYPE_FILE maps each memory type to its mirror filename.
+  // TYPE_FILE maps each memory type to its mirror filename. Read every type's
+  // edits up front: mergeHumanEdits re-renders ALL mirror files on success, so
+  // a per-type read-then-merge loop would overwrite edits in files not yet read
+  // (e.g. preferences.md merging would clobber unsynced projects.md edits).
+  const humanEdits = new Map();
   for (const type of Object.keys(TYPE_FILE)) {
-    const edits = mirror.readHumanEdits(type);
+    humanEdits.set(type, mirror.readHumanEdits(type));
+  }
+  for (const [type, edits] of humanEdits) {
     if (edits.length) service.mergeHumanEdits(type, edits);
   }
 
@@ -61,7 +81,7 @@ export const apply = (ctx, config) => {
   const disposers = [];
 
   ctx.inject(["systemPrompt"], (promptCtx) => {
-    if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, cfg));
+    if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, settings, cfg));
   });
 
   ctx.inject(["tools"], (toolsCtx) => {
@@ -72,15 +92,23 @@ export const apply = (ctx, config) => {
   disposers.push(summarizer.dispose);
 
   if (ctx.webServer) {
-    const api = createApi(ctx, service);
+    const api = createApi(ctx, service, settings, commands ?? {
+      add: () => { throw new Error("commands unavailable"); },
+      remove: () => false,
+      list: () => []
+    });
     disposers.push(api.dispose);
   }
 
-  return () => {
+  // Async disposer: cordis awaits the returned promise on unload (runDisposable),
+  // so an in-flight dream run is allowed to finish before the SQLite store is
+  // closed — dream.dispose() resolves only after its current run settles.
+  return async () => {
     for (const dispose of disposers) {
       if (typeof dispose === "function") dispose();
     }
-    if (dream) dream.dispose();
+    commands?.dispose();
+    if (dream) await dream.dispose();
     store.close();
   };
 };

package/lib/inject.js

@@ -1,4 +1,4 @@
-export function createInjector(ctx, service, config) {
+export function createInjector(ctx, service, settings, config) {
   const maxItems = config.maxInjectedItems ?? 5;
   const threshold = config.importanceThreshold ?? 3;
 
@@ -11,12 +11,37 @@ export function createInjector(ctx, service, config) {
     return lines.join("\n");
   }
 
-  return ctx.systemPrompt.context({
-    name: "memory",
-    order: 90,
-    text: () => {
-      const candidates = service.injectCandidates({ maxItems, threshold });
-      return render(candidates);
+  // User profile + rules: injected ahead of the memory block because they are
+  // always-relevant instructions the agent should follow every turn.
+  function renderUserSettings() {
+    const profile = settings.getProfile().trim();
+    const rules = settings.getRules();
+    if (!profile && !rules.length) return "";
+    const lines = ["[用户设置] 来自 dsh-mneme 的用户画像与规则："];
+    if (profile) lines.push(`- 用户画像：${profile}`);
+    for (const rule of rules) lines.push(`- 规则：${rule}`);
+    return lines.join("\n");
+  }
+
+  const disposers = [
+    ctx.systemPrompt.context({
+      name: "memory",
+      order: 90,
+      text: () => {
+        const candidates = service.injectCandidates({ maxItems, threshold });
+        return render(candidates);
+      }
+    }),
+    ctx.systemPrompt.context({
+      name: "user-settings",
+      order: 85,
+      text: renderUserSettings
+    })
+  ];
+
+  return () => {
+    for (const dispose of disposers) {
+      if (typeof dispose === "function") dispose();
     }
-  });
+  };
 }