@modusensus/dsh-mneme 0.7.10 → 0.7.12

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

@@ -45,14 +45,6 @@ function baseConfig(overrides = {}) {
   };
 }
 
-// v0.7.0 热联合判定：慢衰减类型（project λ=0.0008）默认受热闸保护——40 天热值
-// ≈0.5、100 天 ≈0.28，始终高于 sleepHeatThreshold(0.05)，demotion 不触发。
-// 降级语义测试把 project 的 λ 调快到 0.02（40 天热值≈0.03），复现"时间窗冷态
-// 即降级"的旧路径；默认保守语义由 sleep-heat.test.js 单独覆盖。
-function demotionConfig(overrides = {}) {
-  return baseConfig({ heatTypeDecay: { project: 0.02 }, ...overrides });
-}
-
 function setup() {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
@@ -181,7 +173,7 @@ test("sleep: demotion shrinks cold memory to summary, keeps _full_content", asyn
   const m = makeMemory(service, "cold", "原内容".repeat(60), "project");
   service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
   const ctx = mockCtx(() => "[]");
-  const result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
   const after = service.getById(m.id);
   assert.equal(result.status, "ok");
   assert.ok(after._full_content && after._full_content.length > 0, "full body preserved");
@@ -196,7 +188,7 @@ test("sleep: demotion fully archives memory past sleepCompressDays", async () =>
   const m = makeMemory(service, "ancient", "很老的记忆", "project");
   service.touchLastAccess(m.id, new Date(now - 100 * 86400000).toISOString());
   const ctx = mockCtx(() => "[]");
-  const result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
   const after = service.getById(m.id);
   assert.equal(result.status, "ok");
   assert.equal(after.archived, true, "past compress days → archived");
@@ -283,7 +275,7 @@ test("sleep: a failing phase does not block the others (fail-safe)", async () =>
   const m = makeMemory(service, "cold", "内容".repeat(60), "project");
   service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
   const ctx = mockCtx(() => "[]");
-  const result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
   assert.equal(result.phases.conflicts.status, "skipped", "conflicts phase degraded gracefully (no usable vectors)");
   assert.equal(result.phases.demotion.status, "ok", "demotion still ran");
   assert.equal(result.status, "ok", "overall run still ok despite conflicts degrading");
@@ -297,7 +289,7 @@ test("sleep: no LLM route skips LLM phases but demotion still runs", async () =>
   const m = makeMemory(service, "cold", "内容".repeat(60), "project");
   service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
   const ctx = mockCtx(() => "[]", null); // currentSelection() → null, no route
-  const result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
   assert.equal(result.phases.conflicts.status, "skipped", "no llm route → conflicts skipped");
   assert.equal(result.phases.patterns.status, "skipped", "no llm route → patterns skipped");
   assert.equal(result.phases.demotion.status, "ok", "demotion is LLM-free and runs");
@@ -371,162 +363,3 @@ test("sleep: runSleep is abortable via signal between phases", async () => {
   assert.equal(result.phases.conflicts, undefined, "aborted before any phase ran");
   store.close();
 });
-
-// ------------------------------------------------ entity extraction (issue #23)
-
-// Write-path extractor is gated on entityExtractionEnabled (default off), so
-// default installs never accumulate entities → ego-graph panel blank. This
-// sleep phase backfills it; these tests cover gating, idempotence and
-// fail-safe batching.
-const ENTITY_LLM_JSON = JSON.stringify({
-  entities: [{ name: "X", type: "concept", attrs: [{ key: "k", value: "v" }] }],
-  relations: []
-});
-
-test("sleep: entity extraction skips when disabled", async () => {
-  const { service, store } = setup();
-  makeMemory(service, "记忆A", "内容A", "history");
-  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
-  const result = await runSleep(
-    ctx, service,
-    baseConfig({ sleepEntityExtractionEnabled: false }),
-    ctx.logger, null, null
-  );
-  assert.equal(result.phases["entity-extraction"].status, "skipped", "disabled → skipped");
-  store.close();
-});
-
-test("sleep: extracted memories are stamped and not re-extracted", async () => {
-  const { service, store } = setup();
-  const mem = makeMemory(service, "记忆B", "内容B", "history");
-  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
-  const config = baseConfig({ sleepEntityExtractionEnabled: true });
-  // First cycle backfills → memory gets entity_extracted_at stamped.
-  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(first.phases["entity-extraction"].status, "ok", "first cycle extracts");
-  assert.ok(service.getById(mem.id).metadata?.entity_extracted_at, "stamp written");
-  // Second cycle has nothing un-stamped left → skipped.
-  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(second.phases["entity-extraction"].status, "skipped", "nothing left to extract");
-  store.close();
-});
-
-test("sleep: entity-less extracts are stamped so they are not re-queued forever", async () => {
-  const { service, store } = setup();
-  const mem = makeMemory(service, "无实体记忆", "这里没有任何实体", "history");
-  // LLM legitimately returns no entities — must still be stamped, else every
-  // sleep cycle re-extracts the same text forever (issue #23 regression).
-  const ctx = mockCtx(() => JSON.stringify({ entities: [], relations: [] }), { provider: "p", model: "m" });
-  const config = baseConfig({ sleepEntityExtractionEnabled: true });
-  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(first.phases["entity-extraction"].status, "ok", "empty extract counts as handled");
-  assert.equal(first.phases["entity-extraction"].extracted, 1);
-  assert.ok(service.getById(mem.id).metadata?.entity_extracted_at, "stamp written even with no entities");
-  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(second.phases["entity-extraction"].status, "skipped", "stamped → not re-queued");
-  store.close();
-});
-
-test("sleep: entity extraction backfills entities for un-extracted memories", async () => {
-  const { service, store } = setup();
-  const mem = makeMemory(service, "记忆C", "内容C", "history");
-  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
-  const result = await runSleep(
-    ctx, service,
-    baseConfig({ sleepEntityExtractionEnabled: true }),
-    ctx.logger, null, null
-  );
-  const phase = result.phases["entity-extraction"];
-  assert.equal(phase.status, "ok");
-  assert.equal(phase.extracted, 1);
-  assert.ok(store.listEntities().length > 0, "entity minted");
-  assert.ok(service.getAttrsByMemory(mem.id).length > 0, "memory now carries entity attrs");
-  store.close();
-});
-
-test("sleep: a failing extraction does not abort the batch and retries next cycle", async () => {
-  const { service, store } = setup();
-  const bad = makeMemory(service, "坏记忆", "bad 内容", "history");
-  const good = makeMemory(service, "好记忆", "good 内容", "history");
-  const ctx = mockCtx(
-    (user) => (String(user).includes("bad") ? "这不是合法JSON{{{" : ENTITY_LLM_JSON),
-    { provider: "p", model: "m" }
-  );
-  const config = baseConfig({ sleepEntityExtractionEnabled: true });
-  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
-  const phase = first.phases["entity-extraction"];
-  assert.equal(phase.extracted, 1, "good memory extracted");
-  assert.equal(phase.failed, 1, "bad memory counted as failed");
-  assert.equal(phase.status, "ok", "partial success is ok");
-  assert.ok(store.listEntities().length > 0, "at least one entity minted");
-  // Good memory stamped; bad one not → second cycle retries only the bad one.
-  assert.ok(service.getById(good.id).metadata?.entity_extracted_at, "good memory stamped");
-  assert.equal(service.getById(bad.id).metadata?.entity_extracted_at, undefined, "failed memory not stamped");
-  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(second.phases["entity-extraction"].extracted, 0, "bad memory still fails");
-  assert.equal(second.phases["entity-extraction"].failed, 1, "failed memory retried");
-  store.close();
-});
-
-test("sleep: metadata merge keeps unrelated fields when stamping (review #4)", async () => {
-  const { service, store } = setup();
-  const mem = makeMemory(service, "记忆M", "内容M", "history");
-  service.setMemoryMetadata(mem.id, { custom_flag: "keep-me" });
-  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
-  await runSleep(ctx, service, baseConfig({ sleepEntityExtractionEnabled: true }), ctx.logger, null, null);
-  const meta = service.getById(mem.id).metadata;
-  assert.equal(meta.custom_flag, "keep-me", "pre-existing metadata not clobbered");
-  assert.ok(meta.entity_extracted_at, "stamp added alongside");
-  store.close();
-});
-
-test("sleep: pending_extracted_at is cleared on success and on failure (review #3)", async () => {
-  const { service, store } = setup();
-  const good = makeMemory(service, "好记忆", "内容G", "history");
-  const bad = makeMemory(service, "坏记忆", "bad 内容", "history");
-  const ctx = mockCtx(
-    (user) => (String(user).includes("bad") ? "不是JSON{{{" : ENTITY_LLM_JSON),
-    { provider: "p", model: "m" }
-  );
-  const config = baseConfig({ sleepEntityExtractionEnabled: true });
-  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
-  const phase = first.phases["entity-extraction"];
-  assert.equal(phase.extracted, 1);
-  assert.equal(phase.failed, 1);
-  assert.equal(service.getById(good.id).metadata?.pending_extracted_at, null, "success clears pending");
-  assert.equal(service.getById(bad.id).metadata?.pending_extracted_at, null, "failure clears pending");
-  store.close();
-});
-
-test("sleep: all-failed extraction surfaces failed status through deriveStatus (review #5)", async () => {
-  const { service, store } = setup();
-  makeMemory(service, "坏记忆1", "bad 一", "history");
-  makeMemory(service, "坏记忆2", "bad 二", "history");
-  const ctx = mockCtx(() => "不是JSON{{{", { provider: "p", model: "m" });
-  const result = await runSleep(ctx, service, baseConfig({ sleepEntityExtractionEnabled: true }), ctx.logger, null, null);
-  const phase = result.phases["entity-extraction"];
-  assert.equal(phase.status, "failed", "all-failed extraction reports failed");
-  assert.equal(phase.failed, 2);
-  assert.ok(["failed", "degraded"].includes(result.status), "deriveStatus folds failed into run status");
-  store.close();
-});
-
-test("store: listForEntityExtraction pages oldest un-stamped candidates (review #2)", async () => {
-  const { service, store } = setup();
-  const a = makeMemory(service, "甲", "内容甲", "history");
-  makeMemory(service, "乙", "内容乙", "history");
-  const archived = makeMemory(service, "归档", "内容归档", "history");
-  store.setArchived(archived.id, true);
-  makeMemory(service, "摘要", "内容摘要", "summary");
-  makeMemory(service, "丙", "内容丙", "history"); // second un-stamped candidate so oldest-first has two to compare
-  service.setMemoryMetadata(a.id, { entity_extracted_at: new Date().toISOString() });
-  const list = store.listForEntityExtraction({ limit: 10, offset: 0 });
-  const titles = list.map((m) => m.title);
-  assert.ok(!titles.includes("归档"), "archived excluded");
-  assert.ok(!titles.includes("摘要"), "summary excluded");
-  assert.ok(!titles.includes("甲"), "already-stamped excluded");
-  assert.ok(titles.includes("乙"), "un-stamped included");
-  assert.ok(titles.includes("丙"), "un-stamped included");
-  assert.equal(list[0].created_at <= list[1].created_at, true, "oldest first");
-  store.close();
-});

package/test/standalone-api.test.js

@@ -0,0 +1,326 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSettings } from "../src/settings.js";
+import { createStandaloneApi } from "../src/api-standalone.js";
+import { Config, applyLightModePreset } from "../src/config.js";
+
+// Real HTTP server on an OS-assigned port (port: 0), driven with fetch.
+async function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const api = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: 0 });
+  await api.ready;
+  const base = `http://127.0.0.1:${api.port}`;
+  const auth = { authorization: `Bearer ${api.token}` };
+  return {
+    store,
+    service,
+    settings,
+    api,
+    base,
+    auth,
+    close: () => {
+      // Drop pooled keep-alive sockets so node --test can drain the loop.
+      api.server.closeIdleConnections?.();
+      api.server.close();
+      store.close();
+    }
+  };
+}
+
+// --- auth ---------------------------------------------------------------------
+
+test("GET /health is open without a token; every other route 401s", async () => {
+  const { base, close } = await setup();
+  try {
+    const health = await fetch(`${base}/health`);
+    assert.equal(health.status, 200);
+    assert.deepEqual(await health.json(), { ok: true });
+
+    for (const path of ["/status", "/memories", "/memories/x", "/search?q=x"]) {
+      const res = await fetch(`${base}${path}`);
+      assert.equal(res.status, 401, `${path} requires a token`);
+      assert.deepEqual(await res.json(), { error: "unauthorized" });
+    }
+
+    const bad = await fetch(`${base}/status`, { headers: { authorization: "Bearer wrong-token" } });
+    assert.equal(bad.status, 401, "wrong token rejected");
+  } finally {
+    close();
+  }
+});
+
+test("token is persisted into settings kv and reused across restarts", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const first = createStandaloneApi({ service, store, config: {}, settings, port: 0 });
+  await first.ready;
+  try {
+    assert.equal(settings.getExternalApi().token, first.token, "generated token persisted");
+    assert.ok(first.token.length >= 20, "token is a real random value");
+    const second = createStandaloneApi({ service, store, config: {}, settings, port: 0 });
+    await second.ready;
+    assert.equal(second.token, first.token, "restart reuses the persisted token");
+    second.server.closeIdleConnections?.();
+    second.server.close();
+  } finally {
+    first.server.closeIdleConnections?.();
+    first.server.close();
+    store.close();
+  }
+});
+
+// --- CRUD loop ------------------------------------------------------------------
+
+test("POST/GET/DELETE /memories round trip", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const post = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "preference", title: "语言", content: "始终用中文回复", importance: 4, tags: ["交流"] })
+    });
+    assert.equal(post.status, 201);
+    const created = await post.json();
+    assert.ok(created.id, "row id returned");
+    assert.equal(created.title, "语言");
+    assert.equal(created.importance, 4);
+
+    const list = await fetch(`${base}/memories?limit=10`, { headers: auth });
+    assert.equal(list.status, 200);
+    const listBody = await list.json();
+    assert.equal(listBody.total, 1);
+    assert.equal(listBody.items.length, 1);
+
+    const got = await fetch(`${base}/memories/${created.id}`, { headers: auth });
+    assert.equal(got.status, 200);
+    assert.equal((await got.json()).content, "始终用中文回复");
+
+    const del = await fetch(`${base}/memories/${created.id}`, { method: "DELETE", headers: auth });
+    assert.equal(del.status, 200);
+    assert.deepEqual(await del.json(), { ok: true });
+
+    const gone = await fetch(`${base}/memories/${created.id}`, { headers: auth });
+    assert.equal(gone.status, 404, "deleted row reads back as 404");
+    const delAgain = await fetch(`${base}/memories/${created.id}`, { method: "DELETE", headers: auth });
+    assert.equal(delAgain.status, 404, "deleting a missing row is 404, not a fake ok");
+  } finally {
+    close();
+  }
+});
+
+test("POST /memories dedupes same title within a type (200 + merged content)", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const first = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "mneme", content: "v1 内容" })
+    });
+    assert.equal(first.status, 201);
+    const row1 = await first.json();
+
+    const second = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "mneme", content: "v2 追加" })
+    });
+    assert.equal(second.status, 200, "merge, not a second creation");
+    const row2 = await second.json();
+    assert.equal(row2.id, row1.id, "same row reused");
+    assert.ok(row2.content.includes("v1 内容") && row2.content.includes("v2 追加"), "content appended");
+
+    const list = await fetch(`${base}/memories`, { headers: auth });
+    assert.equal((await list.json()).total, 1, "no duplicate row created");
+  } finally {
+    close();
+  }
+});
+
+test("POST /memories validation: invalid type, bad JSON, non-array tags → 400", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const badType = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "diary", title: "t", content: "c" })
+    });
+    assert.equal(badType.status, 400);
+    assert.deepEqual(await badType.json(), { error: "invalid-type" });
+
+    const badJson = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: "{not json"
+    });
+    assert.equal(badJson.status, 400);
+    assert.deepEqual(await badJson.json(), { error: "invalid-json" });
+
+    const badTags = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "t", content: "c", tags: "x" })
+    });
+    assert.equal(badTags.status, 400);
+    assert.deepEqual(await badTags.json(), { error: "tags-must-be-an-array" });
+
+    const noTitle = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", content: "c" })
+    });
+    assert.equal(noTitle.status, 400);
+    assert.deepEqual(await noTitle.json(), { error: "missing-title" });
+  } finally {
+    close();
+  }
+});
+
+// --- list filters / status / search ---------------------------------------------
+
+test("GET /memories honors type + minImportance filters and paging", async () => {
+  const { base, auth, service, close } = await setup();
+  try {
+    service.saveWithDedupe({ type: "preference", title: "低", content: "i2", importance: 2 });
+    service.saveWithDedupe({ type: "preference", title: "高", content: "i5", importance: 5 });
+    service.saveWithDedupe({ type: "project", title: "项目", content: "i4", importance: 4 });
+
+    const byType = await fetch(`${base}/memories?type=preference`, { headers: auth });
+    assert.equal((await byType.json()).total, 2);
+
+    const byImportance = await fetch(`${base}/memories?minImportance=4`, { headers: auth });
+    const filtered = await byImportance.json();
+    assert.equal(filtered.total, 2);
+    assert.deepEqual(filtered.items.map((m) => m.title).sort(), ["项目", "高"]);
+
+    const paged = await fetch(`${base}/memories?limit=2&offset=0&order=chrono`, { headers: auth });
+    const page = await paged.json();
+    assert.equal(page.items.length, 2);
+    assert.equal(page.total, 3);
+  } finally {
+    close();
+  }
+});
+
+test("GET /status reports version, per-type totals, entities and uptime", async () => {
+  const { base, auth, service, close } = await setup();
+  try {
+    service.saveWithDedupe({ type: "preference", title: "p", content: "c" });
+    service.saveWithDedupe({ type: "project", title: "j", content: "c" });
+    service.saveWithDedupe({ type: "project", title: "j2", content: "c" });
+
+    const res = await fetch(`${base}/status`, { headers: auth });
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.equal(body.version, "0.7.12");
+    assert.equal(body.memories.total, 3);
+    assert.equal(body.memories.byType.preference, 1);
+    assert.equal(body.memories.byType.project, 2);
+    assert.equal(body.entities, 0, "no extraction wired → empty entity table");
+    assert.ok(Number.isInteger(body.uptime_s));
+  } finally {
+    close();
+  }
+});
+
+test("GET /search finds saved memories; empty q returns empty keyword result", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "记忆插件", content: "SQLite 全文检索" })
+    });
+
+    const res = await fetch(`${base}/search?q=${encodeURIComponent("全文检索")}&mode=keyword`, { headers: auth });
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.equal(body.mode, "keyword");
+    assert.equal(body.items.length, 1);
+    assert.equal(body.items[0].title, "记忆插件");
+
+    const empty = await fetch(`${base}/search?q=`, { headers: auth });
+    assert.deepEqual(await empty.json(), { items: [], mode: "keyword" });
+  } finally {
+    close();
+  }
+});
+
+test("unknown path returns 404 json", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const res = await fetch(`${base}/nope`, { headers: auth });
+    assert.equal(res.status, 404);
+    assert.deepEqual(await res.json(), { error: "not-found" });
+  } finally {
+    close();
+  }
+});
+
+// --- light-mode preset (applyLightModePreset) ------------------------------------
+
+const LIGHT_OFF_FIELDS = [
+  "entityExtractionEnabled",
+  "autoDream",
+  "sleepModeEnabled",
+  "rerankEnabled",
+  "autoReindexOnBoot",
+  "hybridInject",
+  "searchSemanticDedup",
+  "selectiveInjectEnabled",
+  "bm25SearchEnabled"
+];
+
+test("applyLightModePreset turns heavy features off and keeps the core loop", () => {
+  const cfg = applyLightModePreset(Config({ lightMode: true }));
+  for (const field of LIGHT_OFF_FIELDS) {
+    assert.equal(cfg[field], false, `${field} forced off in light mode`);
+  }
+  // Core loop preserved.
+  assert.equal(cfg.autoInject, true);
+  assert.equal(cfg.autoSummarize, true);
+  assert.equal(cfg.hotMemoryEnabled, true);
+  assert.equal(cfg.memoryQualityFilter.enabled, true);
+  // Unrelated knobs untouched.
+  assert.equal(cfg.dreamThresholdCount, 10);
+  assert.equal(cfg.dreamDelayMs, 2000);
+  assert.equal(cfg.maxInjectedItems, 5);
+});
+
+test("applyLightModePreset keeps explicit non-preset values and is a no-op without lightMode", () => {
+  const tuned = applyLightModePreset(Config({ lightMode: true, dreamThresholdCount: 30, maxInjectedItems: 8 }));
+  assert.equal(tuned.dreamThresholdCount, 30, "operator values survive the preset");
+  assert.equal(tuned.maxInjectedItems, 8);
+
+  const plain = Config({});
+  assert.equal(applyLightModePreset(plain), plain, "identity when lightMode is unset");
+  const off = Config({ lightMode: false });
+  assert.equal(applyLightModePreset(off), off, "identity when lightMode is false");
+});
+
+test("persisted panel_mode=light wins over a bundle config that did not ask for it", () => {
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  try {
+    // Panel switched to light in a previous session; bundle config says nothing.
+    settings.setPanelMode("light");
+    const rawCfg = Config({});
+    const lightMode = rawCfg.lightMode === true || settings.getPanelMode() === "light";
+    const cfg = applyLightModePreset({ ...rawCfg, lightMode });
+    assert.equal(lightMode, true, "persisted mode forces light");
+    assert.equal(cfg.autoDream, false);
+    assert.equal(cfg.entityExtractionEnabled, false);
+    assert.equal(cfg.autoInject, true, "core injection stays on");
+
+    // standard (default) never forces the preset even with a light bundle flag off.
+    settings.setPanelMode("standard");
+    const raw2 = Config({});
+    assert.equal(raw2.lightMode === true || settings.getPanelMode() === "light", false);
+  } finally {
+    store.close();
+  }
+});

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

@@ -358,79 +358,3 @@ test("conflict_pending table persists across store reopen", () => {
   assert.equal(pending[0].reason, "x");
   s2.close();
 });
-
-// --- session lifecycle (v0.6.0): disposed rows are filtered out ------------
-
-test("session_disposed_at column exists and survives migration", () => {
-  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-disposed-"));
-  const path = join(dir, "memory.db");
-  const s1 = createStore(path);
-  const { id } = s1.save({ type: "decision", title: "迁移", content: "c", session_id: "sess-m" });
-  s1.setDisposedBySession("sess-m", true);
-  const row = s1.db.prepare("SELECT session_disposed_at FROM memories WHERE id = ?").get(id);
-  assert.ok(row.session_disposed_at, "dispose timestamp persisted");
-  s1.close();
-  // reopen: column survives
-  const s2 = createStore(path);
-  const live = s2.list({ type: "decision" });
-  assert.ok(!live.some((m) => m.id === id), "disposed row excluded after reopen");
-  s2.close();
-});
-
-test("search and list exclude disposed rows unless includeDisposed", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "decision", title: "活着", content: "keyword alpha", session_id: "s1" });
-  const b = store.save({ type: "decision", title: "被销毁", content: "keyword beta", session_id: "s2" });
-  store.setDisposedBySession("s2", true);
-
-  const searchRes = store.search("keyword");
-  assert.ok(searchRes.some((m) => m.id === a.id), "live row found");
-  assert.ok(!searchRes.some((m) => m.id === b.id), "disposed row excluded from search");
-  const searchIncl = store.search("keyword", { includeDisposed: true });
-  assert.ok(searchIncl.some((m) => m.id === b.id), "includeDisposed surfaces it");
-
-  const listRes = store.list({ type: "decision" });
-  assert.ok(listRes.some((m) => m.id === a.id));
-  assert.ok(!listRes.some((m) => m.id === b.id), "disposed excluded from list");
-  const listIncl = store.list({ type: "decision", includeDisposed: true });
-  assert.ok(listIncl.some((m) => m.id === b.id), "includeDisposed lists it");
-  assert.equal(store.count("decision", { includeDisposed: true }), 2);
-});
-
-test("searchVector excludes disposed rows", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "decision", title: "向量A", content: "v", session_id: "s1" });
-  const b = store.save({ type: "decision", title: "向量B", content: "v", session_id: "s2" });
-  store.setEmbedding(a.id, [1, 0, 0]);
-  store.setEmbedding(b.id, [1, 0, 0]);
-  store.setDisposedBySession("s2", true);
-
-  const res = store.searchVector([1, 0, 0], { limit: 10 });
-  assert.ok(res.some((m) => m.id === a.id));
-  assert.ok(!res.some((m) => m.id === b.id), "disposed row excluded from vector search");
-});
-
-test("setDisposedBySession round-trips and listBySession sees all states", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "decision", title: "会话记忆", content: "c", session_id: "sess-z" });
-  assert.equal(store.setDisposedBySession("sess-z", true), 1, "first dispose flips 1");
-  assert.equal(store.setDisposedBySession("sess-z", true), 0, "re-dispose is a no-op");
-  assert.equal(store.setDisposedBySession("sess-z", false), 1, "restore flips 1");
-  assert.equal(store.setDisposedBySession("sess-z", false), 0, "re-restore is a no-op");
-  assert.equal(store.getById(a.id).session_disposed_at, undefined, "mark cleared after restore");
-
-  const bySession = store.listBySession("sess-z");
-  assert.equal(bySession.length, 1);
-  assert.equal(bySession[0].id, a.id);
-});
-
-test("listBySession hides disposed by default, includeDisposed opts in", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "decision", title: "会话记忆", content: "c", session_id: "sess-y" });
-  store.setDisposedBySession("sess-y", true);
-
-  assert.equal(store.listBySession("sess-y").length, 0, "disposed row hidden by default");
-  const all = store.listBySession("sess-y", { includeDisposed: true });
-  assert.equal(all.length, 1, "includeDisposed reveals it");
-  assert.equal(all[0].id, a.id);
-});

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

@@ -85,21 +85,6 @@ test("turn/end event triggers summarization and stores entries", async () => {
   assert.ok(all.some((m) => m.type === "preference"));
 });
 
-test("session with only snapshotEvents() (DSH 0.1.2-rc.1) still summarizes", async () => {
-  const { events, store } = setup();
-  const handler = events.find((e) => e.name === "session/event").fn;
-  const session = {
-    id: "s6",
-    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
-    snapshotEvents: () => [userMessage("用快照接口提问"), { seq: 2, type: "turn/end" }]
-  };
-  await handler(session, { seq: 2, type: "turn/end" });
-  assert.equal(store.count(), 2);
-  const all = store.all();
-  assert.ok(all.some((m) => m.type === "decision"));
-  assert.ok(all.some((m) => m.type === "preference"));
-});
-
 test("skips summarization for events other than turn/end", async () => {
   const { events, store, calls } = setup();
   const handler = events.find((e) => e.name === "session/event").fn;
@@ -109,6 +94,22 @@ test("skips summarization for events other than turn/end", async () => {
   assert.equal(calls.length, 0);
 });
 
+// DSH ≥0.1.2-rc removed Session.events; the session object only exposes
+// snapshotEvents(). Regression for #59: with only the old .events path the
+// collector saw an empty log and no LLM call ever happened.
+test("reads events from snapshotEvents() when Session.events is absent", async () => {
+  const { events, store, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s1",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    snapshotEvents: () => [userMessage("帮我选型"), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "an LLM call must be made");
+  assert.equal(store.count(), 2);
+});
+
 test("dispose unsubscribes and stops later turn/end events from summarizing", async () => {
   const { events, summarizer, calls } = setup();
   const handler = events.find((e) => e.name === "session/event").fn;