@modusensus/dsh-mneme 0.8.15 → 0.8.16

package/test/settings.test.js

@@ -182,6 +182,8 @@ test("feature flags accept the new boolean, string, url and enum keys", () => {
   settings.setFeatureFlags({
     "memoryQualityFilter.enabled": false,
     "llmAudit.enabled": false,
+    "distillRecords.enabled": false,
+    "distillRecords.retentionDays": 30,
     bm25SearchEnabled: false,
     conflictFreezeEnabled: true,
     trustEpistemicWeighting: true,
@@ -196,6 +198,9 @@ test("feature flags accept the new boolean, string, url and enum keys", () => {
   const flags = settings.getFeatureFlags();
   assert.equal(flags["memoryQualityFilter.enabled"], false, "nested keys stored flat");
   assert.equal(flags["llmAudit.enabled"], false);
+  // #399：布尔与整数范围两类键都要能过白名单（retentionDays 是 natural 1..3650）
+  assert.equal(flags["distillRecords.enabled"], false);
+  assert.equal(flags["distillRecords.retentionDays"], 30);
   assert.equal(flags.bm25SearchEnabled, false);
   assert.equal(flags.conflictFreezeEnabled, true);
   assert.equal(flags.trustEpistemicWeighting, true);
@@ -215,6 +220,9 @@ test("nested feature flag keys are validated as booleans and rejected otherwise"
   const { store, settings } = setup();
   assert.throws(() => settings.setFeatureFlags({ "memoryQualityFilter.enabled": "yes" }), /memoryQualityFilter\.enabled/);
   assert.throws(() => settings.setFeatureFlags({ "llmAudit.enabled": 1 }), /llmAudit\.enabled/);
+  assert.throws(() => settings.setFeatureFlags({ "distillRecords.enabled": 1 }), /distillRecords\.enabled/);
+  // 范围外的整数也要被挡（retentionDays 上限 3650）
+  assert.throws(() => settings.setFeatureFlags({ "distillRecords.retentionDays": 0 }), /distillRecords\.retentionDays/);
   assert.deepEqual(settings.getFeatureFlags(), {}, "failed writes persist nothing");
   store.close();
 });

package/test/store.test.js

@@ -213,6 +213,114 @@ test("search excludes archived by default", () => {
   store.close();
 });
 
+// ============================ #275 第二批：archived_at 精确归档时刻
+
+test("schema migration adds archived_at column to legacy database", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-migrate-at-"));
+  const dbPath = join(dir, "legacy.db");
+  try {
+    // 存量库：有 archived 标志位，但没有 archived_at（#275 第一批时代的库）
+    const legacy = new DatabaseSync(dbPath);
+    legacy.exec(`CREATE TABLE memories (
+      id TEXT PRIMARY KEY, type TEXT NOT NULL, title TEXT NOT NULL, content TEXT NOT NULL,
+      tags TEXT NOT NULL DEFAULT '[]', importance INTEGER NOT NULL DEFAULT 3,
+      forgotten INTEGER NOT NULL DEFAULT 0, archived INTEGER NOT NULL DEFAULT 0,
+      source TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+    );`);
+    legacy.exec(`INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, created_at, updated_at)
+      VALUES ('old1', 'history', 't', 'c', '[]', 3, 0, 1, NULL, '2026-01-01T00:00:00.000Z', '2026-01-02T00:00:00.000Z');`);
+    legacy.close();
+
+    const store = createStore(dbPath);
+    const cols = store.db.prepare("PRAGMA table_info(memories)").all().map((c) => c.name);
+    assert.ok(cols.includes("archived_at"), "archived_at column added");
+    // 存量归档行零重写：不回填 updated_at（那等于把被推翻的代理口径固化进列里）
+    const raw = store.db.prepare("SELECT archived_at FROM memories WHERE id = 'old1'").get();
+    assert.equal(raw.archived_at, null, "legacy archived row keeps NULL, not backfilled from updated_at");
+    assert.equal(store.getById("old1").archived_at, undefined, "NULL 读作 undefined，调用方须显式处理");
+    store.close();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("archived_at migration is idempotent: reopening the upgraded database is a no-op", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-migrate-at2-"));
+  const dbPath = join(dir, "upgraded.db");
+  try {
+    const first = createStore(dbPath);
+    const m = first.save({ type: "history", title: "t", content: "c" });
+    first.setArchived(m.id, true);
+    const stamp = first.getById(m.id).archived_at;
+    first.close();
+
+    // 再开一次：addColumn 先 PRAGMA 后 ALTER，不该报错、不该重建、不该动已有值
+    const second = createStore(dbPath);
+    const cols = second.db.prepare("PRAGMA table_info(memories)").all().filter((c) => c.name === "archived_at");
+    assert.equal(cols.length, 1, "列只存在一份，没被重复 ALTER");
+    assert.equal(second.getById(m.id).archived_at, stamp, "重开不动已落盘的归档时刻");
+    second.close();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("setArchived stamps archived_at on archive, clears it on restore", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "c", importance: 3 });
+  assert.equal(saved.archived_at, undefined, "新建行未归档 → 无时刻");
+
+  const archived = store.setArchived(saved.id, true);
+  assert.equal(archived.archived, true);
+  assert.ok(archived.archived_at, "活跃 → 归档落时刻");
+  assert.ok(
+    Math.abs(Date.parse(archived.archived_at) - Date.now()) < 5000,
+    "落的是当下时刻，不是别的行的 updated_at"
+  );
+
+  const restored = store.setArchived(saved.id, false);
+  assert.equal(restored.archived, false);
+  assert.equal(restored.archived_at, undefined, "取消归档清空");
+  store.close();
+});
+
+test("setArchived keeps updated_at semantics (existing readers depend on it)", () => {
+  // archived_at 是新增列，不是 updated_at 的替代品：面板排序、快照哈希、CAS 都读
+  // updated_at，本函数自 v0.2 起就无条件刷它——改口径不得顺手改掉这条既有语义。
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "c", importance: 3 });
+  const before = store.getById(saved.id).updated_at;
+  const archived = store.setArchived(saved.id, true);
+  assert.ok(Date.parse(archived.updated_at) >= Date.parse(before), "updated_at 照旧被刷");
+  const again = store.setArchived(saved.id, false);
+  assert.ok(Date.parse(again.updated_at) >= Date.parse(archived.updated_at), "取消归档也刷");
+  store.close();
+});
+
+test("save with archived:true stamps archived_at at insert time", () => {
+  // 铸造即归档的行：archived=1 而 archived_at=NULL 会落进「存量行」语义，读侧只能
+  // 当它时刻不可追溯——明明是当下发生的归档，白丢一条记录。
+  const store = openMemory();
+  const born = store.save({ type: "history", title: "生来就归档", content: "c", archived: true });
+  assert.equal(born.archived, true);
+  assert.ok(born.archived_at, "入库即归档 → 归档时刻 = 入库时刻");
+  assert.equal(born.archived_at, born.created_at, "两列同源（同一个 nowIso）");
+
+  const live = store.save({ type: "history", title: "活跃", content: "c" });
+  assert.equal(live.archived_at, undefined);
+  store.close();
+});
+
+test("update() cannot set archived_at (archived is not an updatable field)", () => {
+  // 归档时刻只能由 setArchived 落。若 update 的 patch 能写它，就等于给精确口径开了
+  // 一个绕过 setArchived 语义（幂等 / 清空）的后门，代理口径会从缝里长回来。
+  const store = openMemory();
+  const saved = store.save({ type: "history", title: "t", content: "c" });
+  store.update(saved.id, { archived_at: "2020-01-01T00:00:00.000Z", content: "改过" });
+  assert.equal(store.getById(saved.id).archived_at, undefined, "patch 里的 archived_at 被忽略");
+  store.close();
+});
+
 // --- vector search ---
 
 test("save/update persist embedding vector and searchVector ranks by cosine", () => {

package/test/summarize.test.js

@@ -274,6 +274,43 @@ test("#239 窗口过短：零 LLM 预判拦下调用，留 skip 审计并消费
   assert.equal(service.listLlmAudits().length, 1, "游标已消费：同一窗口不重复评估、不重复审计");
 });
 
+// #239 定标埋点：窗口字符数必须落进审计，否则下一级预判规则的阈值无从选起。
+// 第二条才是本改动的目的——预判开关关着（默认档位）时行为逐字节不变，但从这一刻
+// 起成功行开始留数，验收 4「默认配置下调用量可量化下降」才有账可对。
+test("#239 计量：window-too-small 的 skip 行带 distillChars 与阈值", async () => {
+  const { events, service } = setup({ summarizeMinWindowChars: 1000 });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-metric-skip",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("好", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  const row = service.listLlmAudits()[0];
+  assert.equal(row.error_message, "window-too-small");
+  // 计的是**真正发给模型的转录文本**长度（含角色前缀：一条 1 字的「好」实测记 4），
+  // 与闸门比较的口径同一个数，定标才对得上。这里不锁字面量，锁语义：短于阈值才该 skip。
+  assert.ok(Number.isInteger(row.metadata?.distillChars) && row.metadata.distillChars > 0,
+    "skip 行必须带窗口字符数");
+  assert.equal(row.metadata.minWindowChars, 1000, "阈值随行落档，事后能复核是哪条闸门拦的");
+  assert.ok(row.metadata.distillChars < row.metadata.minWindowChars, "skip 的前提：窗口短于阈值");
+});
+
+test("#239 计量：预判开关关闭时成功行仍记录 distillChars", async () => {
+  const { events, service } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-metric-success",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("今天决定把窗口字符数记进审计", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  const row = service.listLlmAudits()[0];
+  assert.equal(row.status, "success");
+  assert.ok(Number.isInteger(row.metadata?.distillChars) && row.metadata.distillChars > 0,
+    "默认档位下也要留数，否则验收 4 无从对账");
+});
+
 test("#239 窗口达到阈值时预判放行（不误杀）", async () => {
   const { events, calls } = setup({ summarizeMinWindowChars: 5 });
   const handler = events.find((e) => e.name === "session/event").fn;
@@ -1463,3 +1500,140 @@ test("parseSummaryJson salvage does not turn string-embedded objects into memori
   assert.equal(parsed[0].title, "good");
   assert.match(parsed[0].content, /fake/);
 });
+
+// ── Issue #399：蒸馏窗口原始记录 + 记忆级溯源 ─────────────────────────────
+//
+// 这五条锁的是「把蒸馏从替换降级为叠加索引」的四个承重点：重跑幂等、隐私谓词
+// 在落盘路径同样成立、留存不受喂给模型的裁剪约束、裁剪不毁资产、默认关零写入。
+// 锁形状而非锁实现：断言直接查表，不去读 summarize.js 的中间变量。
+
+/** Issue #399 的开启档 + 关掉真实节流（否则同会话第二轮会被间隔门挡下）。 */
+const RECORDS_ON = { distillRecords: { enabled: true }, distillRateLimitIntervalMs: 0 };
+
+function countRows(store, sql) {
+  return store.db.prepare(sql).get().c;
+}
+
+function recordsSession(id, events) {
+  return {
+    id,
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events
+  };
+}
+
+function eventHandler(events) {
+  return events.find((e) => e.name === "session/event").fn;
+}
+
+test("issue#399: re-distilling the same window never duplicates records", async () => {
+  const first = setup(RECORDS_ON);
+  const session = recordsSession("s399-idem", [userMessage("同一窗口的提问", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(first.events)(session, { seq: 2, type: "turn/end" });
+  assert.equal(countRows(first.store, "SELECT count(*) AS c FROM distill_records"), 1);
+
+  // 模拟宿主重启后重跑同一 seq 段（代码注释里点名的路径：max-runs 耗尽额度、游标
+  // 写入随事务回滚后丢失）：删掉持久化游标 + 换一个全新的 summarizer 实例，于是
+  // lastDistilledSeq 这份内存游标也一并归零，同一窗口会被完整重蒸一遍。
+  first.store.db.prepare("DELETE FROM distill_cursors").run();
+  const second = setup(RECORDS_ON, { store: first.store });
+  await eventHandler(second.events)(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(
+    countRows(first.store, "SELECT count(*) AS c FROM distill_records"),
+    1,
+    "同一 (session_id, seq) 只留一行：重跑必须幂等，保留首次落盘时间才诚实"
+  );
+  assert.equal(
+    countRows(
+      first.store,
+      `SELECT count(*) AS c FROM (
+         SELECT memory_id, session_id, seq_start, seq_end FROM memory_provenance
+         GROUP BY memory_id, session_id, seq_start, seq_end HAVING count(*) > 1)`
+    ),
+    0,
+    "同一窗口重跑不重复挂链接（唯一索引 + ON CONFLICT DO NOTHING）"
+  );
+});
+
+test("issue#399: records keep only public transcript; reasoning and machine-injected content never land on disk", async () => {
+  const { events, store, calls } = setup(RECORDS_ON);
+  const session = recordsSession("s399-priv", [
+    userMessage("真实提问：这个报错怎么修", 1),
+    // 机器注入的三类：AGENTS.md / skill 正文 / 文件变更通知。source.kind 不是
+    // user / agent-message / subagent-settled，必须整个事件被挡在门外。
+    { seq: 2, type: "user/message", data: { source: { kind: "plugin" }, content: [{ type: "text", text: "AGENTS.md 注入正文不该落盘" }] } },
+    { seq: 3, type: "user/message", data: { source: { kind: "skill" }, content: [{ type: "text", text: "SKILL_BODY 不该落盘" }] } },
+    { seq: 4, type: "user/message", data: { source: { kind: "file-change" }, content: [{ type: "text", text: "FILE_CHANGE 通知不该落盘" }] } },
+    {
+      seq: 5,
+      type: "assistant/message",
+      data: { message: { content: [
+        { type: "reasoning", text: "PRIVATE_REASONING 不该落盘" },
+        { type: "text", text: "公开回答：检查第 3 行。" }
+      ] } }
+    },
+    toolResultEvent("TOOL_OUTPUT 只进渲染不落盘", false, 6),
+    { seq: 7, type: "turn/end" }
+  ]);
+  await eventHandler(events)(session, { seq: 7, type: "turn/end" });
+
+  const texts = store.db.prepare("SELECT text FROM distill_records ORDER BY seq").all().map((r) => r.text).join("\n");
+  assert.ok(texts.includes("真实提问"), "用户提示落盘");
+  assert.ok(texts.includes("公开回答"), "助手公开正文落盘");
+  assert.ok(!texts.includes("AGENTS.md"), "插件注入的 AGENTS.md 绝不落盘");
+  assert.ok(!texts.includes("SKILL_BODY"), "skill 正文绝不落盘");
+  assert.ok(!texts.includes("FILE_CHANGE"), "文件变更通知绝不落盘");
+  assert.ok(!texts.includes("PRIVATE_REASONING"), "私有推理链绝不落盘");
+  assert.ok(!texts.includes("TOOL_OUTPUT"), "工具结果不落盘（#399 已知边界 3）");
+  // 渲染路径照旧带工具输出（codingRetrospect 靠它沉淀踩坑根因）——两条路径在
+  // 「工具输出」上的差异是设计的一部分，不是漂移：漂移的方向必须是「落盘的更少」。
+  assert.ok(JSON.stringify(calls[0].messages).includes("TOOL_OUTPUT"), "工具输出仍进 LLM 转录");
+});
+
+test("issue#399: records keep the untruncated prompt while the LLM transcript stays capped", async () => {
+  // 头部标记 + 超长正文：trimTranscript 保尾部，所以「渲染里找不到头部标记」正是
+  // 被 distillMaxChars 截断的证据；记录里必须连头部标记都在。
+  const long = `HEAD_MARKER ${"x".repeat(1200)} TAIL_MARKER`;
+  const { events, store, calls } = setup({ ...RECORDS_ON, distillMaxChars: 200 });
+  const session = recordsSession("s399-long", [userMessage(long, 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  const rows = store.db.prepare("SELECT text FROM distill_records ORDER BY seq").all();
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].text, long, "留存的是整段原文，不截断、不加省略号");
+  assert.ok(!JSON.stringify(calls[0].messages).includes("HEAD_MARKER"), "喂 LLM 的转录仍受 distillMaxChars 约束");
+});
+
+test("issue#399: expiring records keeps the memories and leaves provenance dangling-but-present", async () => {
+  const { events, store } = setup(RECORDS_ON);
+  const session = recordsSession("s399-expire", [userMessage("会被裁剪的原文", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+  assert.equal(store.count(), 2);
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM memory_provenance"), 2);
+
+  // 到期裁剪：把 cutoff 推到未来，等价于「这条记录已经过期」。
+  assert.equal(store.clearDistillRecords(new Date(Date.now() + 86400000).toISOString()), 1);
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM distill_records"), 0);
+  assert.equal(store.count(), 2, "裁剪原文绝不级联删记忆");
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM memory_provenance"), 2, "链接保留，从此指向空区间");
+  const memoryId = store.all()[0].id;
+  assert.ok(store.provenanceFor(memoryId).length >= 1, "面板/CLI 仍能回答「这条记忆出自哪个窗口」，只是来源已过期");
+});
+
+test("issue#399: enabled=false (the default) writes nothing at all", async () => {
+  const { events, store, service } = setup({ distillRateLimitIntervalMs: 0 });
+  let saverCalls = 0;
+  const original = service.saveDistillRecords;
+  service.saveDistillRecords = (...args) => {
+    saverCalls++;
+    return original(...args);
+  };
+  const session = recordsSession("s399-off", [userMessage("默认关不该留原文", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(saverCalls, 0, "默认关：连收集都不做，一次写入调用都不发");
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM distill_records"), 0);
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM memory_provenance"), 0);
+  assert.equal(store.count(), 2, "记忆写入照旧");
+});