@modusensus/dsh-mneme 0.8.14 → 0.8.15

package/test/lang.test.js

@@ -1,87 +1,87 @@
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { STR, langOf } from "../src/lang.js";
-import { createMirror, parseHumanEdits, renderMirrorText } from "../src/mirror.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createInjector } from "../src/inject.js";
-import { createSettings } from "../src/settings.js";
-
-test("langOf resolves the per-instance config language", () => {
-  assert.equal(langOf({}), "zh");
-  assert.equal(langOf({ language: "zh" }), "zh");
-  assert.equal(langOf({ language: "en" }), "en");
-  assert.equal(langOf({ language: "fr" }), "zh");
-  assert.equal(langOf(null), "zh");
-});
-
-test("prompt table resolves by explicit language key", () => {
-  assert.ok(STR.prompts.summary.zh.includes("记忆库提炼助手"));
-  assert.ok(STR.prompts.summary.en.includes("memory curation assistant"));
-  assert.ok(STR.prompts.consolidation.zh.includes("记忆库整理助手"));
-  assert.ok(STR.prompts.consolidation.en.includes("consolidation assistant"));
-  assert.ok(STR.prompts.conflict.zh.includes("冲突仲裁"));
-  assert.ok(STR.prompts.conflict.en.includes("conflict arbiter"));
-  assert.ok(STR.prompts.pattern.zh.includes("模式发现助手"));
-  assert.ok(STR.prompts.pattern.en.includes("pattern-discovery assistant"));
-  // 冻结模式后缀：纯提示文本，可直接拼接在巩固 prompt 后。
-  assert.ok(STR.prompts.freezeSuffix.zh.startsWith("\n\n当前为「冲突冻结」模式"));
-  assert.ok(STR.prompts.freezeSuffix.en.startsWith("\n\nConflict-freeze mode is active"));
-  // 无 JS 语法残留：不携带 const 声明、模板字面量包裹或拼接片段。
-  for (const [key, pair] of Object.entries(STR.prompts)) {
-    for (const [lang, text] of Object.entries(pair)) {
-      assert.ok(!text.startsWith("const ") && !text.startsWith("? ")
-        && !text.endsWith("`;") && !text.endsWith("`"),
-        `${key}.${lang} must not carry JS syntax`);
-    }
-  }
-});
-
-test("two injectors with different language configs render independently", () => {
-  function setup(language) {
-    const store = createStore(":memory:");
-    const service = createService({ store, mirror: null, config: {} });
-    const settings = createSettings(store.db);
-    const contexts = [];
-    const ctx = { systemPrompt: { context(def) { contexts.push(def); } } };
-    createInjector(ctx, service, settings, { maxInjectedItems: 3, importanceThreshold: 3, language });
-    service.saveWithDedupe({ type: "preference", title: "lang", content: "value", importance: 5 });
-    return { store, contexts };
-  }
-  const en = setup("en");
-  const zh = setup("zh");
-  try {
-    assert.ok(en.contexts[0].text({}).includes("[Memory]"), "en instance renders English header");
-    assert.ok(zh.contexts[0].text({}).includes("[记忆库]"), "zh instance renders Chinese header");
-  } finally {
-    en.store.close();
-    zh.store.close();
-  }
-});
-
-test("mirror render follows the instance language; parser accepts both", () => {
-  const memory = { id: "m1", type: "preference", title: "t", content: "c", importance: 5, tags: [], updated_at: "2026-01-01" };
-  const enText = renderMirrorText("preference", [memory], "en");
-  const zhText = renderMirrorText("preference", [memory], "zh");
-  assert.ok(enText.includes("- **Type**: preference"));
-  assert.ok(zhText.includes("- **类型**: preference"));
-  const edits = parseHumanEdits(enText + "\n" + zhText);
-  assert.deepEqual(
-    edits.map((e) => e.id),
-    ["m1", "m1"]
-  );
-  assert.equal(edits[1].content, "c");
-});
-
-test("dream summary keeps one row across a language switch (stable source identity)", () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  service.saveWithDedupe({ type: "summary", title: "记忆库总览", content: "zh overview", importance: 5, source: "dream", _overwrite: true });
-  service.saveWithDedupe({ type: "summary", title: "Memory library overview", content: "en overview", importance: 5, source: "dream", _overwrite: true });
-  const summaries = store.all().filter((m) => m.type === "summary" && !m.archived);
-  assert.equal(summaries.length, 1);
-  assert.equal(summaries[0].title, "Memory library overview");
-  assert.equal(summaries[0].content, "en overview");
-  store.close();
-});
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { STR, langOf } from "../src/lang.js";
+import { createMirror, parseHumanEdits, renderMirrorText } from "../src/mirror.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+test("langOf resolves the per-instance config language", () => {
+  assert.equal(langOf({}), "zh");
+  assert.equal(langOf({ language: "zh" }), "zh");
+  assert.equal(langOf({ language: "en" }), "en");
+  assert.equal(langOf({ language: "fr" }), "zh");
+  assert.equal(langOf(null), "zh");
+});
+
+test("prompt table resolves by explicit language key", () => {
+  assert.ok(STR.prompts.summary.zh.includes("记忆库提炼助手"));
+  assert.ok(STR.prompts.summary.en.includes("memory curation assistant"));
+  assert.ok(STR.prompts.consolidation.zh.includes("记忆库整理助手"));
+  assert.ok(STR.prompts.consolidation.en.includes("consolidation assistant"));
+  assert.ok(STR.prompts.conflict.zh.includes("冲突仲裁"));
+  assert.ok(STR.prompts.conflict.en.includes("conflict arbiter"));
+  assert.ok(STR.prompts.pattern.zh.includes("模式发现助手"));
+  assert.ok(STR.prompts.pattern.en.includes("pattern-discovery assistant"));
+  // 冻结模式后缀：纯提示文本，可直接拼接在巩固 prompt 后。
+  assert.ok(STR.prompts.freezeSuffix.zh.startsWith("\n\n当前为「冲突冻结」模式"));
+  assert.ok(STR.prompts.freezeSuffix.en.startsWith("\n\nConflict-freeze mode is active"));
+  // 无 JS 语法残留：不携带 const 声明、模板字面量包裹或拼接片段。
+  for (const [key, pair] of Object.entries(STR.prompts)) {
+    for (const [lang, text] of Object.entries(pair)) {
+      assert.ok(!text.startsWith("const ") && !text.startsWith("? ")
+        && !text.endsWith("`;") && !text.endsWith("`"),
+        `${key}.${lang} must not carry JS syntax`);
+    }
+  }
+});
+
+test("two injectors with different language configs render independently", () => {
+  function setup(language) {
+    const store = createStore(":memory:");
+    const service = createService({ store, mirror: null, config: {} });
+    const settings = createSettings(store.db);
+    const contexts = [];
+    const ctx = { systemPrompt: { context(def) { contexts.push(def); } } };
+    createInjector(ctx, service, settings, { maxInjectedItems: 3, importanceThreshold: 3, language });
+    service.saveWithDedupe({ type: "preference", title: "lang", content: "value", importance: 5 });
+    return { store, contexts };
+  }
+  const en = setup("en");
+  const zh = setup("zh");
+  try {
+    assert.ok(en.contexts[0].text({}).includes("[Memory]"), "en instance renders English header");
+    assert.ok(zh.contexts[0].text({}).includes("[记忆库]"), "zh instance renders Chinese header");
+  } finally {
+    en.store.close();
+    zh.store.close();
+  }
+});
+
+test("mirror render follows the instance language; parser accepts both", () => {
+  const memory = { id: "m1", type: "preference", title: "t", content: "c", importance: 5, tags: [], updated_at: "2026-01-01" };
+  const enText = renderMirrorText("preference", [memory], "en");
+  const zhText = renderMirrorText("preference", [memory], "zh");
+  assert.ok(enText.includes("- **Type**: preference"));
+  assert.ok(zhText.includes("- **类型**: preference"));
+  const edits = parseHumanEdits(enText + "\n" + zhText);
+  assert.deepEqual(
+    edits.map((e) => e.id),
+    ["m1", "m1"]
+  );
+  assert.equal(edits[1].content, "c");
+});
+
+test("dream summary keeps one row across a language switch (stable source identity)", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  service.saveWithDedupe({ type: "summary", title: "记忆库总览", content: "zh overview", importance: 5, source: "dream", _overwrite: true });
+  service.saveWithDedupe({ type: "summary", title: "Memory library overview", content: "en overview", importance: 5, source: "dream", _overwrite: true });
+  const summaries = store.all().filter((m) => m.type === "summary" && !m.archived);
+  assert.equal(summaries.length, 1);
+  assert.equal(summaries[0].title, "Memory library overview");
+  assert.equal(summaries[0].content, "en overview");
+  store.close();
+});

package/test/lastrunat-persist.test.js

@@ -1,101 +1,101 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createDreamScheduler } from "../src/dream.js";
-import { createSleepScheduler } from "../src/dream/sleep.js";
-
-// 回归（issue #89）：调度器的 lastRunAt 只活在内存里，进程重启即归零——
-// 最小间隔/冷却闸对新实例放行，重启后 autoDream/sleep 立即连发（Sample A/C 的
-// 根因）。修复 = 构造调度器时从 dream_runs 审计表恢复种子（store.lastDreamRunAt，
-// failed/degraded 也算 run，审计表本来就是逐 run 落库）。本文件锁三点：
-//   1. lastDreamRunAt 读回最近一次 run 的开跑时刻（含 run_type 过滤）；
-//   2. dream 调度器带种子构造后，重启场景下最小间隔闸门立即生效；
-//   3. sleep 调度器带种子构造后，冷却期内不起跑、且按剩余窗口重排不丢触发权。
-
-test("issue#89: store.lastDreamRunAt recovers the last run timestamp (with run_type filter)", () => {
-  const store = createStore(":memory:");
-  assert.equal(store.lastDreamRunAt(), 0, "empty trail → 0 (never ran)");
-  assert.equal(store.lastDreamRunAt("sleep"), 0);
-  store.saveDreamRun({ status: "ok", snapshot_hash: "h1", input_count: 1, receipt: "r", created_at: "2026-09-10T01:05:23.640Z", run_type: "auto" });
-  store.saveDreamRun({ status: "ok", snapshot_hash: "h2", input_count: 1, receipt: "r", created_at: "2026-09-09T20:00:00.000Z", run_type: "sleep" });
-  assert.equal(store.lastDreamRunAt(), Date.parse("2026-09-10T01:05:23.640Z"), "latest run regardless of type");
-  assert.equal(store.lastDreamRunAt("sleep"), Date.parse("2026-09-09T20:00:00.000Z"), "filtered by run_type");
-  assert.equal(store.lastDreamRunAt("auto"), Date.parse("2026-09-10T01:05:23.640Z"), "auto filter ignores sleep rows");
-  store.close();
-});
-
-test("issue#89: dream scheduler seeded from the audit trail — restart no longer bypasses the min interval", async () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  // 模拟上一进程刚跑过一轮（10ms 前开跑）并留下审计行，然后「重启」：
-  // minIntervalMs 取 1min——断言窗口远宽于用例执行时间，真实时钟抖动（调度、
-  // 慢盘）不会把 10ms 偏移推出闸门外造成间歇性假失败。
-  store.saveDreamRun({
-    status: "ok", snapshot_hash: "h", input_count: 1, receipt: "r",
-    created_at: new Date(Date.now() - 10).toISOString(), run_type: "auto"
-  });
-  const dream = createDreamScheduler({
-    onRun: async () => ({ ok: false, error: "llm failed" }),
-    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 60000,
-    lastRunAtSeed: store.lastDreamRunAt("auto"),
-    logger: { warn: () => {} }
-  });
-  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
-  // 无种子时这里会返回 true（旧缺陷：重启后立刻连发）；带种子必须被闸门拦下。
-  assert.equal(dream.maybeSchedule(service), false, "seeded gate blocks immediately after 'restart'");
-  store.close();
-});
-
-test("issue#89: sleep scheduler seeded — cooldown survives a restart", async () => {
-  let nowMs = 1_000_000;
-  const timers = [];
-  let seq = 1;
-  let runs = 0;
-  const lastRunAt = nowMs - 10 * 60_000; // 上一进程 10 分钟前跑过，CD 1h 还剩 50min
-  const sched = createSleepScheduler({
-    service: { enqueue: (fn) => fn() },
-    config: { sleepModeEnabled: true, sleepIdleMinutes: 5, sleepMinIntervalHours: 1 },
-    logger: { warn: () => {} },
-    onRun: async () => { runs++; return { ok: true }; },
-    now: () => nowMs,
-    lastRunAtSeed: lastRunAt,
-    setTimeoutFn: (fn, delay) => { const t = { id: seq++, at: nowMs + delay, fn }; timers.push(t); return t.id; },
-    clearTimeoutFn: (id) => { const i = timers.findIndex((t) => t.id === id); if (i >= 0) timers.splice(i, 1); }
-  });
-  nowMs += 1000;
-  sched.noteWrite(); // 挂 idle 闹钟
-  const idleTimer = timers[0];
-  assert.ok(idleTimer, "idle timer armed on write");
-  nowMs = idleTimer.at;
-  timers.length = 0;
-  await idleTimer.fn();
-  assert.equal(runs, 0, "restored cooldown blocks the run");
-  const rearm = timers[0];
-  assert.ok(rearm, "re-armed for the remaining cooldown window (not dropped, #187 semantics)");
-  assert.equal(rearm.at, lastRunAt + 3_600_000 + 1000, "re-arms at CD expiry (+1s guard)");
-});
-
-// --- CodeRabbit #291 findings 5/6：index.js 的 seed 注入是单行无分支接线，仓库
-// 没有插件级挂载 harness（apply 需要完整宿主 ctx），起全量挂载只为准两条断言
-// 不成比例——改为源码级锁：删掉 index.js 的对应注入行即红。import 用绝对路径，
-// 不依赖测试进程 CWD。
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-const indexSrc = readFileSync(fileURLToPath(new URL("../src/index.js", import.meta.url)), "utf8");
-
-test("issue#89: index.js wires the dream scheduler seed from the audit trail", () => {
-  assert.match(
-    indexSrc,
-    /lastRunAtSeed:\s*store\.lastDreamRunAt\("auto"\)/,
-    "dream scheduler must seed its min-interval gate from dream_runs (run_type='auto') — remove this line and restart-bypass returns"
-  );
-});
-
-test("issue#89: index.js wires the sleep scheduler seed from the audit trail", () => {
-  assert.match(
-    indexSrc,
-    /lastRunAtSeed:\s*store\.lastDreamRunAt\("sleep"\)/,
-    "sleep scheduler must seed its cooldown gate from dream_runs (run_type='sleep') — remove this line and restart-bypass returns"
-  );
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+import { createSleepScheduler } from "../src/dream/sleep.js";
+
+// 回归（issue #89）：调度器的 lastRunAt 只活在内存里，进程重启即归零——
+// 最小间隔/冷却闸对新实例放行，重启后 autoDream/sleep 立即连发（Sample A/C 的
+// 根因）。修复 = 构造调度器时从 dream_runs 审计表恢复种子（store.lastDreamRunAt，
+// failed/degraded 也算 run，审计表本来就是逐 run 落库）。本文件锁三点：
+//   1. lastDreamRunAt 读回最近一次 run 的开跑时刻（含 run_type 过滤）；
+//   2. dream 调度器带种子构造后，重启场景下最小间隔闸门立即生效；
+//   3. sleep 调度器带种子构造后，冷却期内不起跑、且按剩余窗口重排不丢触发权。
+
+test("issue#89: store.lastDreamRunAt recovers the last run timestamp (with run_type filter)", () => {
+  const store = createStore(":memory:");
+  assert.equal(store.lastDreamRunAt(), 0, "empty trail → 0 (never ran)");
+  assert.equal(store.lastDreamRunAt("sleep"), 0);
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h1", input_count: 1, receipt: "r", created_at: "2026-09-10T01:05:23.640Z", run_type: "auto" });
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h2", input_count: 1, receipt: "r", created_at: "2026-09-09T20:00:00.000Z", run_type: "sleep" });
+  assert.equal(store.lastDreamRunAt(), Date.parse("2026-09-10T01:05:23.640Z"), "latest run regardless of type");
+  assert.equal(store.lastDreamRunAt("sleep"), Date.parse("2026-09-09T20:00:00.000Z"), "filtered by run_type");
+  assert.equal(store.lastDreamRunAt("auto"), Date.parse("2026-09-10T01:05:23.640Z"), "auto filter ignores sleep rows");
+  store.close();
+});
+
+test("issue#89: dream scheduler seeded from the audit trail — restart no longer bypasses the min interval", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  // 模拟上一进程刚跑过一轮（10ms 前开跑）并留下审计行，然后「重启」：
+  // minIntervalMs 取 1min——断言窗口远宽于用例执行时间，真实时钟抖动（调度、
+  // 慢盘）不会把 10ms 偏移推出闸门外造成间歇性假失败。
+  store.saveDreamRun({
+    status: "ok", snapshot_hash: "h", input_count: 1, receipt: "r",
+    created_at: new Date(Date.now() - 10).toISOString(), run_type: "auto"
+  });
+  const dream = createDreamScheduler({
+    onRun: async () => ({ ok: false, error: "llm failed" }),
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 60000,
+    lastRunAtSeed: store.lastDreamRunAt("auto"),
+    logger: { warn: () => {} }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  // 无种子时这里会返回 true（旧缺陷：重启后立刻连发）；带种子必须被闸门拦下。
+  assert.equal(dream.maybeSchedule(service), false, "seeded gate blocks immediately after 'restart'");
+  store.close();
+});
+
+test("issue#89: sleep scheduler seeded — cooldown survives a restart", async () => {
+  let nowMs = 1_000_000;
+  const timers = [];
+  let seq = 1;
+  let runs = 0;
+  const lastRunAt = nowMs - 10 * 60_000; // 上一进程 10 分钟前跑过，CD 1h 还剩 50min
+  const sched = createSleepScheduler({
+    service: { enqueue: (fn) => fn() },
+    config: { sleepModeEnabled: true, sleepIdleMinutes: 5, sleepMinIntervalHours: 1 },
+    logger: { warn: () => {} },
+    onRun: async () => { runs++; return { ok: true }; },
+    now: () => nowMs,
+    lastRunAtSeed: lastRunAt,
+    setTimeoutFn: (fn, delay) => { const t = { id: seq++, at: nowMs + delay, fn }; timers.push(t); return t.id; },
+    clearTimeoutFn: (id) => { const i = timers.findIndex((t) => t.id === id); if (i >= 0) timers.splice(i, 1); }
+  });
+  nowMs += 1000;
+  sched.noteWrite(); // 挂 idle 闹钟
+  const idleTimer = timers[0];
+  assert.ok(idleTimer, "idle timer armed on write");
+  nowMs = idleTimer.at;
+  timers.length = 0;
+  await idleTimer.fn();
+  assert.equal(runs, 0, "restored cooldown blocks the run");
+  const rearm = timers[0];
+  assert.ok(rearm, "re-armed for the remaining cooldown window (not dropped, #187 semantics)");
+  assert.equal(rearm.at, lastRunAt + 3_600_000 + 1000, "re-arms at CD expiry (+1s guard)");
+});
+
+// --- CodeRabbit #291 findings 5/6：index.js 的 seed 注入是单行无分支接线，仓库
+// 没有插件级挂载 harness（apply 需要完整宿主 ctx），起全量挂载只为准两条断言
+// 不成比例——改为源码级锁：删掉 index.js 的对应注入行即红。import 用绝对路径，
+// 不依赖测试进程 CWD。
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+const indexSrc = readFileSync(fileURLToPath(new URL("../src/index.js", import.meta.url)), "utf8");
+
+test("issue#89: index.js wires the dream scheduler seed from the audit trail", () => {
+  assert.match(
+    indexSrc,
+    /lastRunAtSeed:\s*store\.lastDreamRunAt\("auto"\)/,
+    "dream scheduler must seed its min-interval gate from dream_runs (run_type='auto') — remove this line and restart-bypass returns"
+  );
+});
+
+test("issue#89: index.js wires the sleep scheduler seed from the audit trail", () => {
+  assert.match(
+    indexSrc,
+    /lastRunAtSeed:\s*store\.lastDreamRunAt\("sleep"\)/,
+    "sleep scheduler must seed its cooldown gate from dream_runs (run_type='sleep') — remove this line and restart-bypass returns"
+  );
+});

package/test/lib-smoke.test.js

@@ -1,96 +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();
-});
+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();
+});