@modusensus/dsh-mneme 0.7.10 → 0.7.12

package/{dsh-mneme/src → src}/summarize.js

@@ -1,7 +1,7 @@
 import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
 
 const SUMMARY_PROMPT = `你是记忆库提炼助手。根据下面的会话内容，提炼 2-3 条值得跨会话记住的记忆。
-只输出 JSON 数组，每项形如 {"type":"preference|project|decision|history|user|fact","title":"简短标题","content":"一句话内容","importance":1-5}。
+只输出 JSON 数组，每项形如 {"type":"preference|project|decision|history","title":"简短标题","content":"一句话内容","importance":1-5}。
 不要输出任何其他文字。`;
 
 /** Extract a JSON array from LLM output that may contain prose around it. */
@@ -17,7 +17,7 @@ export function parseSummaryJson(raw) {
     return [];
   }
   if (!Array.isArray(arr)) return [];
-  const VALID = new Set(["preference", "project", "decision", "history", "user", "fact"]);
+  const VALID = new Set(["preference", "project", "decision", "history"]);
   return arr.filter(
     (item) =>
       item &&
@@ -76,11 +76,15 @@ function toProtocolChunk(chunk) {
 // events must not leak into the memory store. Events without a data payload
 // (minimal test doubles) pass the kind check and are handled by the content
 // check below.
+// DSH ≥0.1.2-rc removed the Session.events property; events are only reachable
+// via snapshotEvents(). Older DSH builds still expose .events, so fall back.
+function getSessionEvents(session) {
+  return session?.snapshotEvents?.() ?? session?.events ?? [];
+}
+
 function collectMessages(session) {
   const messages = [];
-  // DSH 0.1.2-rc.1 起 Session 改用 snapshotEvents()，兼容旧版 .events
-  const events = session.snapshotEvents?.() ?? session.events ?? [];
-  for (const event of events) {
+  for (const event of getSessionEvents(session)) {
     const kind = event.data?.source?.kind;
     if (event.type !== "user/message") continue;
     if (kind !== undefined && kind !== "user") continue;
@@ -184,11 +188,7 @@ export function createSummarizer(ctx, service, config) {
         .join("");
       const entries = parseSummaryJson(text || assembledText);
       for (const entry of entries) {
-        // Provenance: the summarizer runs on a real session (turn/end hook), so
-        // session.id is always available here — it rides both the human-readable
-        // source label and the structured session_id column (v0.5.x memory
-        // provenance, the raw material for v0.6.0 reasoning-path / drift analysis).
-        service.saveWithDedupe({ ...entry, source: `session:${session.id}`, session_id: session.id });
+        service.saveWithDedupe({ ...entry, source: `session:${session.id}` });
       }
     } finally {
       if (audit) {

package/src/tools.js

@@ -0,0 +1,274 @@
+import { defineTool } from "@deepseek-ai/dsh-tools";
+
+const TEXT_OUTPUT = (text) => [{ type: "text", text }];
+
+// Wire shape emitted by service.toApiList: shared by memory_search and
+// memory_list so their output schemas always declare every key the runtime
+// value carries (additionalProperties: false would reject undeclared keys).
+const MEMORY_ITEM_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id: { type: "string", required: true },
+    type: { type: "string", required: true },
+    title: { type: "string", required: true },
+    content: { type: "string", required: true },
+    tags: { type: "array", items: { type: "string" } },
+    importance: { type: "integer", required: true },
+    source: { type: "string" },
+    created_at: { type: "string", required: true },
+    updated_at: { type: "string", required: true }
+  }
+};
+
+export function createTools(ctx, service, config, embedder) {
+  const tools = [
+    defineTool({
+      name: "memory_save",
+      description:
+        "Persist one memory entry for future sessions (user preferences, project state, decisions). " +
+        "Call this when the user states a durable preference, a project decision is made, or a lesson is learned. " +
+        "Merges into an existing entry of the same type when the title matches.",
+      parameters: {
+        type: { type: "string", required: true, enum: ["preference", "project", "decision", "history"], description: "preference=user profile; project=project knowledge/state; decision=key decision; history=conversation summary" },
+        title: { type: "string", required: true, description: "Short unique title" },
+        content: { type: "string", required: true, description: "Memory body" },
+        tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
+        importance: { type: "integer", description: "1-5; >= threshold auto-injects into future sessions" },
+        source: { type: "string", description: "Optional provenance" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            action: { type: "string", required: true, enum: ["created", "merged"] },
+            id: { type: "string", required: true }
+          }
+        },
+        render: (_args, value) => TEXT_OUTPUT(`memory ${value.action}: ${value.id}`)
+      },
+      async execute(args) {
+        const { action, memory } = service.saveWithDedupe({
+          type: args.type,
+          title: args.title,
+          content: args.content,
+          tags: args.tags ?? [],
+          importance: args.importance ?? 3,
+          source: args.source ?? "tool"
+        });
+        return { action, id: memory.id };
+      }
+    }),
+
+    defineTool({
+      name: "memory_search",
+      description: "Search the cross-session memory store. Use when you need past context: how a problem was solved, user preferences, project decisions. Substring-matches title/content/tags, and augments results with semantic (vector) recall + optional rerank when an embeddings provider is configured. Returns matching entries with source and timestamps.",
+      parameters: {
+        query: { type: "string", required: true, description: "Search text; substring match over title/content/tags" },
+        limit: { type: "integer", description: "Max results (default 20)" },
+        mode: { type: "string", enum: ["auto", "keyword", "vector", "hybrid"], description: "auto (default) = keyword hits first + vector fill when enabled; keyword = text only; vector = semantic recall first (falls back to keyword); hybrid = vector leads, keyword fills remaining slots" },
+        semantic: { type: "boolean", description: "Shorthand: enable semantic (vector) recall (same as mode=vector when true)" },
+        rerank: { type: "boolean", description: "Run cross-encoder rerank over candidates when a local reranker is configured (default true)" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            items: {
+              type: "array", required: true,
+              items: MEMORY_ITEM_SCHEMA
+            }
+          }
+        },
+        render: (_args, value) => TEXT_OUTPUT(`Found ${value.items.length} memory entr${value.items.length === 1 ? "y" : "ies"}.`)
+      },
+      async execute(args) {
+        const limit = args.limit ?? 20;
+        const mode = args.semantic === true && !args.mode ? "vector" : args.mode ?? "auto";
+        const rows = await service.searchMemories(args.query, {
+          mode,
+          topK: limit,
+          useRerank: args.rerank !== false
+        });
+        return { items: service.toApiList(rows) };
+      }
+    }),
+
+    defineTool({
+      name: "memory_list",
+      description: "List memory entries by type, high-importance first, then newest, paginated. Set include_archived=true to also list archived (hidden) entries so they can be located and restored.",
+      parameters: {
+        type: { type: "string", enum: ["preference", "project", "decision", "history"], description: "Filter by type; omit for all" },
+        limit: { type: "integer", description: "Page size (default 50)" },
+        offset: { type: "integer", description: "Page offset (default 0)" },
+        include_archived: { type: "boolean", description: "Include archived (hidden) entries so they can be found and restored (default false)" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            items: {
+              type: "array", required: true,
+              items: MEMORY_ITEM_SCHEMA
+            },
+            total: { type: "integer", required: true }
+          }
+        },
+        render: (_args, value) => TEXT_OUTPUT(`${value.items.length} memory entries (of ${value.total}).`)
+      },
+      async execute(args) {
+        const includeArchived = args.include_archived === true;
+        const rows = service.toApiList(service.list({
+          type: args.type,
+          limit: args.limit ?? 50,
+          offset: args.offset ?? 0,
+          includeArchived
+        }));
+        return { items: rows, total: service.count(args.type, { includeArchived }) };
+      }
+    }),
+
+    defineTool({
+      name: "memory_update",
+      description: "Modify an existing memory entry (title, content, type, tags, importance).",
+      parameters: {
+        id: { type: "string", required: true, description: "Memory id" },
+        title: { type: "string" },
+        content: { type: "string" },
+        type: { type: "string", enum: ["preference", "project", "decision", "history"] },
+        tags: { type: "array", items: { type: "string" } },
+        importance: { type: "integer", description: "1-5" },
+        reason: { type: "string", description: "Optional context for the correction (what the user actually said/wanted), recorded for reflection" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            memory: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                id: { type: "string", required: true },
+                title: { type: "string", required: true },
+                content: { type: "string", required: true }
+              }
+            }
+          }
+        },
+        render: (_args, value) => TEXT_OUTPUT(`Updated memory ${value.memory.id}: ${value.memory.title}`)
+      },
+      async execute(args) {
+        const memory = service.update(args.id, {
+          title: args.title,
+          content: args.content,
+          type: args.type,
+          tags: args.tags,
+          importance: args.importance
+        }, { query: args.reason });
+        return { memory: { id: memory.id, title: memory.title, content: memory.content } };
+      }
+    }),
+
+    defineTool({
+      name: "memory_delete",
+      description: "Permanently delete a memory entry.",
+      parameters: {
+        id: { type: "string", required: true }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: { deleted: { type: "boolean", required: true } }
+        },
+        render: (_args, value) => TEXT_OUTPUT(value.deleted ? "Memory deleted." : "Memory not found.")
+      },
+      async execute(args) {
+        const existed = service.getById(args.id) !== undefined;
+        if (existed) service.remove(args.id);
+        return { deleted: existed };
+      }
+    }),
+
+    defineTool({
+      name: "memory_forget",
+      description:
+        "Stop a memory from being auto-injected and from appearing in searches and lists without deleting it. " +
+        "The entry stays in storage; pass forgotten: false to restore it.",
+      parameters: {
+        id: { type: "string", required: true },
+        forgotten: { type: "boolean", description: "Suppress (true, default) or restore (false) the entry's visibility" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            memory: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                id: { type: "string", required: true },
+                forgotten: { type: "boolean", required: true }
+              }
+            }
+          }
+        },
+        render: (_args, value) => TEXT_OUTPUT(`Memory ${value.memory.id} injection ${value.memory.forgotten ? "suppressed" : "restored"}.`)
+      },
+      async execute(args) {
+        if (service.getById(args.id) === undefined) {
+          throw new Error("memory not found");
+        }
+        const memory = service.setForget(args.id, args.forgotten ?? true);
+        return { memory: { id: memory.id, forgotten: memory.forgotten } };
+      }
+    }),
+
+    defineTool({
+      name: "memory_archive",
+      description:
+        "Archive a memory (hide it from active lists, search, injection and dream consolidation) or restore it. " +
+        "Archived entries stay in storage and are recoverable: pass archived=false to restore, and use memory_list with " +
+        "include_archived=true to find archived entries.",
+      parameters: {
+        id: { type: "string", required: true, description: "Memory id" },
+        archived: { type: "boolean", description: "Archive (true, default) or restore (false) the entry" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            memory: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                id: { type: "string", required: true },
+                archived: { type: "boolean", required: true }
+              }
+            }
+          }
+        },
+        render: (_args, value) => TEXT_OUTPUT(`Memory ${value.memory.id} ${value.memory.archived ? "archived" : "restored"}.`)
+      },
+      async execute(args) {
+        if (service.getById(args.id) === undefined) {
+          throw new Error("memory not found");
+        }
+        const memory = service.setArchived(args.id, args.archived ?? true);
+        return { memory: { id: memory.id, archived: memory.archived } };
+      }
+    })
+  ];
+
+  for (const tool of tools) {
+    ctx.tools.register(tool);
+  }
+
+  return tools;
+}

package/{dsh-mneme/test → test}/api.test.js

@@ -29,10 +29,8 @@ function req(path, method = "GET", body = null) {
 
 function setup(embedder, apiToken = "") {
   const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
   const settings = createSettings(store.db);
-  // settings is threaded into the service so the /config endpoint reports the
-  // effective settings-over-config tag toggles (issue #31).
-  const service = createService({ store, mirror: null, config: {}, settings });
   const commands = {
     add: (def) => settings.addCommand(def),
     remove: (id) => settings.removeCommand(id),
@@ -193,6 +191,50 @@ test("PUT /api/dsh-mneme/rules saves rules", async () => {
   assert.deepEqual(settings.getRules(), ["a", "b"]);
 });
 
+// --- panel mode (light/standard) ---
+
+test("GET /api/dsh-mneme/mode defaults to standard", async () => {
+  const { routes } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/mode");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode"), res);
+  assert.equal(res.statusCode, 200);
+  assert.deepEqual(JSON.parse(res.body), { mode: "standard" });
+});
+
+test("PUT /api/dsh-mneme/mode validates the enum and persists", async () => {
+  const { routes, settings } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/mode");
+
+  const put = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode", "PUT", { mode: "light" }), put);
+  assert.equal(put.statusCode, 200);
+  assert.deepEqual(JSON.parse(put.body), { mode: "light" });
+  assert.equal(settings.getPanelMode(), "light");
+
+  const back = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode", "PUT", { mode: "standard" }), back);
+  assert.deepEqual(JSON.parse(back.body), { mode: "standard" });
+
+  const bad = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode", "PUT", { mode: "turbo" }), bad);
+  assert.equal(bad.statusCode, 400);
+  assert.equal(settings.getPanelMode(), "standard", "invalid value not persisted");
+});
+
+test("PUT /api/dsh-mneme/mode is token-gated like other settings writes", async () => {
+  const { routes } = setup(undefined, "secret-token");
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/mode");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode", "PUT", { mode: "light" }), res);
+  assert.equal(res.statusCode, 401);
+  const ok = new FakeRes();
+  const authed = req("/api/dsh-mneme/mode", "PUT", { mode: "light" });
+  authed.headers = { authorization: "Bearer secret-token" };
+  await route.handler(authed, ok);
+  assert.equal(ok.statusCode, 200);
+});
+
 test("GET /api/dsh-mneme/commands lists commands", async () => {
   const { routes, settings } = setup();
   settings.addCommand({ name: "agenda", instruction: "x" });
@@ -469,156 +511,3 @@ test("Bug10: vector-reindex with an embed-only OpenAI-compatible embedder return
   assert.equal(vectorIndex.dimension(), 3, "dimension written to vector_meta");
   assert.equal(vectorIndex.getEmbedding(service.all()[0].id).length, 3, "embedding persisted");
 });
-
-// --- memory tags (v0.6.2) ---------------------------------------------------
-
-test("GET /api/dsh-mneme/memory/tags returns live tags and the manual gate", async () => {
-  const { routes, service } = setup();
-  const mem = service.saveWithDedupe({ type: "preference", title: "A", content: "x" }).memory;
-  service.setMemoryTags(mem.id, ["bash", "考研"]);
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/tags");
-  const res = new FakeRes();
-  await route.handler(req(`/api/dsh-mneme/memory/tags?id=${mem.id}`), res);
-  assert.equal(res.statusCode, 200);
-  const data = JSON.parse(res.body);
-  assert.deepEqual(data.tags, ["bash", "考研"], "authoritative entity_attrs tags");
-  assert.equal(data.manualTagEnabled, true, "gate defaults on");
-});
-
-test("POST /api/dsh-mneme/memory/tags overwrites the tag set", async () => {
-  const { routes, service } = setup();
-  const mem = service.saveWithDedupe({ type: "preference", title: "A", content: "x" }).memory;
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/tags");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/memory/tags", "POST", { id: mem.id, tags: ["linux"] }), res);
-  assert.equal(res.statusCode, 200);
-  const data = JSON.parse(res.body);
-  assert.equal(data.ok, true);
-  assert.deepEqual(data.tags, ["linux"]);
-  assert.deepEqual(service.getMemoryTags(mem.id), ["linux"], "tag set persisted");
-});
-
-test("POST /api/dsh-mneme/memory/tags 409s when manualTagEnabled is off", async () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: { manualTagEnabled: false } });
-  const settings = createSettings(store.db);
-  const routes = [];
-  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
-  createApi(ctx, service, settings, { add() {}, remove() {}, list() { return []; } });
-  const mem = service.saveWithDedupe({ type: "preference", title: "A", content: "x" }).memory;
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/tags");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/memory/tags", "POST", { id: mem.id, tags: ["x"] }), res);
-  assert.equal(res.statusCode, 409, "manual tag write rejected");
-  assert.match(JSON.parse(res.body).error, /manualTagEnabled/);
-  const get = new FakeRes();
-  await route.handler(req(`/api/dsh-mneme/memory/tags?id=${mem.id}`), get);
-  assert.equal(JSON.parse(get.body).manualTagEnabled, false, "GET reports the gate off");
-});
-
-// v0.6.3 directory view endpoint: /api/dsh-mneme/directory returns the
-// tag-grouped directory (groups + untagged) as JSON.
-test("GET /api/dsh-mneme/directory groups tagged memories by tag", async () => {
-  const { routes, service } = setup();
-  const a = service.saveWithDedupe({ type: "preference", title: "Linux", content: "内核" }).memory;
-  const b = service.saveWithDedupe({ type: "preference", title: "考研", content: "公共管理" }).memory;
-  service.setMemoryTags(a.id, ["linux"]);
-  service.setMemoryTags(b.id, ["考研"]);
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/directory");
-  assert.ok(route, "directory route must be registered");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/directory"), res);
-  assert.equal(res.statusCode, 200);
-  const data = JSON.parse(res.body);
-  assert.deepEqual(Object.keys(data).sort(), ["groups", "untagged"]);
-  assert.equal(data.groups.length, 2);
-  const linux = data.groups.find((g) => g.tag === "linux");
-  assert.deepEqual(linux.memories.map((m) => m.id), [a.id]);
-  assert.equal(linux.memories[0].title, "Linux");
-});
-
-test("GET /api/dsh-mneme/directory reports untagged memories", async () => {
-  const { routes, service } = setup();
-  const tagged = service.saveWithDedupe({ type: "preference", title: "Tagged", content: "x" }).memory;
-  const bare = service.saveWithDedupe({ type: "project", title: "Bare", content: "y" }).memory;
-  service.setMemoryTags(tagged.id, ["linux"]);
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/directory");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/directory"), res);
-  assert.equal(res.statusCode, 200);
-  const data = JSON.parse(res.body);
-  assert.deepEqual(data.untagged.map((m) => m.id), [bare.id]);
-});
-
-test("GET/PUT /api/dsh-mneme/config round-trips autoTag switches", async () => {
-  const { routes } = setup();
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/config");
-  const res1 = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/config"), res1);
-  assert.equal(res1.statusCode, 200);
-  // unset → effective config falls back to plugin-config defaults:
-  // autoTagEnabled=false, manualTagEnabled=true (issue #31 default unification),
-  // showSidebarTrigger=true (issue #38 default)
-  assert.deepEqual(JSON.parse(res1.body).config, { autoTagEnabled: false, manualTagEnabled: true, showSidebarTrigger: true });
-  const res2 = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/config", "PUT", { autoTagEnabled: true, manualTagEnabled: false }), res2);
-  assert.equal(res2.statusCode, 200);
-  assert.deepEqual(JSON.parse(res2.body).config, { autoTagEnabled: true, manualTagEnabled: false, showSidebarTrigger: true });
-});
-
-test("GET/PUT /api/dsh-mneme/config round-trips the sidebar trigger toggle (issue #38)", async () => {
-  const { routes } = setup();
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/config");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/config", "PUT", { showSidebarTrigger: false }), res);
-  assert.equal(res.statusCode, 200);
-  // Toggling the UI pref must not disturb the tag toggles (settings-over-config).
-  assert.deepEqual(JSON.parse(res.body).config, { autoTagEnabled: false, manualTagEnabled: true, showSidebarTrigger: false });
-  const res2 = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/config"), res2);
-  assert.deepEqual(JSON.parse(res2.body).config, { autoTagEnabled: false, manualTagEnabled: true, showSidebarTrigger: false });
-});
-
-test("DELETE /api/dsh-mneme/memories removes by id and reports misses", async () => {
-  const { routes, service } = setup();
-  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
-  const target = service.list().find((m) => m.title === "语言");
-  const id = target.id;
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/memories");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/memories", "DELETE", { id }), res);
-  assert.equal(res.statusCode, 200);
-  assert.equal(JSON.parse(res.body).deleted, true);
-  const res2 = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/memories", "DELETE", { id }), res2);
-  assert.equal(JSON.parse(res2.body).deleted, false);
-});
-
-test("DELETE /api/dsh-mneme/memories rejects id+query together", async () => {
-  const { routes } = setup();
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/memories");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/memories", "DELETE", { id: "x", query: "y" }), res);
-  assert.equal(res.statusCode, 400);
-});
-
-test("PUT /api/dsh-mneme/config supports partial update", async () => {
-  const { routes } = setup();
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/config");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/config", "PUT", { autoTagEnabled: true }), res);
-  assert.equal(res.statusCode, 200);
-  // Partial PUT only stores autoTagEnabled; manualTagEnabled stays unset and
-  // falls back to the plugin-config default (true) — a lone autoTag toggle must
-  // never silently disable manual tagging (issue #31).
-  assert.deepEqual(JSON.parse(res.body).config, { autoTagEnabled: true, manualTagEnabled: true, showSidebarTrigger: true });
-});
-
-test("PUT /api/dsh-mneme/config rejects non-boolean showSidebarTrigger", async () => {
-  const { routes } = setup();
-  const route = routes.find((r) => r.path === "/api/dsh-mneme/config");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/config", "PUT", { showSidebarTrigger: "no" }), res);
-  assert.equal(res.statusCode, 400);
-  assert.match(JSON.parse(res.body).error, /showSidebarTrigger/);
-});