@modusensus/dsh-mneme 0.1.3 → 0.1.5

package/lib/client.js

@@ -23,7 +23,37 @@ 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": "暂无内容",
+        "memory.panel.semantic": "语义",
+        "memory.settings.vectorTitle": "向量搜索",
+        "memory.settings.vectorHint": "接入 OpenAI 兼容的 embeddings API 做语义搜索，可匹配字面不同但语义相近的记忆",
+        "memory.settings.vectorEnabled": "启用向量搜索",
+        "memory.settings.vectorBaseUrl": "API 地址 (Base URL)",
+        "memory.settings.vectorApiKey": "API Key",
+        "memory.settings.vectorModel": "模型名",
+        "memory.settings.vectorSave": "保存配置",
+        "memory.settings.vectorSaved": "配置已保存",
+        "memory.settings.vectorReindex": "重建索引",
+        "memory.settings.vectorReindexing": "索引中…",
+        "memory.settings.vectorReindexDone": "已索引 {n} 条"
       },
       en: {
         "memory.panel.title": "Memory",
@@ -34,7 +64,37 @@ 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",
+        "memory.panel.semantic": "Semantic",
+        "memory.settings.vectorTitle": "Vector Search",
+        "memory.settings.vectorHint": "Connect an OpenAI-compatible embeddings API for semantic search by meaning, not just keywords",
+        "memory.settings.vectorEnabled": "Enable vector search",
+        "memory.settings.vectorBaseUrl": "Base URL",
+        "memory.settings.vectorApiKey": "API Key",
+        "memory.settings.vectorModel": "Model",
+        "memory.settings.vectorSave": "Save Config",
+        "memory.settings.vectorSaved": "Config saved",
+        "memory.settings.vectorReindex": "Reindex",
+        "memory.settings.vectorReindexing": "Indexing…",
+        "memory.settings.vectorReindexDone": "Indexed {n} items"
       }
     };
 
@@ -50,13 +110,22 @@ window.__ModuleLoader__.load({
       return Number.isNaN(date.getTime()) ? "—" : date.toLocaleString();
     }
 
-    function MemoryPanel({ t, onClose }) {
+    function MemoryPanel({ t, onClose, embedded }) {
       const [tab, setTab] = useState("all");
       const [query, setQuery] = useState("");
+      const [semantic, setSemantic] = useState(false);
+      const [vecEnabled, setVecEnabled] = useState(false);
       const [items, setItems] = useState([]);
       const [loading, setLoading] = useState(false);
       const abortRef = useRef(null);
 
+      useEffect(() => {
+        fetch("/api/dsh-mneme/vector-config")
+          .then((res) => res.json())
+          .then((d) => setVecEnabled(!!d.config?.enabled))
+          .catch(() => {});
+      }, []);
+
       const load = useCallback(async () => {
         abortRef.current?.abort();
         const controller = new AbortController();
@@ -66,7 +135,7 @@ window.__ModuleLoader__.load({
           const params = new URLSearchParams();
           if (tab !== "all") params.set("type", tab);
           const url = query.trim()
-            ? `/api/dsh-mneme/search?q=${encodeURIComponent(query.trim())}`
+            ? `/api/dsh-mneme/search?q=${encodeURIComponent(query.trim())}&mode=${semantic ? "vector" : "auto"}`
             : `/api/dsh-mneme/list?${params.toString()}`;
           const res = await fetch(url, { signal: controller.signal });
           const data = await res.json();
@@ -77,7 +146,7 @@ window.__ModuleLoader__.load({
         } finally {
           setLoading(false);
         }
-      }, [tab, query]);
+      }, [tab, query, semantic]);
 
       useEffect(() => {
         load();
@@ -86,19 +155,24 @@ window.__ModuleLoader__.load({
 
       const tabs = ["all", "preference", "project", "decision", "history"];
 
-      return createPortal(
-        react.createElement("div", { style: styles.overlay },
-          react.createElement("div", { style: styles.panel },
-            react.createElement("div", { style: styles.header },
-              react.createElement("span", { style: styles.title }, t("memory.panel.title")),
-              react.createElement("button", { style: styles.close, onClick: onClose }, "×")
+      const body = react.createElement("div", { style: embedded ? { ...styles.panel, width: "100%", maxWidth: "100%", maxHeight: "none" } : styles.panel },
+        !embedded && react.createElement("div", { style: styles.header },
+          react.createElement("span", { style: styles.title }, t("memory.panel.title")),
+          react.createElement("button", { style: styles.close, onClick: onClose }, "×")
+        ),
+            react.createElement("div", { style: { display: "flex", gap: 6, alignItems: "center", marginBottom: 12 } },
+              react.createElement("input", {
+                style: { ...styles.search, flex: 1, marginBottom: 0 },
+                placeholder: t("memory.panel.search"),
+                value: query,
+                onChange: (e) => setQuery(e.target.value)
+              }),
+              vecEnabled && react.createElement("button", {
+                style: { ...styles.tab, ...(semantic ? styles.tabActive : {}) },
+                title: t("memory.settings.vectorTitle"),
+                onClick: () => setSemantic(!semantic)
+              }, t("memory.panel.semantic"))
             ),
-            react.createElement("input", {
-              style: styles.search,
-              placeholder: t("memory.panel.search"),
-              value: query,
-              onChange: (e) => setQuery(e.target.value)
-            }),
             react.createElement("div", { style: styles.tabs },
               tabs.map((key) =>
                 react.createElement("button", {
@@ -128,10 +202,218 @@ window.__ModuleLoader__.load({
                       )
                     )
             )
-          )
+      );
+      return embedded
+        ? body
+        : createPortal(react.createElement("div", { style: styles.overlay }, body), document.body);
+    }
+
+    const h = react.createElement;
+
+    // --- Settings panel: user profile, rules, custom commands ---
+    function SettingsPanel({ t, onClose, embedded }) {
+      const [sectionTab, setSectionTab] = react.useState("settings");
+      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 [vector, setVector] = react.useState({ enabled: false, baseUrl: "", apiKey: "", model: "" });
+      const [vectorSaved, setVectorSaved] = react.useState(false);
+      const [reindexing, setReindexing] = react.useState(false);
+      const [reindexMsg, setReindexMsg] = react.useState("");
+
+      const load = react.useCallback(async () => {
+        try {
+          const [p, r, c, v] = 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()),
+            fetch("/api/dsh-mneme/vector-config").then((res) => res.json())
+          ]);
+          setProfile(p.profile || "");
+          setRules(Array.isArray(r.rules) ? r.rules : []);
+          setCommands(Array.isArray(c.commands) ? c.commands : []);
+          setVector(v.config || { enabled: false, baseUrl: "", apiKey: "", model: "" });
+        } 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));
+      }
+
+      async function saveVector() {
+        try {
+          await fetch("/api/dsh-mneme/vector-config", {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(vector)
+          });
+          setVectorSaved(true);
+          setTimeout(() => setVectorSaved(false), 1500);
+        } catch { /* ignore */ }
+      }
+
+      async function reindex() {
+        setReindexing(true);
+        setReindexMsg("");
+        try {
+          const res = await fetch("/api/dsh-mneme/vector-reindex");
+          const data = await res.json();
+          const n = data.indexed ?? 0;
+          setReindexMsg(t("memory.settings.vectorReindexDone").replace("{n}", String(n)));
+        } catch { setReindexMsg(""); }
+        setReindexing(false);
+      }
+
+      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)" };
+
+      const body = h("div", { style: embedded ? { ...styles.panel, width: "100%", maxWidth: "100%", maxHeight: "none" } : styles.panel },
+        !embedded && h("div", { style: styles.header },
+          h("span", { style: styles.title }, t("memory.settings.title")),
+          h("button", { style: styles.close, onClick: onClose }, "×")
+        ),
+        h("div", { style: styles.tabs },
+          h("button", { style: { ...styles.tab, ...(sectionTab === "memory" ? styles.tabActive : {}) }, onClick: () => setSectionTab("memory") }, t("memory.panel.open")),
+          h("button", { style: { ...styles.tab, ...(sectionTab === "settings" ? styles.tabActive : {}) }, onClick: () => setSectionTab("settings") }, t("memory.settings.title"))
         ),
-        document.body
+        sectionTab === "memory"
+          ? h(MemoryPanel, { t, embedded: true })
+          : 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: "both", 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: "both", 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)
+              ),
+              // vector search
+              h("div", { style: { ...labelStyle, marginTop: 20 } }, t("memory.settings.vectorTitle")),
+              h("div", { style: hintStyle }, t("memory.settings.vectorHint")),
+              h("label", { style: { display: "flex", alignItems: "center", gap: 6, marginBottom: 8, fontSize: 13 } },
+                h("input", { type: "checkbox", checked: !!vector.enabled, onChange: (e) => setVector({ ...vector, enabled: e.target.checked }) }),
+                h("span", null, t("memory.settings.vectorEnabled"))
+              ),
+              h("input", { style: inputStyle, value: vector.baseUrl, placeholder: t("memory.settings.vectorBaseUrl"), onChange: (e) => setVector({ ...vector, baseUrl: e.target.value }) }),
+              h("input", { style: inputStyle, type: "password", value: vector.apiKey, placeholder: t("memory.settings.vectorApiKey"), onChange: (e) => setVector({ ...vector, apiKey: e.target.value }) }),
+              h("input", { style: inputStyle, value: vector.model, placeholder: t("memory.settings.vectorModel"), onChange: (e) => setVector({ ...vector, model: e.target.value }) }),
+              h("div", { style: { display: "flex", alignItems: "center", gap: 6, flexWrap: "wrap" } },
+                h("button", { style: styles.footerButton, onClick: saveVector }, t("memory.settings.vectorSave")),
+                vectorSaved && h("span", { style: { fontSize: 12, color: "var(--dsw-alias-state-success, #2a7)" } }, t("memory.settings.vectorSaved")),
+                h("button", { style: styles.footerButton, onClick: reindex, disabled: reindexing }, reindexing ? t("memory.settings.vectorReindexing") : t("memory.settings.vectorReindex")),
+                reindexMsg && h("span", { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary, #666)" } }, reindexMsg)
+              )
+            )
       );
+      return embedded
+        ? body
+        : createPortal(h("div", { style: styles.overlay }, body), document.body);
     }
 
     const styles = {
@@ -158,26 +440,18 @@ window.__ModuleLoader__.load({
     function apply(ctx) {
       ctx.effect(() => ctx.locale.register(NS, dictionaries), "dsh-mneme: dictionaries");
 
+      // Register a custom section inside the DSH settings panel (nav label +
+      // embedded memory/settings content). Access is via the official settings
+      // panel only; no sidebar buttons are registered.
       ctx.effect(() => {
         const t = ctx.locale.bind(NS);
-        return ctx.slots.inject("sidebar.footer.action", () =>
-          ctx.slots.register({
-            name: "sidebar.footer.action",
-            id: "memory",
-            locale: NS,
-            inject: () => ({})
-          }, () => {
-            const [open, setOpen] = 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) })
-            );
-          })
-        );
-      }, "dsh-mneme: sidebar action");
+        return ctx.slots.register({
+          name: "settings.section",
+          id: "dsh-mneme",
+          label: () => t("memory.settings.title"),
+          inject: () => ({})
+        }, () => react.createElement(SettingsPanel, { t, embedded: true, onClose: () => {} }));
+      }, "dsh-mneme: settings section");
     }
 
     exports.apply = apply;

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/embedding.js

@@ -0,0 +1,97 @@
+// OpenAI-compatible embedding client for vector search. DSH's LLM service is
+// chat-only, so dsh-mneme calls an external `/embeddings` endpoint itself.
+// Works with OpenAI, SiliconFlow, Zhipu, local Ollama (via OpenAI-compatible
+// proxy) and any provider exposing the standard embeddings API.
+const DEFAULT_TIMEOUT_MS = 15000;
+
+/** Normalize a configured baseUrl into the full embeddings endpoint URL. */
+function embeddingsUrl(baseUrl) {
+  const base = String(baseUrl ?? "").trim().replace(/\/+$/, "");
+  if (!base) return "";
+  // Accept both "https://host/v1" and a full path ending in /embeddings.
+  if (/\/embeddings$/i.test(base)) return base;
+  return `${base}/embeddings`;
+}
+
+/**
+ * Call the embeddings API for one text. Resolves to a Float64 array, or null
+ * when the provider is not configured, the call fails, or the response is
+ * unusable. Never throws: failures degrade to keyword search.
+ */
+export async function embedText({ baseUrl, apiKey, model }, text) {
+  const url = embeddingsUrl(baseUrl);
+  if (!url || !apiKey || !model || !text) return null;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ model, input: String(text).slice(0, 8000) }),
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return null;
+  }
+  const vec = body?.data?.[0]?.embedding;
+  return Array.isArray(vec) && vec.length ? Array.from(vec) : null;
+}
+
+/**
+ * Embedder bound to the current settings + store: on each write it re-embeds
+ * the row's title+content and stores the vector. Failures are swallowed so a
+ * flaky embedding endpoint never breaks memory writes.
+ */
+export function createEmbedder({ store, settings, logger }) {
+  async function embedFor(id, title, content) {
+    const cfg = settings.getVectorConfig();
+    if (!cfg?.enabled || !cfg.baseUrl || !cfg.apiKey || !cfg.model) return;
+    const text = [title, content].filter(Boolean).join("\n");
+    const vector = await embedText(cfg, text);
+    if (vector) {
+      store.setEmbedding(id, vector);
+      logger?.info?.(`[dsh-mneme] embedded memory ${id} (dim=${vector.length})`);
+    }
+  }
+
+  return {
+    /** Fire-and-forget re-embed of a memory after any write. */
+    schedule(memory) {
+      if (!memory?.id) return;
+      embedFor(memory.id, memory.title, memory.content).catch(() => {});
+    },
+
+    /** Embed one text and return its vector (null on failure/disabled). */
+    async embed(query) {
+      const cfg = settings.getVectorConfig();
+      if (!cfg?.enabled || !cfg.baseUrl || !cfg.apiKey || !cfg.model) return null;
+      return embedText(cfg, query);
+    },
+
+    /** Batch re-index rows still missing an embedding. */
+    async reindexMissing(limit = 50) {
+      const cfg = settings.getVectorConfig();
+      if (!cfg?.enabled) return { indexed: 0, skipped: 0 };
+      const rows = store.needsEmbedding(limit);
+      let indexed = 0;
+      for (const row of rows) {
+        const text = [row.title, row.content].filter(Boolean).join("\n");
+        const vector = await embedText(cfg, text);
+        if (vector) {
+          store.setEmbedding(row.id, vector);
+          indexed++;
+        }
+      }
+      return { indexed, skipped: rows.length - indexed };
+    }
+  };
+}

package/lib/index.js

@@ -6,13 +6,16 @@ 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 { createEmbedder } from "./embedding.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,6 +36,23 @@ 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);
+
+  // Vector search: embedder calls the configured OpenAI-compatible embeddings
+  // endpoint on writes and for queries. service re-embeds after each write.
+  const embedder = createEmbedder({ store, settings, logger: ctx.logger });
+  service.setEmbedder(embedder);
+
+  // 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. Read every type's
   // edits up front: mergeHumanEdits re-renders ALL mirror files on success, so
@@ -67,7 +87,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) => {
@@ -78,7 +98,11 @@ 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: () => []
+    }, embedder);
     disposers.push(api.dispose);
   }
 
@@ -89,6 +113,7 @@ export const apply = (ctx, config) => {
     for (const dispose of disposers) {
       if (typeof dispose === "function") dispose();
     }
+    commands?.dispose();
     if (dream) await dream.dispose();
     store.close();
   };