@modusensus/dsh-mneme 0.7.16 → 0.7.18

package/src/store.js

@@ -637,7 +637,7 @@ export function createStore(path) {
     return ts;
   }
 
-  function count(type, { minImportance = null, source = null, includeForgotten = false, includeArchived = false, onlyArchived = false, updatedFrom = null, updatedTo = null } = {}) {
+  function count(type, { minImportance = null, source = null, includeForgotten = false, includeArchived = false, onlyArchived = false, depositedOnly = false, updatedFrom = null, updatedTo = null } = {}) {
     const clauses = [];
     const params = [];
     if (type !== undefined) {
@@ -673,6 +673,12 @@ export function createStore(path) {
     } else if (!includeArchived) {
       clauses.push("archived = 0");
     }
+    // 与 list() 同过滤：deposited 视图的 total 才能和行保持一致。
+    if (depositedOnly) {
+      clauses.push(
+        "(id IN (SELECT record_id FROM receipt_chain WHERE kind IN ('merge', 'update') AND verdict = 'live') OR source = 'dream')"
+      );
+    }
     const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
     return db.prepare(`SELECT count(*) AS c FROM memories ${where}`).get(...params).c;
   }
@@ -924,7 +930,7 @@ export function createStore(path) {
     return rows.map(toRow);
   }
 
-  function list({ type, limit = 50, offset = 0, order = "importance", includeForgotten = false, includeArchived = false, onlyArchived = false, minImportance = null, source = null, updatedFrom = null, updatedTo = null } = {}) {
+  function list({ type, limit = 50, offset = 0, order = "importance", includeForgotten = false, includeArchived = false, onlyArchived = false, depositedOnly = false, minImportance = null, source = null, updatedFrom = null, updatedTo = null } = {}) {
     const clauses = [];
     const params = [];
     if (type) {
@@ -962,6 +968,14 @@ export function createStore(path) {
     } else if (!includeArchived) {
       clauses.push("archived = 0");
     }
+    // depositedOnly：只看 autoDream 巩固过的记忆——receipt_chain 的 merge /
+    // update live verdict（record_id 即保留/更新目标）∪ source="dream" 的
+    // 直写沉淀（记忆库总览）。conflict 不算沉淀：两侧只被仲裁，内容未落。
+    if (depositedOnly) {
+      clauses.push(
+        "(id IN (SELECT record_id FROM receipt_chain WHERE kind IN ('merge', 'update') AND verdict = 'live') OR source = 'dream')"
+      );
+    }
     const { limit: lim, offset: off } = sanitizePage(limit, offset, 50);
     const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
     // "chrono" is pure newest-first — the stable order paged browsing (month

package/test/api-routes-gaps.test.js

@@ -0,0 +1,218 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+
+// 覆盖 PR#73 删测后遗留的三个存活 API 空白（v0.7.16 回归补测）：
+//   /api/dsh-mneme/delete         面板删记忆（POST + auth + 存在性 404）
+//   /api/dsh-mneme/entities       实体目录（只读、limit 夹取）
+//   /api/dsh-mneme/external-api   独立服务配置（GET 发 token / PUT 校验）
+// 这三个路由在 src/api.js 里一直在跑，只是丢了测试。
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path, method = "GET", body = null) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = method;
+  r.headers = {};
+  if (body !== null) {
+    process.nextTick(() => {
+      r.emit("data", Buffer.from(JSON.stringify(body)));
+      r.emit("end");
+    });
+  }
+  return r;
+}
+
+function setup(apiToken = "") {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, commands, null, undefined, apiToken);
+  return { store, service, routes, settings };
+}
+
+function handler(routes, path) {
+  return routes.find((r) => r.path === path);
+}
+
+// ---------------------------------------------------------------------------
+// /api/dsh-mneme/delete
+// ---------------------------------------------------------------------------
+test("delete is auth-gated and rejects non-POST", async () => {
+  const { routes } = setup("secret-token");
+  const route = handler(routes, "/api/dsh-mneme/delete");
+
+  // 未带 token → 401
+  let res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/delete", "POST", { id: "x" }), res);
+  assert.equal(res.statusCode, 401);
+  assert.equal(JSON.parse(res.body).error, "unauthorized");
+
+  // 带 token 但 GET → 404
+  res = new FakeRes();
+  const ok = req("/api/dsh-mneme/delete", "GET");
+  ok.headers = { authorization: "Bearer secret-token" };
+  await route.handler(ok, res);
+  assert.equal(res.statusCode, 404);
+});
+
+test("delete validates id and reports missing/unknown 404", async () => {
+  const { routes, service } = setup("secret-token");
+  const route = handler(routes, "/api/dsh-mneme/delete");
+
+  // 空 id → 400
+  let res = new FakeRes();
+  let ok = req("/api/dsh-mneme/delete", "POST", { id: "  " });
+  ok.headers = { authorization: "Bearer secret-token" };
+  await route.handler(ok, res);
+  assert.equal(res.statusCode, 400);
+  assert.equal(JSON.parse(res.body).error, "missing-id");
+
+  // 不存在的 id → 404（store.remove 静默，靠前置 getById 区分）
+  res = new FakeRes();
+  ok = req("/api/dsh-mneme/delete", "POST", { id: "no-such-memory" });
+  ok.headers = { authorization: "Bearer secret-token" };
+  await route.handler(ok, res);
+  assert.equal(res.statusCode, 404);
+  assert.equal(JSON.parse(res.body).error, "not-found");
+
+  // 确认没被误删
+  assert.equal(service.count(), 0);
+});
+
+test("delete removes an existing memory", async () => {
+  const { routes, service } = setup("secret-token");
+  const route = handler(routes, "/api/dsh-mneme/delete");
+
+  const { memory } = service.saveWithDedupe({ type: "project", title: "要删的", content: "删掉我" });
+  assert.ok(service.getById(memory.id));
+
+  const res = new FakeRes();
+  const ok = req("/api/dsh-mneme/delete", "POST", { id: memory.id });
+  ok.headers = { authorization: "Bearer secret-token" };
+  await route.handler(ok, res);
+  assert.equal(res.statusCode, 200);
+  assert.deepEqual(JSON.parse(res.body), { ok: true });
+  assert.equal(service.getById(memory.id), undefined);
+  assert.equal(service.count(), 0);
+});
+
+// ---------------------------------------------------------------------------
+// /api/dsh-mneme/entities
+// ---------------------------------------------------------------------------
+test("entities directory is read-only and returns empty list", async () => {
+  const { routes } = setup();
+  const route = handler(routes, "/api/dsh-mneme/entities");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/entities"), res);
+  assert.equal(res.statusCode, 200);
+  assert.deepEqual(JSON.parse(res.body), { entities: [], total: 0 });
+});
+
+test("entities lists seeded entities without auth", async () => {
+  const { routes, service } = setup("secret-token"); // 有 token 但读路由不校验
+  service.createEntity({ name: "SQLite", type: "technology" });
+  service.createEntity({ name: "记忆", type: "concept" });
+
+  const route = handler(routes, "/api/dsh-mneme/entities");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/entities"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.total, 2);
+  const names = data.entities.map((e) => e.name).sort();
+  assert.deepEqual(names, ["SQLite", "记忆"]);
+  for (const e of data.entities) {
+    assert.ok(e.type, "each entity carries a type");
+    assert.ok(Number.isInteger(e.mention_count));
+  }
+});
+
+test("entities clamps limit to [1, 1000]", async () => {
+  const { routes, service } = setup();
+  for (let i = 0; i < 5; i++) service.createEntity({ name: `e${i}`, type: "concept" });
+  const route = handler(routes, "/api/dsh-mneme/entities");
+
+  // 夹取语义：NaN/0 先被 `|| 500` 兜底成 500（0 不再走 max(1,) 下限），
+  // 负数才被夹到 1，超限（>1000）夹到 1000。断言按真实实现收紧。
+  for (const [qs, want] of [["limit=abc", 5], ["limit=0", 5], ["limit=-10", 1], ["limit=5000", 5]]) {
+    const res = new FakeRes();
+    await route.handler(req(`/api/dsh-mneme/entities?${qs}`), res);
+    const data = JSON.parse(res.body);
+    assert.equal(data.entities.length, want, `${qs} → ${want} (got ${data.entities.length})`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// /api/dsh-mneme/external-api
+// ---------------------------------------------------------------------------
+test("external-api GET materializes and persists a token", async () => {
+  const { routes, settings } = setup();
+  const route = handler(routes, "/api/dsh-mneme/external-api");
+
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/external-api"), res);
+  assert.equal(res.statusCode, 200);
+  const cfg = JSON.parse(res.body).config;
+  assert.ok(typeof cfg.token === "string" && cfg.token.length >= 16, "token is generated");
+
+  // 持久化后二次 GET 返回同一 token
+  const res2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/external-api"), res2);
+  assert.equal(JSON.parse(res2.body).config.token, cfg.token);
+  assert.ok(settings.getExternalApi().token, "token persisted to settings kv");
+});
+
+test("external-api PUT requires auth and validates port/host", async () => {
+  const { routes } = setup("secret-token");
+  const route = handler(routes, "/api/dsh-mneme/external-api");
+
+  // 未带 token → 401
+  let res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/external-api", "PUT", { enabled: true }), res);
+  assert.equal(res.statusCode, 401);
+
+  // 端口越界 → 400
+  res = new FakeRes();
+  let ok = req("/api/dsh-mneme/external-api", "PUT", { port: 70000 });
+  ok.headers = { authorization: "Bearer secret-token" };
+  await route.handler(ok, res);
+  assert.equal(res.statusCode, 400);
+  assert.equal(JSON.parse(res.body).error, "invalid-port");
+
+  // host 带协议 → 400
+  res = new FakeRes();
+  ok = req("/api/dsh-mneme/external-api", "PUT", { host: "https://example.com" });
+  ok.headers = { authorization: "Bearer secret-token" };
+  await route.handler(ok, res);
+  assert.equal(res.statusCode, 400);
+  assert.equal(JSON.parse(res.body).error, "invalid-host");
+});
+
+test("external-api PUT applies valid config and echoes it", async () => {
+  const { routes } = setup("secret-token");
+  const route = handler(routes, "/api/dsh-mneme/external-api");
+
+  const res = new FakeRes();
+  const ok = req("/api/dsh-mneme/external-api", "PUT", { enabled: true, port: 8790, host: "127.0.0.1" });
+  ok.headers = { authorization: "Bearer secret-token" };
+  await route.handler(ok, res);
+  assert.equal(res.statusCode, 200);
+  const cfg = JSON.parse(res.body).config;
+  assert.equal(cfg.enabled, true);
+  assert.equal(cfg.port, 8790);
+  assert.equal(cfg.host, "127.0.0.1");
+  assert.ok(typeof cfg.token === "string");
+});

package/test/api.test.js

@@ -994,3 +994,58 @@ test("GET /api/dsh-mneme/list?archived=only lists just archived rows; default li
   await route.handler(req("/api/dsh-mneme/list"), back);
   assert.equal(JSON.parse(back.body).total, 2);
 });
+
+test("GET /api/dsh-mneme/list?deposited=only lists dream-touched memories (receipts ∪ source=dream)", async () => {
+  const { routes, service } = setup();
+  const plain = service.saveWithDedupe({ type: "preference", title: "无关", content: "plain" });
+  const merged = service.saveWithDedupe({ type: "project", title: "被巩固", content: "merged" });
+  const updated = service.saveWithDedupe({ type: "decision", title: "被更新", content: "updated" });
+  service.saveWithDedupe({ type: "summary", title: "总览", content: "overview", source: "dream" });
+  const ids = [plain, merged, updated].map((r) => r.memory.id);
+
+  // 巩固账本：merge 落在 keepSource、update 落在目标；conflict 只仲裁不落
+  // 内容，不算沉淀。verdict='live' 才有效。
+  service.saveReceipt({
+    receipt_id: "r-merge", run_id: "run-1", record_id: merged.memory.id, kind: "merge",
+    input_digest: "d1", keep_source: merged.memory.id, sources: [merged.memory.id, ids[0]],
+    verdict: "live", count_before: 2, count_after: 1, policy_epoch: 0,
+    created_at: new Date().toISOString()
+  });
+  service.saveReceipt({
+    receipt_id: "r-update", run_id: "run-1", record_id: updated.memory.id, kind: "update",
+    input_digest: "d2", verdict: "live", count_before: 1, count_after: 1,
+    policy_epoch: 0, created_at: new Date().toISOString()
+  });
+  service.saveReceipt({
+    receipt_id: "r-conflict", run_id: "run-1", record_id: "winner-x", kind: "conflict",
+    input_digest: "d3", winner_id: "winner-x", loser_id: "loser-y", verdict: "live",
+    count_before: 2, count_after: 2, policy_epoch: 0, created_at: new Date().toISOString()
+  });
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list?deposited=only"), res);
+  const data = JSON.parse(res.body);
+  assert.deepEqual(
+    data.items.map((m) => m.title).sort(),
+    ["总览", "被巩固", "被更新"],
+    "deposited view = receipt merge/update records ∪ source=dream writes"
+  );
+  assert.equal(data.total, 3, "total honors the deposited filter");
+
+  // 默认列表不受 deposited 过滤影响
+  const def = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list"), def);
+  assert.equal(JSON.parse(def.body).total, 4);
+
+  // 与 archived=only 可叠加：归档的沉淀记忆才出现在交集视图里
+  const upd = routes.find((r) => r.path === "/api/dsh-mneme/update");
+  const arch = new FakeRes();
+  await upd.handler(req("/api/dsh-mneme/update", "POST", { id: merged.memory.id, archived: true }), arch);
+  assert.equal(arch.statusCode, 200);
+  const both = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list?deposited=only&archived=only"), both);
+  const bothData = JSON.parse(both.body);
+  assert.deepEqual(bothData.items.map((m) => m.title), ["被巩固"]);
+  assert.equal(bothData.total, 1);
+});

package/test/client.test.js

@@ -160,6 +160,104 @@ test("sidebar entry portals above the workspaces region with footer fallback", (
   );
 });
 
+// Three alignment/softness guarantees born from field feedback: (a) the
+// portalled entry keeps tracking the live New-Session class (host and skin
+// rewrite it asynchronously, so a mount-time snapshot goes stale), (b) it
+// fills the same width as that button and inherits its native centering,
+// (c) the toolbar dropdown escapes the transform stacking trap — the
+// container needs the z-index because transform creates the context.
+test("entry tracks native class, fills native width, and lifts the toolbar dropdown", () => {
+  assert.ok(
+    clientSource.includes("new MutationObserver"),
+    "the entry must re-sync the copied class via MutationObserver"
+  );
+  assert.ok(
+    clientSource.includes('attributeFilter: ["class"]'),
+    "the observer must watch class attribute changes"
+  );
+  assert.ok(
+    /\.mneme-topentry-native\{width:100%;/.test(clientSource),
+    "the entry button must fill the same width as the New-Session row"
+  );
+  assert.equal(
+    clientSource.includes(".mneme-topentry-native .mneme-topentry-label{flex:1;min-width:0;text-align:left;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}"),
+    false,
+    "the old left-aligned label override must go; native centering applies"
+  );
+  assert.ok(
+    /\.mneme-xtools\{[^}]*z-index:3\}/.test(clientSource),
+    "the toolbar container must carry z-index:3 (sticky month header is 2, drawer 6)"
+  );
+});
+
+// Importance renders as Lucide star glyphs (the morphicons-paired data set;
+// the runtime cannot require the ESM-only morphicons engine, so the path
+// ships inline like the other stroke icons), not raw ★ text. Only the
+// drawer's edit-mode <option> labels keep the text form — SVG cannot render
+// inside <option>.
+test("importance renders as star glyphs, not raw text stars", () => {
+  assert.ok(
+    clientSource.includes("STAR_PATH_D"),
+    "the Lucide star path data must be inlined"
+  );
+  assert.ok(
+    clientSource.includes("const ImportanceStars"),
+    "the star-row component must exist"
+  );
+  assert.equal(
+    (clientSource.match(/"★"\.repeat/g) || []).length,
+    1,
+    "only the drawer edit <option> labels may keep the ★ text form"
+  );
+  assert.ok(
+    /h\(ImportanceStars, \{ className: "mneme-dmetaval"/.test(clientSource),
+    "the drawer detail must render the star row"
+  );
+  assert.ok(
+    /h\(ImportanceStars, \{ value: m\.importance/.test(clientSource),
+    "the card foot must render the star row"
+  );
+});
+
+// better-sidebar ecosystem integration is an optional capability (official
+// external-plugin-guide §2.2): 'betterSidebar' IS declared in inject (DSH's
+// runtime gates ctx property access on the inject declaration — probing
+// without declaring fails the whole loader entry, verified in the field) and
+// marked as an optional peer dependency, so when it is absent the service
+// resolves to undefined and registration skips gracefully. Registration
+// probes at runtime inside a named ctx.effect (scope cleanup on HMR/disable)
+// with a bounded retry for service-provision ordering.
+test("better-sidebar tab declares optional inject, probes, and skips gracefully", () => {
+  assert.ok(
+    /const inject = \["slots", "locale", "betterSidebar"\];/.test(clientSource),
+    "module inject must declare betterSidebar — DSH gates ctx property access on it"
+  );
+  assert.ok(
+    /const bs = ctx\.betterSidebar;[\s\S]{0,60}typeof bs\.registerTab === "function"/.test(clientSource),
+    "the tab registration must still probe ctx.betterSidebar at runtime (undefined when absent)"
+  );
+  assert.ok(
+    /id: "dsh-mneme:memory"/.test(clientSource),
+    "the registered tab id must be package-prefixed"
+  );
+  assert.ok(
+    /title: \(\) => t\("memory\.view\.label"\)/.test(clientSource),
+    "the tab title must reuse the localized 记忆库 label"
+  );
+  assert.ok(
+    /component: \(\) => h\(MemoryExplorer, \{ t \}\)/.test(clientSource),
+    "the tab must reuse the MemoryExplorer views"
+  );
+  assert.ok(
+    clientSource.includes('"dsh-mneme: better-sidebar tab"'),
+    "the registration effect must carry a named label for scope cleanup"
+  );
+  assert.ok(
+    /if \(\+\+tries <= 10\) timer = setTimeout\(attempt, 1000\);/.test(clientSource),
+    "the service probe must retry with a bound (10 × 1s), not loop forever"
+  );
+});
+
 // The graph toggle must not read as "share": the primitives share icon is
 // banned and a custom node-graph glyph takes its place.
 test("graph toggle uses a node-graph glyph, not the share icon", () => {
@@ -174,6 +272,44 @@ test("graph toggle uses a node-graph glyph, not the share icon", () => {
   );
 });
 
+// 方案 A：查询收敛。状态页只做仪表盘（小页预览 + 服务端 total + 查看全部），
+// 沉淀/归档的完整浏览走记忆库的 deposited/archived 筛选视图（chip 预置 +
+// 状态页入口跳转），详情抽屉给归档记忆一个反向的「恢复」。
+test("status dashboard links into deposited/archived library views", () => {
+  assert.ok(
+    clientSource.includes('"/api/dsh-mneme/list?deposited=only&limit=8&order=chrono"'),
+    "the workbench deposited preview must read the server-side deposited view"
+  );
+  assert.ok(
+    clientSource.includes('"/api/dsh-mneme/list?archived=only&limit=3&order=chrono"'),
+    "the workbench archived preview must cap at 3 rows backed by a server total"
+  );
+  assert.ok(
+    clientSource.includes("browseWithFilter"),
+    "the status page must jump into the library with preset filters"
+  );
+  assert.ok(
+    /view === "status" && h\(StatusPanel, \{ t, onBrowse: browseWithFilter \}\)/.test(clientSource),
+    "the status panel must receive the browse-jump callback"
+  );
+  assert.ok(
+    clientSource.includes('(depositedOnly ? "&deposited=only" : "")'),
+    "the library filterQS must carry the deposited chip"
+  );
+  assert.ok(
+    clientSource.includes('(archivedOnly ? "&archived=only" : "")'),
+    "the library filterQS must carry the archived chip"
+  );
+  assert.ok(
+    clientSource.includes('postUpdate({ archived: false }, { restored: true })'),
+    "the drawer must offer restore for archived memories"
+  );
+  assert.ok(
+    clientSource.includes('"memory.status.viewAll"'),
+    "the view-all entries must come from the dictionary"
+  );
+});
+
 // Every memory feature lives in the main-area library now: the explorer
 // hosts three sub-views (browse / entities / settings) switched by tabs whose
 // labels come from dedicated dictionary keys.

package/test/lib-smoke.test.js

@@ -0,0 +1,96 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// lib/ 运行冒烟（v0.7.16 回归补测，重建被 PR#73 删除的 lib-smoke.test.js）。
+// npm 包实际加载的是 lib/（package main → lib/index.js），历史教训 v0.7.8
+// 只改 src 忘了同步 lib 发出去旧产物（issue #65）。这里补两层守护：
+//   1) 静态：src/ 与 lib/ 逐文件字节一致（check-sync.js 的测试版，CI 常驻）；
+//   2) 运行时：直接从 lib/ 导入核心模块跑关键链路，证明打包产物可独立加载。
+
+const root = fileURLToPath(new URL("..", import.meta.url)); // dsh-mneme/
+const srcDir = join(root, "src");
+const libDir = join(root, "lib");
+
+function walk(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walk(full));
+    else if (entry.isFile()) out.push(full);
+  }
+  return out;
+}
+
+test("src/ and lib/ are byte-identical (no publish drift)", () => {
+  const srcFiles = walk(srcDir);
+  assert.ok(srcFiles.length > 0, "src tree is not empty");
+  const drift = [];
+  for (const file of srcFiles) {
+    const rel = relative(srcDir, file);
+    const dest = join(libDir, rel);
+    if (!readFileSync(dest, "utf8")) {
+      drift.push(`missing lib/${rel}`);
+    } else if (!readFileSync(file).equals(readFileSync(dest))) {
+      drift.push(`differ lib/${rel}`);
+    }
+  }
+  assert.deepEqual(drift, [], "src↔lib must stay in sync (npm run sync)");
+});
+
+// ---------------------------------------------------------------------------
+// lib 运行时冒烟：直接加载 npm 实际分发的产物
+// ---------------------------------------------------------------------------
+test("lib store+service runs a save/get/count cycle", async () => {
+  const { createStore } = await import("../lib/store.js");
+  const { createService } = await import("../lib/service.js");
+
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const { memory } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  assert.ok(memory.id);
+  assert.ok(service.getById(memory.id));
+  assert.equal(service.count(), 1);
+});
+
+test("lib summarize parses extraction JSON robustly", async () => {
+  const { parseSummaryJson } = await import("../lib/summarize.js");
+
+  // 前后夹带杂质的原始输出 → 只取数组
+  const parsed = parseSummaryJson("```json\n[{\"type\":\"preference\",\"title\":\"x\",\"content\":\"y\",\"importance\":9}]\n```");
+  assert.equal(parsed.length, 1);
+  assert.equal(parsed[0].importance, 5, "importance clamped to [1,5]");
+
+  // 非法 JSON / 非数组 → 空数组，不抛
+  assert.deepEqual(parseSummaryJson("no array here"), []);
+  assert.deepEqual(parseSummaryJson('{"type":"preference"}'), []);
+  assert.deepEqual(parseSummaryJson(""), []);
+});
+
+test("lib summarize constructs with autoSummarize disabled", async () => {
+  const { createSummarizer } = await import("../lib/summarize.js");
+  const summarizer = createSummarizer({}, {}, { autoSummarize: false });
+  assert.equal(typeof summarizer.dispose, "function");
+  summarizer.dispose();
+});
+
+test("lib inject constructs and renders an empty block", async () => {
+  const { createInjector } = await import("../lib/inject.js");
+  const registered = [];
+  const ctx = {
+    systemPrompt: {
+      context: (def) => { registered.push(def); return () => {}; }
+    }
+  };
+  const service = { injectCandidates: () => [], injectSettings: () => [] };
+  const dispose = createInjector(ctx, service, {}, {});
+  assert.equal(typeof dispose, "function");
+  assert.equal(registered.length, 2, "memory + user-settings contexts registered");
+
+  const memoryBlock = registered.find((d) => d.name === "memory");
+  assert.equal(typeof memoryBlock.text, "function");
+  assert.equal(memoryBlock.text({}), ""); // 无候选 → 空块
+  dispose();
+});