@modusensus/dsh-mneme 0.8.2 → 0.8.4

package/test/inject-first-round-bm25.test.js

@@ -1,89 +1,89 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createVectorIndex } from "../src/vector-index.js";
-
-// 回归（issue #198）：注入渲染是同步的（宿主 systemPrompt 不支持异步 text），
-// 查询向量只能异步 prefetch 给下一轮用——首轮 queryVectorCache 必 miss。
-// 此时 injectCandidates 落到静态 priority 排序（summary > preference >
-// importance×quality）：老的高重要性 preference 会占满全部槽位，当前话题的
-// decision/project 进不来（报告者库：427 活跃、29 条 imp=5 preference）。
-// 修复：首轮同步兜底用 BM25 词法召回领位（纯进程内、无需向量）；语义向量
-// 命中时行为不变（向量 > 缓存召回 > BM25 > 静态排序）。
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-// 与查询词法完全不相交的旧高价值 preference（双字组不重叠）
-function seedStalePreferences(service, n = 8) {
-  const ids = [];
-  for (let i = 0; i < n; i++) {
-    ids.push(service.saveWithDedupe({
-      type: "preference",
-      title: `旧偏好条目${i}`,
-      content: `用户喜欢深色界面与紧凑排版，这是第${i}条历史偏好存档`
-    , importance: 5 }).memory.id);
-  }
-  return ids;
-}
-
-test("#198: first round (no vector) leads with BM25 topical hits, not stale preferences", () => {
-  const { service, store } = setup();
-  seedStalePreferences(service, 8);
-  const onTopic = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
-  assert.ok(picked.some((m) => m.id === onTopic.id), "on-topic decision must enter the first-round block");
-  assert.equal(picked[0].id, onTopic.id, "BM25 topical hit leads the block");
-  store.close();
-});
-
-test("#198: legacy static order is kept when bm25 is disabled", () => {
-  const { service, store } = setup({ bm25SearchEnabled: false });
-  seedStalePreferences(service, 8);
-  const onTopic = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
-  assert.ok(!picked.some((m) => m.id === onTopic.id), "bm25 off -> legacy static order (preferences fill the slots)");
-  store.close();
-});
-
-test("#198: vector hits still outrank BM25 when a queryVector is available", async () => {
-  const { service, store } = setup();
-  seedStalePreferences(service, 3);
-  // 词法与查询不相交、但向量命中的记忆：语义路径必须压过 BM25 词法路径。
-  const vectorHit = service.saveWithDedupe({
-    type: "project",
-    title: "星图渲染重构",
-    content: "星图渲染重构记录：绘制管线迁移与图层合并",
-    importance: 3
-  }).memory;
-  const bm25Hit = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-  const vectorIndex = createVectorIndex({ store });
-  service.setVectorIndex(vectorIndex);
-  vectorIndex.saveEmbedding(vectorHit.id, [1, 0, 0]);
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3, queryVector: [1, 0, 0] });
-  assert.equal(picked[0].id, vectorHit.id, "vector hit leads; BM25 only fills the gap when no vector");
-  assert.ok(picked.some((m) => m.id === bm25Hit.id), "BM25 hit still present among candidates");
-  store.close();
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// 回归（issue #198）：注入渲染是同步的（宿主 systemPrompt 不支持异步 text），
+// 查询向量只能异步 prefetch 给下一轮用——首轮 queryVectorCache 必 miss。
+// 此时 injectCandidates 落到静态 priority 排序（summary > preference >
+// importance×quality）：老的高重要性 preference 会占满全部槽位，当前话题的
+// decision/project 进不来（报告者库：427 活跃、29 条 imp=5 preference）。
+// 修复：首轮同步兜底用 BM25 词法召回领位（纯进程内、无需向量）；语义向量
+// 命中时行为不变（向量 > 缓存召回 > BM25 > 静态排序）。
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+// 与查询词法完全不相交的旧高价值 preference（双字组不重叠）
+function seedStalePreferences(service, n = 8) {
+  const ids = [];
+  for (let i = 0; i < n; i++) {
+    ids.push(service.saveWithDedupe({
+      type: "preference",
+      title: `旧偏好条目${i}`,
+      content: `用户喜欢深色界面与紧凑排版，这是第${i}条历史偏好存档`
+    , importance: 5 }).memory.id);
+  }
+  return ids;
+}
+
+test("#198: first round (no vector) leads with BM25 topical hits, not stale preferences", () => {
+  const { service, store } = setup();
+  seedStalePreferences(service, 8);
+  const onTopic = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
+  assert.ok(picked.some((m) => m.id === onTopic.id), "on-topic decision must enter the first-round block");
+  assert.equal(picked[0].id, onTopic.id, "BM25 topical hit leads the block");
+  store.close();
+});
+
+test("#198: legacy static order is kept when bm25 is disabled", () => {
+  const { service, store } = setup({ bm25SearchEnabled: false });
+  seedStalePreferences(service, 8);
+  const onTopic = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
+  assert.ok(!picked.some((m) => m.id === onTopic.id), "bm25 off -> legacy static order (preferences fill the slots)");
+  store.close();
+});
+
+test("#198: vector hits still outrank BM25 when a queryVector is available", async () => {
+  const { service, store } = setup();
+  seedStalePreferences(service, 3);
+  // 词法与查询不相交、但向量命中的记忆：语义路径必须压过 BM25 词法路径。
+  const vectorHit = service.saveWithDedupe({
+    type: "project",
+    title: "星图渲染重构",
+    content: "星图渲染重构记录：绘制管线迁移与图层合并",
+    importance: 3
+  }).memory;
+  const bm25Hit = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+  const vectorIndex = createVectorIndex({ store });
+  service.setVectorIndex(vectorIndex);
+  vectorIndex.saveEmbedding(vectorHit.id, [1, 0, 0]);
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3, queryVector: [1, 0, 0] });
+  assert.equal(picked[0].id, vectorHit.id, "vector hit leads; BM25 only fills the gap when no vector");
+  assert.ok(picked.some((m) => m.id === bm25Hit.id), "BM25 hit still present among candidates");
+  store.close();
+});

package/test/inject-heat.test.js

@@ -0,0 +1,61 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// #218 v1：heat 作为注入排序的**同级内乘数**（issue #218 拍板口径）。
+// 规则路 comparator 的层内权重 importance×quality 乘 heat；priority 分层
+// （summary=0 / preference=1 / coding 同级 / 其余 2）与 store 的 order=chrono
+// 分页序不动。heatEnabled=false（默认）时权重恒 1，排序与改动前一致——
+// 本文件的关闭用例与 heat.test.js 的曲线断言共同锁住验收第 1 条。
+
+const HOUR = 3600000;
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+const titles = (candidates) => candidates.map((c) => c.title);
+
+test("heat off（默认）：层内维持 importance 序，与改动前一致", () => {
+  const { store, service } = setup();
+  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
+  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
+  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
+  // 新记忆不触达：ref 退 created_at（≈现在），heat≈1，不影响本用例
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
+  store.close();
+});
+
+test("heat on：同层内新鲜低重要性记忆越过冷的高重要性记忆", () => {
+  const { store, service } = setup({ heatEnabled: true });
+  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
+  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
+  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  // λ=0.002、3000h → 冷记忆权重 4×e^-6≈0.01，新鲜记忆 3×≈1 → 反超
+  assert.deepEqual(titles(picked), ["新的低重要性决策", "冷的高重要性决策"]);
+  store.close();
+});
+
+test("heat on 且 λ=0（免疫类型）：乘数恒 1，importance 序不受影响", () => {
+  const { store, service } = setup({ heatEnabled: true, heatTypeDecay: { decision: 0 } });
+  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
+  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
+  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
+  store.close();
+});
+
+test("heat 不跨层：再热的 decision 也不越过 summary 层", () => {
+  const { store, service } = setup({ heatEnabled: true });
+  service.saveWithDedupe({ type: "summary", title: "会话总览", content: "总览", importance: 2 });
+  service.saveWithDedupe({ type: "decision", title: "滚烫决策", content: "新", importance: 3 });
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.equal(picked[0].type, "summary", "priority 分层不被 heat 打破");
+  store.close();
+});

package/test/inject-rotation.test.js

@@ -0,0 +1,161 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+// 回归（issue #205）：注入位跨轮轮换。长会话（几十上百轮、注入位有限）中
+// 同一批条目在相邻轮次反复出现——报告者 15.5 小时实测 86 次注入 93% 重复，
+// 库总览一条 43/43 块全勤。新配置 injectRotationTurns（默认 0 = 关闭）：
+// 同一条记忆在最近 N 个「不同用户查询」轮次注入过后，本轮不再优先——
+// 新鲜者前置、不足按原序回填（槽位数不变）；同一查询的重复渲染（工具轮）
+// 不推进窗口；会话边界自动重置。
+
+function setup(configOver = {}) {
+  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);
+        return () => {};
+      }
+    }
+  };
+  const config = { maxInjectedItems: 2, importanceThreshold: 3, ...configOver };
+  createInjector(ctx, service, settings, config);
+  // 注入块是 contexts[0]（memory），user-settings 是 contexts[1]
+  const render = (sessionId, query) => contexts[0].text({
+    agent: { session: { id: sessionId, snapshotEvents: () => query ? [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: query }] } }
+    ] : [] } }
+  });
+  const titles = (text) => [...text.matchAll(/- \[([^\]]+)\] ([^（(]*)/g)].map((m) => m[2].trim());
+  return { store, service, render, titles };
+}
+
+function seedMemories(service, n = 4) {
+  const saved = [];
+  for (let i = 0; i < n; i++) {
+    saved.push(service.saveWithDedupe({
+      type: "preference",
+      title: `偏好条目${i}`,
+      content: `第 ${i} 条独立的用户偏好内容，主题互不相同`,
+      importance: 5
+    }).memory);
+  }
+  return saved;
+}
+
+test("#205: default (rotation off) repeats the same entries across turns", () => {
+  const { store, service, render, titles } = setup({});
+  seedMemories(service, 4);
+  const turn1 = titles(render("s1", "第一个问题"));
+  const turn2 = titles(render("s1", "第二个问题"));
+  assert.equal(turn1.length, 2);
+  assert.deepEqual(turn1, turn2, "rotation off → same entries repeat (current behavior)");
+  store.close();
+});
+
+test("#205: rotation=1 swaps out previously injected entries, slots stay full", () => {
+  const { store, service, render, titles } = setup({ injectRotationTurns: 1 });
+  seedMemories(service, 4);
+  const turn1 = titles(render("s1", "第一个问题"));
+  const turn2 = titles(render("s1", "第二个问题"));
+  assert.equal(turn2.length, 2, "slots stay full");
+  for (const t of turn1) {
+    assert.ok(!turn2.includes(t), `previously injected "${t}" must rotate out`);
+  }
+  store.close();
+});
+
+test("#205: entry becomes eligible again after leaving the window", () => {
+  const { store, service, render, titles } = setup({ injectRotationTurns: 1 });
+  seedMemories(service, 4);
+  const turn1 = titles(render("s1", "q1"));
+  const turn2 = titles(render("s1", "q2")); // window = [q1] → turn1 条目被换下
+  const turn3 = titles(render("s1", "q3")); // window = [q2] → turn1 条目重新有资格
+  for (const t of turn2) assert.ok(!turn3.includes(t), `"${t}" (injected at turn2) rotates out at turn3`);
+  for (const t of turn1) assert.ok(turn3.includes(t), `"${t}" (turn1) is fresh again at turn3`);
+  store.close();
+});
+
+test("#205: repeated renders within the same query do not advance the window", () => {
+  const { store, service, render, titles } = setup({ injectRotationTurns: 1 });
+  seedMemories(service, 4);
+  const turn1a = titles(render("s1", "q1"));
+  const turn1b = titles(render("s1", "q1")); // 同一查询：工具调用轮，不推进
+  assert.deepEqual(turn1a, turn1b, "same query renders identically (window not advanced)");
+  const turn2 = titles(render("s1", "q2"));
+  for (const t of turn1a) assert.ok(!turn2.includes(t), "rotation happens on the next query only");
+  store.close();
+});
+
+test("#205: a new session starts fresh", () => {
+  const { store, service, render, titles } = setup({ injectRotationTurns: 1 });
+  seedMemories(service, 4);
+  const turn1 = titles(render("s1", "q1"));
+  const other = titles(render("s2", "q1")); // 新会话：历史为空
+  assert.deepEqual(other, turn1, "session boundary resets rotation history");
+  store.close();
+});
+
+test("#205: backfill keeps slots full when fresh candidates run out", () => {
+  const { store, service, render, titles } = setup({ injectRotationTurns: 1 });
+  seedMemories(service, 2); // 候选恰等于槽位
+  const turn1 = titles(render("s1", "q1"));
+  const turn2 = titles(render("s1", "q2"));
+  assert.equal(turn2.length, 2, "stale entries backfill when nothing fresh remains");
+  assert.deepEqual(turn1, turn2, "no fresh candidates → original selection returned");
+  store.close();
+});
+
+// 回归（issue #205 补测，报告者读码发现）：轮换窗口需要 maxItems×(N+1) 张
+// 不同的牌，但候选池各有硬上限——语义路径截在 maxItems×2、合并层也是
+// maxItems×2。池子只有十来张时，窗口一开就把池子吃光、只剩回填：重复率的
+// 结构性下限由池子大小决定，轮换本身越不出箱子。修复：rotateWindow > 0 时
+// 池子按 maxItems×(N+1) 扩容（语义检索、bm25、合并层三处同步），无轮换时
+// 保持既有上限不变。旧测试样本（4 条记忆 + 注入位 2 = 恰好 maxItems×2）
+// 正好测不到这个边界——本用例刻意用 8 条 + 窗口 2 压过旧上限。
+test("#205 补测: semantic pool grows with the rotation window (no forced repeats)", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const vectorIndex = createVectorIndex({ store });
+  service.setVectorIndex(vectorIndex);
+  const ids = [];
+  for (let i = 0; i < 8; i++) {
+    const theta = i * 0.1; // 角度递增 → 与 query [1,0,0] 的余弦严格递减
+    const m = service.saveWithDedupe({
+      type: "preference",
+      title: `条目${i}`,
+      content: `第 ${i} 条，主题互不相同`,
+      importance: 5
+    }).memory;
+    vectorIndex.saveEmbedding(m.id, [Math.cos(theta), Math.sin(theta), 0]);
+    ids.push(m.id);
+  }
+
+  const call = (rotate, rotateWindow) => service.injectCandidates({
+    query: "q",
+    queryVector: [1, 0, 0],
+    maxItems: 2,
+    threshold: 3,
+    rotate,
+    rotateWindow
+  }).map((m) => m.id);
+
+  const turn1 = call(null, 2);
+  assert.deepEqual(turn1, [ids[0], ids[1]], "baseline: top-2 by cosine");
+  const turn2 = call(new Set(turn1), 2);
+  assert.deepEqual(turn2, [ids[2], ids[3]], "window 1: next two fresh");
+  // 窗口 2 = 前两轮的并集（真实流程里注入层会把最近 N 轮的 id 合成一个集合）
+  const turn3 = call(new Set([...turn1, ...turn2]), 2);
+  // 旧上限（maxItems×2 = 4）下池子只有 m0..m3，第三轮 fresh 为空 → 只能回填
+  // m0/m1（强制重复）。池子扩到 6 后，m4/m5 仍在箱内可被轮换换上来。
+  assert.deepEqual(turn3, [ids[4], ids[5]], "window 2: pool grew with the window, no forced repeat");
+  store.close();
+});