@modusensus/dsh-mneme 0.7.10 → 0.7.11

package/test/inject.test.js

@@ -0,0 +1,120 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const disposers = [];
+  const ctx = {
+    systemPrompt: {
+      context(def) {
+        contexts.push(def);
+        const dispose = () => disposers.push(def.name);
+        return dispose;
+      }
+    }
+  };
+  const config = { maxInjectedItems: 3, importanceThreshold: 3, ...over };
+  const injector = createInjector(ctx, service, settings, config);
+  return { store, service, contexts, injector, settings };
+}
+
+test("registers memory and user-settings contexts", () => {
+  const { contexts } = setup();
+  assert.equal(contexts.length, 2);
+  assert.equal(contexts[0].name, "memory");
+  assert.equal(contexts[1].name, "user-settings");
+});
+
+test("context text renders injected memories as markdown block", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "用户用中文交流", importance: 5 });
+  service.saveWithDedupe({ type: "project", title: "记忆插件", content: "SQLite+Markdown", importance: 4 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("[记忆库]"), "has header");
+  assert.ok(text.includes("语言"), "includes preference");
+  assert.ok(text.includes("记忆插件"), "includes high-importance project");
+});
+
+test("returns empty text when nothing qualifies", () => {
+  const { contexts } = setup();
+  const text = contexts[0].text({});
+  assert.equal(text, "");
+});
+
+test("renders summary block first when summary candidate exists", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "summary", title: "记忆库总览", content: "这是总览摘要", importance: 5 });
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文", importance: 5 });
+  const text = contexts[0].text({});
+  const summaryIdx = text.indexOf("这是总览摘要");
+  const prefIdx = text.indexOf("语言");
+  assert.ok(summaryIdx !== -1, "summary present");
+  assert.ok(prefIdx !== -1, "preference present");
+  assert.ok(summaryIdx < prefIdx, "summary rendered first");
+});
+
+test("user-settings context renders profile and rules, empty when unset", () => {
+  const { contexts, settings } = setup();
+  const settingsCtx = contexts.find((c) => c.name === "user-settings");
+  assert.ok(settingsCtx, "user-settings context registered");
+  assert.equal(settingsCtx.text({}), "", "empty when no profile/rules");
+  settings.setProfile("我叫小明，是一名前端开发者");
+  settings.setRules(["回答时先给结论", "使用简体中文"]);
+  const text = settingsCtx.text({});
+  assert.ok(text.includes("用户画像"), "has profile header");
+  assert.ok(text.includes("前端开发者"), "includes profile");
+  assert.ok(text.includes("先给结论"), "includes rule");
+  assert.ok(text.includes("简体中文"), "includes second rule");
+});
+
+test("user-settings context precedes memory block (order 85 < 90)", () => {
+  const { contexts, settings } = setup();
+  settings.setProfile("画像");
+  const settingsCtx = contexts.find((c) => c.name === "user-settings");
+  assert.ok(settingsCtx.order < contexts.find((c) => c.name === "memory").order);
+});
+
+test("Bug6: long content is truncated to ~300 chars with an ellipsis", () => {
+  const { contexts, service } = setup();
+  const longContent = "这是一段非常长的记忆正文".repeat(200); // ~2600 chars
+  service.saveWithDedupe({ type: "preference", title: "长记忆", content: longContent, importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("长记忆"), "memory still rendered");
+  assert.ok(text.includes("…"), "ellipsis marks the truncation");
+  assert.ok(!text.includes(longContent.slice(300)), "full body not injected verbatim");
+});
+
+test("Bug6: injected block stays within the ~1500 char budget, later entries collapse", () => {
+  const { contexts, service } = setup({ maxInjectedItems: 8 });
+  for (let i = 0; i < 8; i++) {
+    service.saveWithDedupe({ type: "preference", title: `长标题记忆${i}`, content: "这是一段".repeat(100), importance: 5 });
+  }
+  const text = contexts[0].text({});
+  assert.ok(text.length <= 1600, `memory block bounded near budget, got ${text.length} chars`);
+  // The first entries render full bodies; every entry is present by title.
+  for (let i = 0; i < 8; i++) assert.ok(text.includes(`长标题记忆${i}`), `entry ${i} present`);
+});
+
+// DSH ≥0.1.2-rc removed Session.events; events are only reachable via
+// snapshotEvents(). Regression for #59: the hot block must still render from
+// a session object that has no .events property.
+test("extracts hot rounds from snapshotEvents() when Session.events is absent", () => {
+  const { contexts } = setup();
+  const session = {
+    snapshotEvents: () => [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "怎么修图谱面板" }] } },
+      { type: "assistant/message", data: { content: [{ type: "text", text: "用 viewBox 单位跑模拟" }] } }
+    ]
+  };
+  const text = contexts[0].text({ agent: { session } });
+  assert.ok(text.includes("[短期上下文]"), "hot block rendered");
+  assert.ok(text.includes("怎么修图谱面板"), "round query present");
+  assert.ok(text.includes("用 viewBox 单位跑模拟"), "round response present");
+});

package/{dsh-mneme/test → test}/llm-audit.test.js

@@ -50,10 +50,10 @@ test("autoDream writes llm_audit_logs rows for consolidation and summary", async
   assert.equal(summarize.trigger_source, "autoDream");
   assert.equal(consolidate.status, "success");
   assert.equal(summarize.status, "success");
-  // Issue #25: config route (dreamProvider/dreamModel) wins over the agent
-  // default from mockCtx — the audit must reflect the actually-used route.
-  assert.equal(consolidate.model_id, "deepseek:deepseek-chat");
-  assert.equal(summarize.model_id, "deepseek:deepseek-chat");
+  // mockCtx resolves the route from agentDefaultModel (mock:stress-model), not
+  // the config fallback — assert the actually-used route.
+  assert.equal(consolidate.model_id, "mock:stress-model");
+  assert.equal(summarize.model_id, "mock:stress-model");
   assert.ok(Array.isArray(consolidate.related_memory_ids) && consolidate.related_memory_ids.length === 2,
     "consolidation audit records the snapshot ids");
   assert.ok(consolidate.total_tokens >= 0 && summarize.total_tokens >= 0);

package/{dsh-mneme/test → test}/reasoning-effort.test.js

@@ -36,11 +36,6 @@ test("issue#9: reasoningEffort config defaults to none and rejects unknown value
   assert.equal(cfg.sleepReasoningEffort, "none");
   assert.equal(Config({ dreamReasoningEffort: "high" }).dreamReasoningEffort, "high");
   assert.equal(Config({ sleepReasoningEffort: "medium" }).sleepReasoningEffort, "medium");
-  // v0.5.3: 'off' explicitly disables thinking — required for thinking-type
-  // models (deepseek-v4-flash) whose reasoning otherwise drains the whole
-  // token budget and returns an empty consolidation body.
-  assert.equal(Config({ dreamReasoningEffort: "off" }).dreamReasoningEffort, "off");
-  assert.equal(Config({ sleepReasoningEffort: "off" }).sleepReasoningEffort, "off");
   assert.throws(() => Config({ dreamReasoningEffort: "bogus" }), "invalid effort rejected");
   assert.throws(() => Config({ sleepReasoningEffort: "ultra" }), "invalid effort rejected");
 });
@@ -112,28 +107,6 @@ test("issue#9: dream forwards dreamReasoningEffort on both LLM calls", async ()
   store.close();
 });
 
-test("issue#9: dream forwards dreamReasoningEffort:off (thinking disabled) on both LLM calls", async () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
-  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
-  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
-  const captured = [];
-  const ctx = dreamCtx({
-    captured,
-    onConsolidation: () => JSON.stringify([
-      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "插件总览", content: "合并内容", importance: 4 }
-    ])
-  });
-  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "off" });
-  assert.equal(result.ok, true);
-  assert.equal(captured.length, 2);
-  for (const options of captured) {
-    assert.equal(options.reasoningEffort, "off", `reasoningEffort:"off" forwarded on ${options.purpose}`);
-  }
-  store.close();
-});
-
 // ---------------------------------------------------------------- sleep passthrough
 
 function sleepSetup() {

package/{dsh-mneme/test → test}/recall-layer.test.js

@@ -77,23 +77,14 @@ test("recorded candidates carry id/title/content/score/source and match the retu
   assert.ok(cands.some((c) => c.id === b.id), "second memory recorded");
 });
 
-test("recordRecall defaults on (v0.7.0) — recorder is called by default", async () => {
+test("recordRecall defaults to off — recorder is not called", async () => {
   const { service } = setup();
   let calls = 0;
   service.setRecallRecorder(() => calls++);
   saveMemory(service, null, { title: "量子计算", content: "入门" });
   await service.searchMemories("量子", { mode: "keyword" });
-  assert.equal(calls, 1, "recorder called once by default (recall_runs 记录默认开)");
-});
-
-test("recordRecall can be opted out via explicit false or config.recallRecordDefault=false", async () => {
-  const { service } = setup({ recallRecordDefault: false });
-  let calls = 0;
-  service.setRecallRecorder(() => calls++);
-  saveMemory(service, null, { title: "量子计算", content: "入门" });
-  await service.searchMemories("量子", { mode: "keyword" });
   await service.searchMemories("量子", { mode: "keyword", recordRecall: false });
-  assert.equal(calls, 0, "no recorder call when default disabled or explicit false");
+  assert.equal(calls, 0, "no recorder call when recordRecall is unset or false");
 });
 
 test("recordRecall=true with no recorder installed is safe and returns normally", async () => {
@@ -310,7 +301,7 @@ test("e2e: index.js wiring — recordRecall search lands a row listRecallRuns ca
   assert.equal(store.getRecallRun(run.id).query, "量子", "row readable right away");
 });
 
-test("e2e: recordRecall defaults on (v0.7.0) but is disabled by config.recallRecordDefault=false", async () => {
+test("e2e: without recordRecall the recall_runs table gains no rows", async () => {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
   service.setRecallRecorder((recall) => store.saveRecallRun({
@@ -319,18 +310,6 @@ test("e2e: recordRecall defaults on (v0.7.0) but is disabled by config.recallRec
   }));
   service.saveWithDedupe({ type: "preference", title: "量子计算入门", content: "叠加态" });
   await service.searchMemories("量子", { mode: "keyword" });
-  assert.equal(store.listRecallRuns().length, 1, "default config records a row (记录默认开)");
-
-  const store2 = createStore(":memory:");
-  const service2 = createService({ store: store2, mirror: null, config: { recallRecordDefault: false } });
-  service2.setRecallRecorder((recall) => store2.saveRecallRun({
-    query: recall.query, mode: recall.mode, topK: recall.topK, threshold: recall.threshold ?? null,
-    candidates: recall.candidates ?? [], created_at: recall.createdAt
-  }));
-  service2.saveWithDedupe({ type: "preference", title: "量子计算入门", content: "叠加态" });
-  await service2.searchMemories("量子", { mode: "keyword" });
-  await service2.searchMemories("量子", { mode: "keyword", recordRecall: false });
-  assert.deepEqual(store2.listRecallRuns(), [], "no rows when recallRecordDefault=false or explicit false");
-  store.close();
-  store2.close();
+  await service.searchMemories("量子", { mode: "keyword", recordRecall: false });
+  assert.deepEqual(store.listRecallRuns(), [], "no rows without recordRecall=true");
 });

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

@@ -1,7 +1,5 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
 import { LocalReranker } from "../src/reranker.js";
 
 /** Injected scorer: records (query, passage) calls, returns a fixed score. */
@@ -197,44 +195,3 @@ test("dispose releases the loaded pipeline", async () => {
   assert.equal(r.pipeline, null);
   assert.equal(extractor.disposed, true);
 });
-
-test("default pipeline loader mirrors cache_dir onto env.cacheDir (issue #13)", () => {
-  // The fix lives in the module's *default* loader — the dynamic-import of
-  // @huggingface/transformers that the in-process tests bypass by injecting
-  // engineFactory. So it is exercised in a child node process under the
-  // --experimental-test-module-mocks flag: the transformers module is mocked
-  // with an empty env, LocalReranker uses the real default loader, and we
-  // assert env.cacheDir picks up the constructor's cache_dir. A regression
-  // (loader no longer mirroring) fails the child and surfaces here as a
-  // non-zero exit.
-  const srcUrl = new URL("../src/reranker.js", import.meta.url).href;
-  const cacheDir = "/tmp/dsh-mneme-cache-mirror-test";
-  const script = `
-    import { test } from "node:test";
-    const cacheDir = ${JSON.stringify(cacheDir)};
-    test("cache_dir is mirrored onto env.cacheDir", async (t) => {
-      t.mock.module("@huggingface/transformers", {
-        namedExports: {
-          env: {},
-          pipeline: async () => ({ dispose: () => {} })
-        }
-      });
-      const { LocalReranker } = await import(${JSON.stringify(srcUrl)});
-      const r = new LocalReranker({ cacheDir, device: "cpu" });
-      await r.init();
-      const { env } = await import("@huggingface/transformers");
-      if (env.cacheDir !== cacheDir) {
-        throw new Error("env.cacheDir not mirrored from cache_dir: " + env.cacheDir);
-      }
-      console.log("CACHE_MIRROR_OK");
-    });
-  `;
-  const res = spawnSync(process.execPath, [
-    "--experimental-test-module-mocks",
-    "--input-type=module",
-    "-e",
-    script
-  ], { encoding: "utf8", cwd: fileURLToPath(new URL("..", import.meta.url)) });
-  assert.equal(res.status, 0, `cache-dir mirror child failed:\n${res.stdout}\n${res.stderr}`);
-  assert.match(res.stdout, /CACHE_MIRROR_OK/);
-});

package/{dsh-mneme/test → test}/service-search.test.js

@@ -85,31 +85,6 @@ test("hybrid blend honors configured vector/keyword weights", async () => {
   assert.ok(Math.abs(t.score - 0.9) < 1e-9, `tuned blend ${t.score}`);
 });
 
-test("hybrid fusion clamps blended scores into [0,1]", async () => {
-  // Weights summing above 1 (1.0 + 1.0) push a same-memory blend over 1.0:
-  // title hit (importance 5) = 1 * (0.5 + 0.5) = 1.0, vector cosine = 1.0 →
-  // raw blend 1.0*1 + 1.0*1 = 2.0. The fused score must be clamped so
-  // consumers never see a score outside [0,1].
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {
-    hybridSearchVectorWeight: 1,
-    hybridSearchKeywordWeight: 1,
-    adaptiveThresholdEnabled: false,
-    searchSemanticDedup: false
-  } });
-  const vi = createVectorIndex({ store });
-  service.setEmbedder(embedder);
-  service.setVectorIndex(vi);
-  const m = service.saveWithDedupe({ type: "preference", title: "量子计算", content: "量子计算入门", importance: 5 });
-  vi.saveEmbedding(m.memory.id, [1, 0, 0]);
-
-  const rows = await service.searchMemories("量子计算", { mode: "hybrid", topK: 10 });
-  const hit = rows.find((r) => r.id === m.memory.id);
-  assert.ok(hit, "blended row is recalled");
-  assert.equal(hit.score, 1, `over-weight blend clamped to 1 (got ${hit.score})`);
-  assert.ok(hit.score >= 0 && hit.score <= 1);
-});
-
 test("auto = keyword leads, vector fills the remaining slots", async () => {
   const { service, vectorIndex } = setup();
   const kw = service.saveWithDedupe({ type: "preference", title: "量子计算", content: "量子计算入门" });

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

@@ -76,10 +76,6 @@ test("toApiList maps store rows to wire DTOs", () => {
   assert.equal(dto[0].title, "选型");
   assert.equal(dto[0].content, "node:sqlite");
   assert.equal(dto[0].importance, 3);
-  // session_id rides the DTO when present (session lifecycle needs it)
-  const withSession = service.saveWithDedupe({ type: "decision", title: "带会话", content: "y", session_id: "sess-x" });
-  const dto2 = service.toApiList([withSession.memory]);
-  assert.equal(dto2[0].session_id, "sess-x");
 });
 
 test("mergeHumanEdits skips edits without id and keeps applying the rest", () => {
@@ -331,105 +327,3 @@ test("Bug7: injection ranking re-weights by quality_score (degraded memories ran
   assert.equal(candidates[0].title, "高质量", "100-quality preference leads the degraded one");
   assert.equal(candidates[1].title, "元记忆");
 });
-
-// --- session lifecycle (v0.6.0): dispose/restore by session -----------------
-// session_disposed_at is orthogonal to `archived`: dispose hides only entries
-// born in the deleted session, and restore never resurrects user-archived ones.
-
-test("disposeBySession marks only that session's memories", () => {
-  const store = createStore(":memory:");
-  const svc = createService({ store, mirror: null, config: {} });
-  const s1 = svc.saveWithDedupe({ type: "project", title: "会话A记忆", content: "x", session_id: "sess-1" });
-  svc.saveWithDedupe({ type: "project", title: "会话B记忆", content: "y", session_id: "sess-2" });
-
-  const res = svc.disposeBySession("sess-1");
-  assert.deepEqual(res, { disposed: 1 });
-  assert.ok(svc.getById(s1.memory.id).session_disposed_at, "session-1 memory marked disposed");
-  // disposed memories vanish from default list (like archived)
-  assert.ok(!svc.list({ type: "project" }).some((m) => m.id === s1.memory.id), "disposed hidden from default list");
-  const other = svc.list({ type: "project", includeDisposed: true });
-  assert.ok(other.some((m) => m.title === "会话B记忆" && !m.session_disposed_at), "other session untouched");
-});
-
-test("restoreBySession clears the dispose mark and makes entries visible again", () => {
-  const store = createStore(":memory:");
-  const svc = createService({ store, mirror: null, config: {} });
-  const s1 = svc.saveWithDedupe({ type: "project", title: "存档会话", content: "x", session_id: "sess-9" });
-  svc.disposeBySession("sess-9");
-
-  assert.ok(!svc.list({ type: "project" }).some((m) => m.id === s1.memory.id), "hidden while disposed");
-  const res = svc.restoreBySession("sess-9");
-  assert.deepEqual(res, { restored: 1 });
-  assert.equal(svc.getById(s1.memory.id).session_disposed_at, undefined, "dispose mark cleared");
-  assert.ok(svc.list({ type: "project" }).some((m) => m.id === s1.memory.id), "visible again");
-});
-
-test("disposeBySession is idempotent: re-disposing returns 0", () => {
-  const store = createStore(":memory:");
-  const svc = createService({ store, mirror: null, config: {} });
-  svc.saveWithDedupe({ type: "project", title: "重复销毁", content: "x", session_id: "sess-3" });
-
-  assert.deepEqual(svc.disposeBySession("sess-3"), { disposed: 1 });
-  assert.deepEqual(svc.disposeBySession("sess-3"), { disposed: 0 }, "no rows flipped the second time");
-});
-
-test("disposeBySession on an unknown session is a no-op", () => {
-  const store = createStore(":memory:");
-  const svc = createService({ store, mirror: null, config: {} });
-  assert.deepEqual(svc.disposeBySession("nope"), { disposed: 0 });
-  assert.deepEqual(svc.restoreBySession("nope"), { restored: 0 });
-});
-
-test("legacy rows without session_id are never touched by session lifecycle", () => {
-  const store = createStore(":memory:");
-  const svc = createService({ store, mirror: null, config: {} });
-  const legacy = svc.saveWithDedupe({ type: "preference", title: "全局记忆", content: "no session", session_id: undefined });
-
-  svc.disposeBySession("sess-x");
-  assert.equal(svc.getById(legacy.memory.id).session_disposed_at, undefined, "global memory survives session dispose");
-});
-
-test("restoreBySession does NOT resurrect user-archived memories (orthogonal)", () => {
-  const store = createStore(":memory:");
-  const svc = createService({ store, mirror: null, config: {} });
-  // user manually archived this one (archived=true), then the session is disposed
-  const { memory: userArchived } = svc.saveWithDedupe({ type: "decision", title: "手动归档", content: "x", session_id: "sess-4" });
-  svc.setArchived(userArchived.id, true);
-  svc.disposeBySession("sess-4");
-
-  svc.restoreBySession("sess-4");
-  assert.equal(svc.getById(userArchived.id).archived, true, "user archive survives restore");
-  assert.equal(svc.getById(userArchived.id).session_disposed_at, undefined, "dispose mark cleared but archive kept");
-  assert.ok(!svc.list({ type: "decision" }).some((m) => m.id === userArchived.id), "still hidden by user archive");
-});
-
-test("listBySession returns only that session's memories via wire DTOs", () => {
-  const store = createStore(":memory:");
-  const svc = createService({ store, mirror: null, config: {} });
-  const { memory } = svc.saveWithDedupe({ type: "decision", title: "会话决策", content: "d", session_id: "sess-7" });
-  svc.saveWithDedupe({ type: "decision", title: "别会话", content: "e", session_id: "sess-8" });
-
-  const rows = svc.listBySession("sess-7");
-  assert.equal(rows.length, 1);
-  assert.equal(rows[0].id, memory.id);
-  assert.equal(rows[0].title, "会话决策");
-  assert.equal(rows[0].session_id, "sess-7");
-});
-
-test("listBySession DTO hides disposed by default and flags it when included", () => {
-  const store = createStore(":memory:");
-  const svc = createService({ store, mirror: null, config: {} });
-  const { memory } = svc.saveWithDedupe({ type: "decision", title: "会话决策", content: "d", session_id: "sess-9" });
-  svc.disposeBySession("sess-9");
-
-  assert.equal(svc.listBySession("sess-9").length, 0, "disposed hidden by default");
-  const visible = svc.listBySession("sess-9", { includeDisposed: true });
-  assert.equal(visible.length, 1);
-  assert.equal(visible[0].id, memory.id);
-  assert.equal(visible[0].disposed, true, "DTO carries disposed marker so restore is not blind");
-
-  svc.restoreBySession("sess-9");
-  const restored = svc.listBySession("sess-9");
-  assert.equal(restored.length, 1, "restore brings it back to default view");
-  assert.equal(restored[0].disposed, undefined, "marker cleared after restore");
-});

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

@@ -99,46 +99,3 @@ test("vector config disabled value is stored as false", () => {
   assert.equal(settings.getVectorConfig().enabled, false);
   store.close();
 });
-
-test("autoTag config defaults to null (unset) and round-trips only explicit keys", () => {
-  const { store, settings } = setup();
-  // Issue #31: an unset key is null so runtime consumers fall back to the
-  // plugin config default — the settings layer must not invent `false`.
-  assert.deepEqual(settings.getAutoTagConfig(), { autoTagEnabled: null, manualTagEnabled: null });
-  settings.setAutoTagConfig({ autoTagEnabled: true, manualTagEnabled: true });
-  assert.deepEqual(settings.getAutoTagConfig(), { autoTagEnabled: true, manualTagEnabled: true });
-  // A partial update only touches the key it was given: manualTagEnabled was
-  // stored earlier so it keeps its value (true), it does not revert to null.
-  settings.setAutoTagConfig({ autoTagEnabled: false });
-  assert.deepEqual(settings.getAutoTagConfig(), { autoTagEnabled: false, manualTagEnabled: true });
-  store.close();
-});
-
-test("autoTag config coerces non-boolean to false", () => {
-  const { store, settings } = setup();
-  settings.setAutoTagConfig({ autoTagEnabled: "yes", manualTagEnabled: 1 });
-  assert.deepEqual(settings.getAutoTagConfig(), { autoTagEnabled: false, manualTagEnabled: false });
-  store.close();
-});
-
-test("ui config (sidebar trigger) defaults to null and round-trips only explicit keys", () => {
-  const { store, settings } = setup();
-  // Issue #38: same settings-over-config pattern as the tag toggles — an unset
-  // key is null so consumers fall back to the plugin-config default (visible).
-  assert.deepEqual(settings.getUiConfig(), { showSidebarTrigger: null });
-  settings.setUiConfig({ showSidebarTrigger: false });
-  assert.deepEqual(settings.getUiConfig(), { showSidebarTrigger: false });
-  settings.setUiConfig({ showSidebarTrigger: true });
-  assert.deepEqual(settings.getUiConfig(), { showSidebarTrigger: true });
-  // A partial update with no showSidebarTrigger keeps the stored value.
-  settings.setUiConfig({});
-  assert.deepEqual(settings.getUiConfig(), { showSidebarTrigger: true });
-  store.close();
-});
-
-test("ui config coerces non-boolean to false", () => {
-  const { store, settings } = setup();
-  settings.setUiConfig({ showSidebarTrigger: "yes" });
-  assert.deepEqual(settings.getUiConfig(), { showSidebarTrigger: false });
-  store.close();
-});