@modusensus/dsh-mneme 0.8.14 → 0.8.15

package/test/stress.test.js

@@ -1,209 +1,209 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createDreamScheduler, parseReceipt } from "../src/dream.js";
-import { applyDecisions } from "../src/dream/decisions.js";
-import {
-  sessionDecisions,
-  arbitrationDecisions,
-  mockCtx
-} from "./helpers/dream-mock.js";
-
-function setup() {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
-  return { store, service, dream };
-}
-
-function tmpPath(prefix) {
-  return join(mkdtempSync(join(tmpdir(), prefix)), "memory.db");
-}
-
-// ---------------------------------------------------------------- 轴线 1
-
-test("long-session stress: Recall@k stays high, stale residual drops to zero", async () => {
-  const { store, service, dream } = setup();
-  const ctx = mockCtx({ onConsolidation: sessionDecisions });
-  const topics = 5;
-  const rounds = 3;
-
-  const gt = [];
-  for (let t = 1; t <= topics; t++) {
-    const title = `主题${String(t).padStart(2, "0")}`;
-    const { memory } = service.saveWithDedupe({ type: "project", title, content: `${title} 规范内容`, importance: 5 });
-    gt.push({ title, id: memory.id });
-  }
-  for (let r = 1; r <= rounds; r++) {
-    for (let t = 1; t <= topics; t++) {
-      service.saveWithDedupe({
-        type: "project",
-        title: `主题${String(t).padStart(2, "0")}·变体${r}`,
-        content: "旧变体",
-        importance: 3
-      });
-    }
-    const result = await dream.runDream(ctx, service, {});
-    assert.equal(result.ok, true);
-  }
-
-  let hits = 0;
-  for (const { title, id } of gt) {
-    if (service.search(title, { limit: 5 }).some((m) => m.id === id)) hits++;
-  }
-  assert.equal(hits, topics, "every canonical memory recalled in top-5 after 3 consolidation rounds");
-
-  const all = store.all();
-  const variants = all.filter((m) => m.type === "project" && m.title.includes("变体"));
-  assert.equal(variants.filter((m) => !m.archived).length, 0, "no stale variants remain active");
-  assert.equal(store.listDreamRuns().length, rounds, "every run written to the audit trail");
-  store.close();
-});
-
-// ---------------------------------------------------------------- 轴线 2
-
-test("arbitration set is replayable: deterministic, correct, idempotent replay", async () => {
-  const { store, service, dream } = setup();
-  const ctx = mockCtx({ onConsolidation: arbitrationDecisions });
-  const sets = [
-    { w: { type: "decision", title: "截止", content: "8月20日", importance: 5 }, l: { type: "decision", title: "截止(旧)", content: "8月15日", importance: 3 } },
-    { w: { type: "preference", title: "语言", content: "简体中文", importance: 5 }, l: { type: "preference", title: "语言(旧)", content: "繁体中文", importance: 2 } }
-  ];
-  for (const s of sets) {
-    service.saveWithDedupe({ ...s.l });
-    service.saveWithDedupe({ ...s.w });
-  }
-
-  const run = await dream.runDream(ctx, service, {});
-  assert.equal(run.ok, true);
-  assert.equal(run.applied, sets.length, "one conflict per arbitration set");
-
-  // correctness: winner kept (with provenance), loser archived
-  for (const s of sets) {
-    const winner = service.list({ type: s.w.type }).find((m) => m.title === s.w.title);
-    const loser = store.all().find((m) => m.title === s.l.title);
-    assert.ok(winner, "winner present");
-    assert.ok(loser?.archived, "loser archived");
-    assert.ok(winner.content.includes("已否决旧信息"), "provenance note appended");
-  }
-
-  // audit + receipt are replayable
-  const audit = store.getDreamRun(run.runId);
-  assert.equal(audit.status, "ok");
-  const receipt = parseReceipt(audit.receipt);
-  assert.equal(receipt.status, "ok");
-  assert.equal(Object.keys(audit.outcome.byId).length, sets.length * 2, "outcome covers every arbitrated id");
-  assert.equal(audit.decisions.length, sets.length, "raw decisions persisted");
-
-  // re-applying the recorded decision list is a no-op (idempotent replay)
-  assert.equal(applyDecisions(audit.decisions, service).applied, 0, "replay applies nothing");
-  store.close();
-});
-
-// ---------------------------------------------------------------- 轴线 3
-
-function bump(content) {
-  return `count=${Number(content.match(/count=(\d+)/)[1]) + 1}`;
-}
-
-test("concurrent agents: no duplicate merge, lost-update reproduced then fixed, crash recovery", () => {
-  const path = tmpPath("dsh-mneme-stress-test-");
-  const sA = createStore(path);
-  const svA = createService({ store: sA, mirror: null, config: {} });
-
-  // duplicate merge: 20 agents save the same title → exactly one active row
-  for (let i = 0; i < 20; i++) {
-    svA.saveWithDedupe({ type: "preference", title: "并发任务", content: `agent-${i}` });
-  }
-  assert.equal(
-    svA.list({ type: "preference", limit: 100 }).filter((m) => m.title === "并发任务").length,
-    1,
-    "no duplicate rows after concurrent same-title saves"
-  );
-
-  // lost update: two connections read the same baseline, then both write
-  const sB = createStore(path);
-  const svB = createService({ store: sB, mirror: null, config: {} });
-  svA.saveWithDedupe({ type: "history", title: "计数器", content: "count=0", importance: 3 });
-  const id = svA.list({ type: "history" })[0].id;
-
-  const readA = svA.getById(id).content; // count=0
-  const readB = svB.getById(id).content; // count=0 (stale)
-  svA.update(id, { content: bump(readA) }); // count=1
-  svB.update(id, { content: bump(readB) }); // count=1 → overwrites A's increment
-  assert.equal(svB.getById(id).content, "count=1", "unlocked read-modify-write loses an increment");
-
-  // serialized fix: re-read the latest value before writing
-  svA.update(id, { content: "count=0" });
-  svA.update(id, { content: bump(svA.getById(id).content) }); // reads 0 → 1
-  svB.update(id, { content: bump(svB.getById(id).content) }); // reads 1 → 2
-  assert.equal(svB.getById(id).content, "count=2", "re-read before write keeps both increments");
-
-  // crash recovery: committed writes survive an exception and a reopen
-  svA.saveWithDedupe({ type: "project", title: "已提交", content: "x" });
-  assert.throws(() => svA.update("ghost", { content: "boom" }), /not found/, "unknown-id update throws");
-  sA.close();
-  sB.close();
-
-  const sR = createStore(path);
-  assert.ok(sR.getById(id), "counter survives reopen");
-  assert.ok(sR.all().some((m) => m.title === "已提交"), "committed write survives reopen");
-  assert.equal(sR.all().filter((m) => m.title === "已提交").length, 1, "no partial residue");
-  sR.close();
-});
-
-// ---------------------------------------------------------------- CAS + atomicity (item ③)
-
-test("CAS concurrent increments: stale version rejected, retry lands both increments", () => {
-  const path = tmpPath("dsh-mneme-stress-cas-");
-  const sA = createStore(path);
-  const svA = createService({ store: sA, mirror: null, config: {} });
-  const sB = createStore(path);
-  const svB = createService({ store: sB, mirror: null, config: {} });
-
-  svA.saveWithDedupe({ type: "history", title: "计数器", content: "count=0", importance: 3 });
-  const id = svA.list({ type: "history" })[0].id;
-  svA.update(id, { content: "count=0" });
-  const baseline = svA.getById(id); // updated_at=T, count=0
-
-  const aOk = svA.compareAndUpdate(id, baseline.updated_at, { content: bump("count=0") });
-  assert.ok(aOk, "current-version CAS lands");
-  const bStale = svB.compareAndUpdate(id, baseline.updated_at, { content: bump("count=0") });
-  assert.equal(bStale, undefined, "stale-version CAS rejected — no lost update");
-
-  const cur = svB.getById(id);
-  svB.compareAndUpdate(id, cur.updated_at, { content: bump(cur.content) });
-  assert.equal(svB.getById(id).content, "count=2", "re-read + retry keeps both increments");
-  sA.close();
-  sB.close();
-});
-
-test("multi-step transaction is atomic: a mid-way throw rolls back every step", () => {
-  const path = tmpPath("dsh-mneme-stress-atomic-");
-  const s = createStore(path);
-  const sv = createService({ store: s, mirror: null, config: {} });
-
-  assert.throws(
-    () => sv.transaction(() => {
-      sv.saveWithDedupe({ type: "project", title: "原子A", content: "x" });
-      sv.saveWithDedupe({ type: "project", title: "原子B", content: "y" });
-      throw new Error("boom");
-    }),
-    /boom/
-  );
-  assert.ok(!s.all().some((m) => m.title === "原子A"), "atomicA fully rolled back");
-  assert.ok(!s.all().some((m) => m.title === "原子B"), "atomicB fully rolled back");
-
-  // a clean transaction commits both steps
-  sv.transaction(() => {
-    sv.saveWithDedupe({ type: "project", title: "完整A", content: "x" });
-    sv.saveWithDedupe({ type: "project", title: "完整B", content: "y" });
-  });
-  assert.equal(s.all().filter((m) => m.title === "完整A").length, 1, "committed step A");
-  assert.equal(s.all().filter((m) => m.title === "完整B").length, 1, "committed step B");
-  s.close();
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler, parseReceipt } from "../src/dream.js";
+import { applyDecisions } from "../src/dream/decisions.js";
+import {
+  sessionDecisions,
+  arbitrationDecisions,
+  mockCtx
+} from "./helpers/dream-mock.js";
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  return { store, service, dream };
+}
+
+function tmpPath(prefix) {
+  return join(mkdtempSync(join(tmpdir(), prefix)), "memory.db");
+}
+
+// ---------------------------------------------------------------- 轴线 1
+
+test("long-session stress: Recall@k stays high, stale residual drops to zero", async () => {
+  const { store, service, dream } = setup();
+  const ctx = mockCtx({ onConsolidation: sessionDecisions });
+  const topics = 5;
+  const rounds = 3;
+
+  const gt = [];
+  for (let t = 1; t <= topics; t++) {
+    const title = `主题${String(t).padStart(2, "0")}`;
+    const { memory } = service.saveWithDedupe({ type: "project", title, content: `${title} 规范内容`, importance: 5 });
+    gt.push({ title, id: memory.id });
+  }
+  for (let r = 1; r <= rounds; r++) {
+    for (let t = 1; t <= topics; t++) {
+      service.saveWithDedupe({
+        type: "project",
+        title: `主题${String(t).padStart(2, "0")}·变体${r}`,
+        content: "旧变体",
+        importance: 3
+      });
+    }
+    const result = await dream.runDream(ctx, service, {});
+    assert.equal(result.ok, true);
+  }
+
+  let hits = 0;
+  for (const { title, id } of gt) {
+    if (service.search(title, { limit: 5 }).some((m) => m.id === id)) hits++;
+  }
+  assert.equal(hits, topics, "every canonical memory recalled in top-5 after 3 consolidation rounds");
+
+  const all = store.all();
+  const variants = all.filter((m) => m.type === "project" && m.title.includes("变体"));
+  assert.equal(variants.filter((m) => !m.archived).length, 0, "no stale variants remain active");
+  assert.equal(store.listDreamRuns().length, rounds, "every run written to the audit trail");
+  store.close();
+});
+
+// ---------------------------------------------------------------- 轴线 2
+
+test("arbitration set is replayable: deterministic, correct, idempotent replay", async () => {
+  const { store, service, dream } = setup();
+  const ctx = mockCtx({ onConsolidation: arbitrationDecisions });
+  const sets = [
+    { w: { type: "decision", title: "截止", content: "8月20日", importance: 5 }, l: { type: "decision", title: "截止(旧)", content: "8月15日", importance: 3 } },
+    { w: { type: "preference", title: "语言", content: "简体中文", importance: 5 }, l: { type: "preference", title: "语言(旧)", content: "繁体中文", importance: 2 } }
+  ];
+  for (const s of sets) {
+    service.saveWithDedupe({ ...s.l });
+    service.saveWithDedupe({ ...s.w });
+  }
+
+  const run = await dream.runDream(ctx, service, {});
+  assert.equal(run.ok, true);
+  assert.equal(run.applied, sets.length, "one conflict per arbitration set");
+
+  // correctness: winner kept (with provenance), loser archived
+  for (const s of sets) {
+    const winner = service.list({ type: s.w.type }).find((m) => m.title === s.w.title);
+    const loser = store.all().find((m) => m.title === s.l.title);
+    assert.ok(winner, "winner present");
+    assert.ok(loser?.archived, "loser archived");
+    assert.ok(winner.content.includes("已否决旧信息"), "provenance note appended");
+  }
+
+  // audit + receipt are replayable
+  const audit = store.getDreamRun(run.runId);
+  assert.equal(audit.status, "ok");
+  const receipt = parseReceipt(audit.receipt);
+  assert.equal(receipt.status, "ok");
+  assert.equal(Object.keys(audit.outcome.byId).length, sets.length * 2, "outcome covers every arbitrated id");
+  assert.equal(audit.decisions.length, sets.length, "raw decisions persisted");
+
+  // re-applying the recorded decision list is a no-op (idempotent replay)
+  assert.equal(applyDecisions(audit.decisions, service).applied, 0, "replay applies nothing");
+  store.close();
+});
+
+// ---------------------------------------------------------------- 轴线 3
+
+function bump(content) {
+  return `count=${Number(content.match(/count=(\d+)/)[1]) + 1}`;
+}
+
+test("concurrent agents: no duplicate merge, lost-update reproduced then fixed, crash recovery", () => {
+  const path = tmpPath("dsh-mneme-stress-test-");
+  const sA = createStore(path);
+  const svA = createService({ store: sA, mirror: null, config: {} });
+
+  // duplicate merge: 20 agents save the same title → exactly one active row
+  for (let i = 0; i < 20; i++) {
+    svA.saveWithDedupe({ type: "preference", title: "并发任务", content: `agent-${i}` });
+  }
+  assert.equal(
+    svA.list({ type: "preference", limit: 100 }).filter((m) => m.title === "并发任务").length,
+    1,
+    "no duplicate rows after concurrent same-title saves"
+  );
+
+  // lost update: two connections read the same baseline, then both write
+  const sB = createStore(path);
+  const svB = createService({ store: sB, mirror: null, config: {} });
+  svA.saveWithDedupe({ type: "history", title: "计数器", content: "count=0", importance: 3 });
+  const id = svA.list({ type: "history" })[0].id;
+
+  const readA = svA.getById(id).content; // count=0
+  const readB = svB.getById(id).content; // count=0 (stale)
+  svA.update(id, { content: bump(readA) }); // count=1
+  svB.update(id, { content: bump(readB) }); // count=1 → overwrites A's increment
+  assert.equal(svB.getById(id).content, "count=1", "unlocked read-modify-write loses an increment");
+
+  // serialized fix: re-read the latest value before writing
+  svA.update(id, { content: "count=0" });
+  svA.update(id, { content: bump(svA.getById(id).content) }); // reads 0 → 1
+  svB.update(id, { content: bump(svB.getById(id).content) }); // reads 1 → 2
+  assert.equal(svB.getById(id).content, "count=2", "re-read before write keeps both increments");
+
+  // crash recovery: committed writes survive an exception and a reopen
+  svA.saveWithDedupe({ type: "project", title: "已提交", content: "x" });
+  assert.throws(() => svA.update("ghost", { content: "boom" }), /not found/, "unknown-id update throws");
+  sA.close();
+  sB.close();
+
+  const sR = createStore(path);
+  assert.ok(sR.getById(id), "counter survives reopen");
+  assert.ok(sR.all().some((m) => m.title === "已提交"), "committed write survives reopen");
+  assert.equal(sR.all().filter((m) => m.title === "已提交").length, 1, "no partial residue");
+  sR.close();
+});
+
+// ---------------------------------------------------------------- CAS + atomicity (item ③)
+
+test("CAS concurrent increments: stale version rejected, retry lands both increments", () => {
+  const path = tmpPath("dsh-mneme-stress-cas-");
+  const sA = createStore(path);
+  const svA = createService({ store: sA, mirror: null, config: {} });
+  const sB = createStore(path);
+  const svB = createService({ store: sB, mirror: null, config: {} });
+
+  svA.saveWithDedupe({ type: "history", title: "计数器", content: "count=0", importance: 3 });
+  const id = svA.list({ type: "history" })[0].id;
+  svA.update(id, { content: "count=0" });
+  const baseline = svA.getById(id); // updated_at=T, count=0
+
+  const aOk = svA.compareAndUpdate(id, baseline.updated_at, { content: bump("count=0") });
+  assert.ok(aOk, "current-version CAS lands");
+  const bStale = svB.compareAndUpdate(id, baseline.updated_at, { content: bump("count=0") });
+  assert.equal(bStale, undefined, "stale-version CAS rejected — no lost update");
+
+  const cur = svB.getById(id);
+  svB.compareAndUpdate(id, cur.updated_at, { content: bump(cur.content) });
+  assert.equal(svB.getById(id).content, "count=2", "re-read + retry keeps both increments");
+  sA.close();
+  sB.close();
+});
+
+test("multi-step transaction is atomic: a mid-way throw rolls back every step", () => {
+  const path = tmpPath("dsh-mneme-stress-atomic-");
+  const s = createStore(path);
+  const sv = createService({ store: s, mirror: null, config: {} });
+
+  assert.throws(
+    () => sv.transaction(() => {
+      sv.saveWithDedupe({ type: "project", title: "原子A", content: "x" });
+      sv.saveWithDedupe({ type: "project", title: "原子B", content: "y" });
+      throw new Error("boom");
+    }),
+    /boom/
+  );
+  assert.ok(!s.all().some((m) => m.title === "原子A"), "atomicA fully rolled back");
+  assert.ok(!s.all().some((m) => m.title === "原子B"), "atomicB fully rolled back");
+
+  // a clean transaction commits both steps
+  sv.transaction(() => {
+    sv.saveWithDedupe({ type: "project", title: "完整A", content: "x" });
+    sv.saveWithDedupe({ type: "project", title: "完整B", content: "y" });
+  });
+  assert.equal(s.all().filter((m) => m.title === "完整A").length, 1, "committed step A");
+  assert.equal(s.all().filter((m) => m.title === "完整B").length, 1, "committed step B");
+  s.close();
+});

package/test/summarize-occurred-at.test.js

@@ -0,0 +1,127 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSummarizer, parseSummaryJson } from "../src/summarize.js";
+
+// 蒸馏的时间锚定（SimpleMem，arXiv 2601.02553：抽取与时间锚定在同一次生成里完成，
+// 消融去掉后时间类问题 F1 掉 56.7%）。这组用例防的是三类回归：
+//   1) occurred_at 在解析层被吞掉（历史形状里没有这个字段，改 prompt 时容易只改
+//      提示词、忘记映射）；
+//   2) 解析不出来的时间被写成 null / "" 而不是省略键——空值会被下游当成「已锚定」，
+//      污染 occurred_from/occurred_to 过滤与时间排序；
+//   3) 模型瞎填的未来时间原样落库（store.normalizeOccurredAt 只判可解析性，拦不住）。
+// 时间一律按「相对当下」构造：锁死某个日期会让用例在时钟走过该日期后变成反向断言。
+const HOUR_MS = 3600 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+
+/** 带 +08:00 偏移的同刻 ISO 写法：证明归一真的解析过时区，而不是原样搬运字符串。 */
+function isoWithOffset(ms) {
+  return `${new Date(ms + 8 * HOUR_MS).toISOString().slice(0, 23)}+08:00`;
+}
+
+function setup(entries, deps = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const events = [];
+  const calls = [];
+  const ctx = {
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {
+        const i = events.findIndex((e) => e.name === name && e.fn === fn);
+        if (i !== -1) events.splice(i, 1);
+      };
+    },
+    llm: {
+      stream(options) {
+        calls.push(options);
+        const json = JSON.stringify(entries);
+        return (async function* () {
+          yield { type: "block-start", block: { type: "text" } };
+          yield { type: "text-delta", delta: json };
+          yield { type: "block-end", block: { type: "text" } };
+          yield { type: "finish", kind: "ok" };
+        })();
+      }
+    }
+  };
+  createSummarizer(ctx, service, { autoSummarize: true }, deps);
+  return { store, service, calls, handler: events.find((e) => e.name === "session/event").fn };
+}
+
+function turnEndSession(text = "上周把 occurred_at 接进蒸馏链路") {
+  return {
+    id: "s-time",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text }] } },
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+}
+
+test("parseSummaryJson keeps a parseable occurred_at, normalized to UTC ISO", () => {
+  const past = Date.now() - 30 * DAY_MS;
+  const parsed = parseSummaryJson(JSON.stringify([
+    { type: "history", title: "时间锚定", content: "上周把 occurred_at 接进蒸馏", importance: 2, occurred_at: isoWithOffset(past) }
+  ]));
+  assert.equal(parsed.length, 1);
+  assert.equal(parsed[0].occurred_at, new Date(past).toISOString(), "带偏移的绝对时间归一为 UTC ISO");
+});
+
+test("parseSummaryJson omits occurred_at when it is unparseable, non-string, or beyond the 1-day future tolerance", () => {
+  const now = Date.now();
+  const parsed = parseSummaryJson(JSON.stringify([
+    { type: "history", title: "脏字符串", content: "模型给了自然语言时间", importance: 2, occurred_at: "昨天下午" },
+    { type: "history", title: "空白串", content: "模型给了空串", importance: 2, occurred_at: "   " },
+    { type: "history", title: "非字符串", content: "模型给了 epoch 数字", importance: 2, occurred_at: 1757000000000 },
+    { type: "history", title: "未来时间", content: "模型编了个两年后的时间", importance: 2, occurred_at: new Date(now + 730 * DAY_MS).toISOString() },
+    { type: "history", title: "略晚于当下", content: "时区/时钟偏移内的未来时间", importance: 2, occurred_at: new Date(now + HOUR_MS).toISOString() },
+    { type: "history", title: "没给时间", content: "最普通的条目", importance: 2 }
+  ]));
+  assert.equal(parsed.length, 6);
+  for (const i of [0, 1, 2, 3, 5]) {
+    assert.equal("occurred_at" in parsed[i], false, `${parsed[i].title}：必须整条省略该键（不是 null、不是空串）`);
+  }
+  // 1 天容忍内的未来时间保留：真实时钟与模型给出的时区写法会有小时级偏差，不是瞎填。
+  assert.equal(parsed[4].occurred_at, new Date(now + HOUR_MS).toISOString(), "容忍窗口内的时间照常保留");
+});
+
+test("distilled occurred_at is visible in the store, dirty/future values are dropped", async () => {
+  const past = Date.now() - 3 * HOUR_MS;
+  const { store, handler } = setup([
+    { type: "decision", title: "时间锚定", content: "蒸馏产物带绝对时间 occurred_at", importance: 4, occurred_at: isoWithOffset(past) },
+    { type: "history", title: "脏时间", content: "模型给了不可解析的时间", importance: 2, occurred_at: "上周三" },
+    { type: "history", title: "未来时间", content: "模型编了个两年后的时间", importance: 2, occurred_at: new Date(Date.now() + 730 * DAY_MS).toISOString() },
+    { type: "history", title: "无时间", content: "条目里根本没有时间依据", importance: 2 }
+  ]);
+  await handler(turnEndSession(), { seq: 2, type: "turn/end" });
+
+  const rows = store.all();
+  const byTitle = (title) => {
+    const row = rows.find((r) => r.title === title);
+    assert.ok(row, `记忆「${title}」应当落库`);
+    return row;
+  };
+  // 落库可见：解析层的归一值原样进 memories.occurred_at（saveWithDedupe 普通路径）。
+  assert.equal(byTitle("时间锚定").occurred_at, new Date(past).toISOString());
+  // 丢弃：不可解析与超容忍的未来时间都不落列（NULL），不是字符串化后硬存。
+  assert.equal(byTitle("脏时间").occurred_at, undefined);
+  assert.equal(byTitle("未来时间").occurred_at, undefined);
+  assert.equal(byTitle("无时间").occurred_at, undefined);
+});
+
+test("the distill system prompt carries the wall-clock anchor relative times are converted against", async () => {
+  const fixed = new Date("2026-05-04T03:02:01.000Z");
+  const { calls, handler } = setup([
+    { type: "history", title: "锚点", content: "会话里只说了「昨天」", importance: 2 }
+  ], { now: () => fixed.getTime() });
+  await handler(turnEndSession("昨天部署了 v0.8.4"), { seq: 2, type: "turn/end" });
+
+  const system = calls[0].messages.find((m) => m.role === "system")?.content?.[0]?.text ?? "";
+  assert.ok(system.includes("occurred_at"), "系统提示的形状串里给出可选时间字段");
+  assert.ok(system.includes("严格") || system.includes("严禁编造"), "提示词写明编造禁令");
+  // 锚点取自可注入时钟：没有它，「昨天」永远换算不出绝对值。
+  assert.ok(system.includes(`当前时间：${fixed.toISOString()}`), "系统提示末尾带上会话发生时间");
+});