@modusensus/dsh-mneme 0.14.0-beta.1 → 0.14.0-beta.2

package/test/date-hint.test.js

@@ -0,0 +1,156 @@
+// 模型可见时间线索：注入行与三个工具回执都要带日期，且日期缺省时渲染与改动前
+// 逐字节一致。
+//
+// 为什么单独开一份：这三处（inject.js / tools.js / lang.js）在仓库里从来没有测试
+// 断言过渲染串（ops_grep 在 252 个测试文件里对 `updated: ` 零命中），所以改动它们
+// 时测试不会红——反过来说，新加的行为也没人钉住。本文件专门钉这个面。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { hintDate, memoryDate } from "../src/date-hint.js";
+import { STR } from "../src/lang.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+test("hintDate 只认 YYYY-MM-DD 前缀的形状，坏值返回空串而不是占位符", () => {
+  assert.equal(hintDate("2026-11-11T10:29:45.703Z"), "2026-11-11");
+  assert.equal(hintDate("2026-11-11"), "2026-11-11");
+  assert.equal(hintDate(""), "");
+  assert.equal(hintDate(null), "");
+  assert.equal(hintDate(undefined), "");
+  assert.equal(hintDate("2026-11"), "");
+  assert.equal(hintDate("昨天"), "");
+  assert.equal(hintDate(20261111), "");
+});
+
+test("memoryDate：事件发生时间优先，缺省回落到落库时间", () => {
+  assert.equal(memoryDate({ occurred_at: "2026-10-05T09:30:00+08:00", created_at: "2026-11-01T00:00:00Z" }), "2026-10-05");
+  assert.equal(memoryDate({ occurred_at: null, created_at: "2026-11-01T00:00:00Z" }), "2026-11-01");
+  assert.equal(memoryDate({ created_at: "2026-11-01T00:00:00Z" }), "2026-11-01");
+  // occurred_at 形状不对时不能让整条丢掉日期——回落 created_at。
+  assert.equal(memoryDate({ occurred_at: "not-a-date", created_at: "2026-11-01T00:00:00Z" }), "2026-11-01");
+  assert.equal(memoryDate({}), "");
+  assert.equal(memoryDate(null), "");
+});
+
+// 日期位是「可选参数」：不传时渲染必须与加日期前逐字节相同。老调用方（含
+// test/graph-inject-budget.test.js 的三参调用）因此不受影响。
+test("两个行模板：不传日期时输出与加日期前逐字节一致", () => {
+  assert.equal(STR.entryLine.zh("preference", "", "标题", "正文"), "- [preference] 标题：正文");
+  assert.equal(STR.entryLine.en("preference", "[verified] ", "Title", "body"), "- [preference] [verified] Title: body");
+  assert.equal(STR.graphHintLine.zh("entity", "某某", "内容"), "- [线索/entity] 某某：内容");
+  assert.equal(STR.graphHintLine.en("technology", "Foo", "bar"), "- [hint/technology] Foo: bar");
+});
+
+test("两个行模板：传日期时日期落在类型括号之后、标题之前", () => {
+  assert.equal(STR.entryLine.zh("preference", "", "标题", "正文", "2026-11-11"), "- [preference] 2026-11-11 标题：正文");
+  assert.equal(STR.entryLine.en("decision", "", "Title", "body", "2026-11-11"), "- [decision] 2026-11-11 Title: body");
+  // 前缀 `- [type] ` 不能被日期抢走：线索行的引导语/前缀断言依赖它。
+  assert.ok(STR.graphHintLine.zh("entity", "某某", "内容", "2026-11-11").startsWith("- [线索/entity] "));
+  assert.equal(STR.graphHintLine.zh("entity", "某某", "内容", "2026-11-11"), "- [线索/entity] 2026-11-11 某某：内容");
+});
+
+function setupTools() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+  createTools(ctx, service, {}, null);
+  const byName = (n) => registered.find((t) => t.name === n);
+  return { store, service, byName };
+}
+
+test("memory_search / memory_list / memory_get 三个回执都带 created 与 updated", async () => {
+  const { store, service, byName } = setupTools();
+  try {
+    const saved = service.saveWithDedupe({ type: "preference", title: "时间线索", content: "条目正文" }).memory;
+    const day = saved.created_at.slice(0, 10);
+
+    const search = byName("memory_search");
+    const searchText = search.output.render({}, await search.execute({ query: "条目正文" }))[0].text;
+    assert.ok(searchText.includes(`created: ${day}`), "search 回执要带 created（原只有 updated）");
+    assert.ok(searchText.includes(`updated: ${day}`), "search 回执的 updated 不能丢");
+    assert.ok(!searchText.includes("T10:"), "日期不带时分秒");
+
+    const list = byName("memory_list");
+    const listText = list.output.render({}, await list.execute({}))[0].text;
+    assert.ok(listText.includes(`created: ${day}`), "list 回执要带 created");
+
+    // memory_get 改动前连 updated 都不给——模型取全文时彻底丢时间。
+    const get = byName("memory_get");
+    const getText = get.output.render({}, await get.execute({ id: saved.id }))[0].text;
+    assert.ok(getText.includes(`created: ${day}`), "get 回执要带 created");
+    assert.ok(getText.includes(`updated: ${day}`), "get 回执要带 updated（改动前缺）");
+  } finally {
+    store.close();
+  }
+});
+
+// 注入行是消费方唯一无条件可见的文本：不带日期，模型只能拿 updated_at 猜年龄。
+test("注入行带条目日期，occurred_at 优先于 created_at", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const contexts = [];
+  const ctx = { systemPrompt: { context(def) { contexts.push(def); } } };
+  try {
+    const saved = service.saveWithDedupe({
+      type: "decision", title: "带发生时间的决策", content: "正文", importance: 5,
+      occurred_at: "2026-10-05T09:30:00+08:00"
+    }).memory;
+    createInjector(ctx, service, createSettings(store.db), { maxInjectedItems: 3, importanceThreshold: 3 });
+    const text = contexts[0].text({});
+    assert.ok(text.includes(`- [decision] 2026-10-05 带发生时间的决策`),
+      `注入行要带 occurred_at 的日期，实际：${text}`);
+    assert.ok(!text.includes(saved.created_at.slice(0, 10)),
+      "occurred_at 存在时不应再拿 created_at 顶替");
+  } finally {
+    store.close();
+  }
+});
+
+test("注入行：无 occurred_at 时回落到 created_at，且降级标题行同样带日期", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const contexts = [];
+  const ctx = { systemPrompt: { context(def) { contexts.push(def); } } };
+  try {
+    const saved = service.saveWithDedupe({ type: "project", title: "无发生时间", content: "正文", importance: 5 }).memory;
+    const day = saved.created_at.slice(0, 10);
+    createInjector(ctx, service, createSettings(store.db), { maxInjectedItems: 3, importanceThreshold: 3 });
+    const text = contexts[0].text({});
+    assert.ok(text.includes(`- [project] ${day} 无发生时间`), `注入行要回落 created_at，实际：${text}`);
+  } finally {
+    store.close();
+  }
+});
+
+// 降级标题行（预算不足时只留标题）是另一段代码，漏改就会在同一块里出现「有日期」
+// 与「无日期」两种行，模型会以为后者是特殊条目。
+test("预算不足的降级标题行也带日期", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const contexts = [];
+  const ctx = { systemPrompt: { context(def) { contexts.push(def); } } };
+  try {
+    // 两条超长正文 → 高重要度那条先渲染并吃掉预算，低一档的只能退化成标题行。
+    // 不能挑 pin 类型（constraint/preference）：pin 池不参与塌缩预算，永远不会降级
+    // ——踩过一次，测试因此假绿。也不能让两条同重要度：平局按 updated_at DESC 排，
+    // 后插入的那条会先渲染，到底谁降级就不确定了。配置键是 injectContentMaxChars
+    // （inject.js:187），不是 maxContent。
+    const long = "长".repeat(2000);
+    const first = service.saveWithDedupe({ type: "project", title: "占满预算", content: long, importance: 5 }).memory;
+    const second = service.saveWithDedupe({ type: "project", title: "被降级", content: long, importance: 3 }).memory;
+    createInjector(ctx, service, createSettings(store.db), {
+      maxInjectedItems: 5, importanceThreshold: 3, injectContentMaxChars: 1400
+    });
+    const text = contexts[0].text({});
+    assert.ok(text.includes(`${first.created_at.slice(0, 10)} 占满预算`), "满行带日期");
+    // 降级行必须逐字匹配「类型 + 日期 + 标题 + 重要性」，且整行就到重要性结尾。
+    const degraded = `- [project] ${second.created_at.slice(0, 10)} 被降级（重要性 3）`;
+    assert.ok(text.split("\n").includes(degraded), `降级标题行要带日期且不带正文，实际块：\n${text.slice(0, 600)}`);
+  } finally {
+    store.close();
+  }
+});

package/test/dedupe-candidate-window.test.js

@@ -1,180 +1,180 @@
-// Issue #505：saveWithDedupe 的去重候选窗口固定 100 条，库一变大就静默不再合并。
-//
-// 根因：候选集是 store.list({ type, limit: 100 })，order 默认 importance
-// ⇒「该类型最重要的 100 行」，与「找出同标题的那一行」无关。某类型里 importance
-// 高于待写行的行数一旦超过窗口，同标题行与待写行双双落在窗口外，find 恒不命中，
-// 于是走创建分支：不报错、不告警，合并语义随库增长而失效。
-//
-// 这组用例刻意复刻报告里的实测形状（类型 1047 行、其中 importance=5 有 180 行），
-// 但用更小的数字达成同样的窗口溢出，避免测试本身变慢。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-function freshService() {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  return { store, service };
-}
-
-// 往某个类型里灌 n 条 importance=5 的行，把窗口挤满。
-function crowdType(store, type, n) {
-  for (let i = 0; i < n; i++) {
-    store.save({
-      type,
-      title: `crowd-${type}-${i}`,
-      content: `padding row ${i}`,
-      importance: 5
-    });
-  }
-}
-
-test("#505: 同类型 importance 更高的行超过窗口后，同标题第二次写入仍然合并", () => {
-  const { store, service } = freshService();
-  // 窗口是 100。灌 120 条 importance=5，保证待写行（importance=3）与它的同标题
-  // 行都排不进前 100。
-  crowdType(store, "project", 120);
-
-  const payload = {
-    type: "project",
-    title: "dedupe-target",
-    content: "first content",
-    importance: 3
-  };
-  const first = service.saveWithDedupe(payload);
-  assert.equal(first.action, "created", "第一次写入应当是新建");
-
-  const second = service.saveWithDedupe({ ...payload, content: "second content" });
-  assert.equal(
-    second.action,
-    "merged",
-    "第二次同标题写入必须并入已有行；返回 created 说明候选窗口把同标题行挡在窗口外（#505 静默降级）"
-  );
-  assert.equal(second.memory.id, first.memory.id, "合并必须落在同一行");
-
-  const rows = store.list({ type: "project", limit: null })
-    .filter((m) => m.title.trim() === "dedupe-target");
-  assert.equal(rows.length, 1, "同标题只应存在一行");
-});
-
-test("#505: 定向候选不受 importance 分布影响（低 importance 的同标题行也能命中）", () => {
-  const { store, service } = freshService();
-  // 先写一条 importance=1 的目标行，再用大量 importance=5 的行把它挤出窗口。
-  const first = service.saveWithDedupe({
-    type: "pattern",
-    title: "low-importance-target",
-    content: "seed",
-    importance: 1
-  });
-  assert.equal(first.action, "created");
-
-  crowdType(store, "pattern", 120);
-
-  const second = service.saveWithDedupe({
-    type: "pattern",
-    title: "low-importance-target",
-    content: "merged later",
-    importance: 1
-  });
-  assert.equal(second.action, "merged", "低 importance 的同标题行同样必须能被找到");
-  assert.equal(second.memory.id, first.memory.id);
-});
-
-test("#505: 标题首尾空白不影响去重命中（入库不 trim，比较 trim）", () => {
-  const { store, service } = freshService();
-  crowdType(store, "constraint", 120);
-
-  const first = service.saveWithDedupe({
-    type: "constraint",
-    title: "  spaced title  ",
-    content: "seed",
-    importance: 3
-  });
-  assert.equal(first.action, "created");
-
-  // 同一个标题、首尾空白写法不同——按 trim 口径应当命中同一行。
-  const second = service.saveWithDedupe({
-    type: "constraint",
-    title: "spaced title",
-    content: "merged",
-    importance: 3
-  });
-  assert.equal(second.action, "merged", "trim 后同标题必须合并，否则存量带空白的标题会退回静默降级");
-  assert.equal(second.memory.id, first.memory.id);
-});
-
-test("#505: 定向候选不跨类型命中", () => {
-  const { store, service } = freshService();
-  crowdType(store, "project", 120);
-
-  const a = service.saveWithDedupe({
-    type: "project",
-    title: "same-title-different-type",
-    content: "in project",
-    importance: 3
-  });
-  const b = service.saveWithDedupe({
-    type: "preference",
-    title: "same-title-different-type",
-    content: "in preference",
-    importance: 3
-  });
-  assert.equal(a.action, "created");
-  assert.equal(b.action, "created", "不同 type 的同标题行不得合并");
-  assert.notEqual(a.memory.id, b.memory.id);
-});
-
-test("#505: 归档行不作为合并目标（口径与 list 默认一致）", () => {
-  const { store, service } = freshService();
-  crowdType(store, "decision", 120);
-
-  const first = service.saveWithDedupe({
-    type: "decision",
-    title: "archived-target",
-    content: "seed",
-    importance: 3
-  });
-  // 归档必须走 store.setArchived——store.update 的 SET 子句里没有 archived 列，
-  // 用 update({archived:true}) 根本不会归档，测试会假绿。
-  store.setArchived(first.memory.id, true);
-
-  const second = service.saveWithDedupe({
-    type: "decision",
-    title: "archived-target",
-    content: "after archive",
-    importance: 3
-  });
-  assert.equal(second.action, "created", "已归档行不该被当作活跃合并目标");
-  assert.notEqual(second.memory.id, first.memory.id);
-});
-
-
-// #505 把「取该类型前 100 条」换成「按 type + TRIM(title) 精确取」：窗口没了、静默不
-// 合并也没了，但 SQL 形状变了——代价随最大类型的行数线性长（20000 行时 4.6ms 一次，
-// 每存一条付一次），所以 store.js 里配了 (type, TRIM(title)) 表达式索引。这条用例不测
-// 快慢（机器有关节，数字不可复现），测的是**那条索引真的被这条查询选中**：表达式写歪
-// 一点（漏 TRIM、列序不对）优化器就静默退回扫整个类型，而本文件其余用例全绿。
-test("#505: 定向候选那条 SQL 命中表达式索引，而不是扫完整个类型", () => {
-  const dir = mkdtempSync(join(tmpdir(), "mneme-dedupe-idx-"));
-  const file = join(dir, "m.db");
-  const store = createStore(file);
-  store.save({ type: "project", title: "  spaced  ", content: "x", importance: 3 });
-  store.close();
-  const db = new DatabaseSync(file);
-  try {
-    // WHERE 与 store.js 的 activeByTypeAndTitle 逐字同形，只把列表换成单列。
-    const plan = db.prepare(
-      "EXPLAIN QUERY PLAN SELECT id FROM memories WHERE type = ? AND TRIM(title) = ? AND forgotten = 0 AND archived = 0"
-    ).all("project", "spaced").map((r) => r.detail).join(" ");
-    assert.match(plan, /idx_memories_type_trimmed_title/,
-      `定向候选必须走 (type, TRIM(title)) 表达式索引，实得：${plan}`);
-  } finally {
-    db.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+// Issue #505：saveWithDedupe 的去重候选窗口固定 100 条，库一变大就静默不再合并。
+//
+// 根因：候选集是 store.list({ type, limit: 100 })，order 默认 importance
+// ⇒「该类型最重要的 100 行」，与「找出同标题的那一行」无关。某类型里 importance
+// 高于待写行的行数一旦超过窗口，同标题行与待写行双双落在窗口外，find 恒不命中，
+// 于是走创建分支：不报错、不告警，合并语义随库增长而失效。
+//
+// 这组用例刻意复刻报告里的实测形状（类型 1047 行、其中 importance=5 有 180 行），
+// 但用更小的数字达成同样的窗口溢出，避免测试本身变慢。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+function freshService() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+// 往某个类型里灌 n 条 importance=5 的行，把窗口挤满。
+function crowdType(store, type, n) {
+  for (let i = 0; i < n; i++) {
+    store.save({
+      type,
+      title: `crowd-${type}-${i}`,
+      content: `padding row ${i}`,
+      importance: 5
+    });
+  }
+}
+
+test("#505: 同类型 importance 更高的行超过窗口后，同标题第二次写入仍然合并", () => {
+  const { store, service } = freshService();
+  // 窗口是 100。灌 120 条 importance=5，保证待写行（importance=3）与它的同标题
+  // 行都排不进前 100。
+  crowdType(store, "project", 120);
+
+  const payload = {
+    type: "project",
+    title: "dedupe-target",
+    content: "first content",
+    importance: 3
+  };
+  const first = service.saveWithDedupe(payload);
+  assert.equal(first.action, "created", "第一次写入应当是新建");
+
+  const second = service.saveWithDedupe({ ...payload, content: "second content" });
+  assert.equal(
+    second.action,
+    "merged",
+    "第二次同标题写入必须并入已有行；返回 created 说明候选窗口把同标题行挡在窗口外（#505 静默降级）"
+  );
+  assert.equal(second.memory.id, first.memory.id, "合并必须落在同一行");
+
+  const rows = store.list({ type: "project", limit: null })
+    .filter((m) => m.title.trim() === "dedupe-target");
+  assert.equal(rows.length, 1, "同标题只应存在一行");
+});
+
+test("#505: 定向候选不受 importance 分布影响（低 importance 的同标题行也能命中）", () => {
+  const { store, service } = freshService();
+  // 先写一条 importance=1 的目标行，再用大量 importance=5 的行把它挤出窗口。
+  const first = service.saveWithDedupe({
+    type: "pattern",
+    title: "low-importance-target",
+    content: "seed",
+    importance: 1
+  });
+  assert.equal(first.action, "created");
+
+  crowdType(store, "pattern", 120);
+
+  const second = service.saveWithDedupe({
+    type: "pattern",
+    title: "low-importance-target",
+    content: "merged later",
+    importance: 1
+  });
+  assert.equal(second.action, "merged", "低 importance 的同标题行同样必须能被找到");
+  assert.equal(second.memory.id, first.memory.id);
+});
+
+test("#505: 标题首尾空白不影响去重命中（入库不 trim，比较 trim）", () => {
+  const { store, service } = freshService();
+  crowdType(store, "constraint", 120);
+
+  const first = service.saveWithDedupe({
+    type: "constraint",
+    title: "  spaced title  ",
+    content: "seed",
+    importance: 3
+  });
+  assert.equal(first.action, "created");
+
+  // 同一个标题、首尾空白写法不同——按 trim 口径应当命中同一行。
+  const second = service.saveWithDedupe({
+    type: "constraint",
+    title: "spaced title",
+    content: "merged",
+    importance: 3
+  });
+  assert.equal(second.action, "merged", "trim 后同标题必须合并，否则存量带空白的标题会退回静默降级");
+  assert.equal(second.memory.id, first.memory.id);
+});
+
+test("#505: 定向候选不跨类型命中", () => {
+  const { store, service } = freshService();
+  crowdType(store, "project", 120);
+
+  const a = service.saveWithDedupe({
+    type: "project",
+    title: "same-title-different-type",
+    content: "in project",
+    importance: 3
+  });
+  const b = service.saveWithDedupe({
+    type: "preference",
+    title: "same-title-different-type",
+    content: "in preference",
+    importance: 3
+  });
+  assert.equal(a.action, "created");
+  assert.equal(b.action, "created", "不同 type 的同标题行不得合并");
+  assert.notEqual(a.memory.id, b.memory.id);
+});
+
+test("#505: 归档行不作为合并目标（口径与 list 默认一致）", () => {
+  const { store, service } = freshService();
+  crowdType(store, "decision", 120);
+
+  const first = service.saveWithDedupe({
+    type: "decision",
+    title: "archived-target",
+    content: "seed",
+    importance: 3
+  });
+  // 归档必须走 store.setArchived——store.update 的 SET 子句里没有 archived 列，
+  // 用 update({archived:true}) 根本不会归档，测试会假绿。
+  store.setArchived(first.memory.id, true);
+
+  const second = service.saveWithDedupe({
+    type: "decision",
+    title: "archived-target",
+    content: "after archive",
+    importance: 3
+  });
+  assert.equal(second.action, "created", "已归档行不该被当作活跃合并目标");
+  assert.notEqual(second.memory.id, first.memory.id);
+});
+
+
+// #505 把「取该类型前 100 条」换成「按 type + TRIM(title) 精确取」：窗口没了、静默不
+// 合并也没了，但 SQL 形状变了——代价随最大类型的行数线性长（20000 行时 4.6ms 一次，
+// 每存一条付一次），所以 store.js 里配了 (type, TRIM(title)) 表达式索引。这条用例不测
+// 快慢（机器有关节，数字不可复现），测的是**那条索引真的被这条查询选中**：表达式写歪
+// 一点（漏 TRIM、列序不对）优化器就静默退回扫整个类型，而本文件其余用例全绿。
+test("#505: 定向候选那条 SQL 命中表达式索引，而不是扫完整个类型", () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-dedupe-idx-"));
+  const file = join(dir, "m.db");
+  const store = createStore(file);
+  store.save({ type: "project", title: "  spaced  ", content: "x", importance: 3 });
+  store.close();
+  const db = new DatabaseSync(file);
+  try {
+    // WHERE 与 store.js 的 activeByTypeAndTitle 逐字同形，只把列表换成单列。
+    const plan = db.prepare(
+      "EXPLAIN QUERY PLAN SELECT id FROM memories WHERE type = ? AND TRIM(title) = ? AND forgotten = 0 AND archived = 0"
+    ).all("project", "spaced").map((r) => r.detail).join(" ");
+    assert.match(plan, /idx_memories_type_trimmed_title/,
+      `定向候选必须走 (type, TRIM(title)) 表达式索引，实得：${plan}`);
+  } finally {
+    db.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});