@modusensus/dsh-mneme 0.8.14 → 0.8.16

package/test/inject-recall.test.js

@@ -1,105 +1,144 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-// #217 增量（2026-09-19 拍板）：注入是曝光型访问事件，注入终选集落
-// mode='inject' 审计行（跟随 recallRecordDefault；空选不记）。留痕与消费
-// 解耦：heatEnabled=false 时行照写，touch（heat 消费侧）不发生。
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  // 与 index.js 相同的接线：审计记账 → recall_runs（best effort）
-  service.setRecallRecorder((recall) => {
-    store.saveRecallRun({
-      query: recall.query,
-      mode: recall.mode,
-      topK: recall.topK,
-      threshold: recall.threshold ?? null,
-      candidates: recall.candidates ?? [],
-      created_at: recall.createdAt
-    });
-  });
-  return { store, service };
-}
-
-const injectRow = (store) =>
-  store.listRecallRunsSince(new Date(Date.now() - 86400000).toISOString())
-    .rows.find((r) => r.mode === "inject");
-
-test("注入落账：终选集写一行 mode='inject'，candidates 为实际注入条目", () => {
-  const { store, service } = setup();
-  service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
-  service.saveWithDedupe({ type: "decision", title: "乙", content: "内容乙", importance: 3 });
-  const selected = service.injectCandidates({ maxItems: 5 });
-  assert.ok(selected.length >= 2);
-  const row = injectRow(store);
-  assert.ok(row, "注入应落一行审计");
-  assert.equal(row.mode, "inject");
-  // recall_runs.query 是 NOT NULL（store.js:61）：注入无查询词，用空串而非 null
-  assert.equal(row.query, "");
-  assert.deepEqual(row.candidates.map((c) => c.id), selected.map((m) => m.id));
-  store.close();
-});
-
-test("recallRecordDefault=false 不落账（与检索侧同门）", () => {
-  const { store, service } = setup({ recallRecordDefault: false });
-  service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
-  service.injectCandidates({ maxItems: 5 });
-  assert.equal(injectRow(store), undefined);
-  store.close();
-});
-
-test("空选不落账（没有访问发生）", () => {
-  const { store, service } = setup();
-  service.injectCandidates({ maxItems: 5 });
-  assert.equal(injectRow(store), undefined);
-  store.close();
-});
-
-test("留痕与消费解耦：heat 关闭时行照写、touch 不发生", () => {
-  // 显式 false = 生产 config 经 resolveConfig 后的默认值；touchRecalled 的
-  // 门控是 === false 才跳过（service.js:515）
-  const { store, service } = setup({ heatEnabled: false });
-  const m = service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 }).memory;
-  const before = store.getById(m.id).last_accessed_at ?? null;
-  service.injectCandidates({ maxItems: 5 });
-  assert.ok(injectRow(store), "heat 关闭时注入行仍照写");
-  assert.equal(store.getById(m.id).last_accessed_at ?? null, before, "touch 属 heat 消费侧，不发生");
-  store.close();
-});
-
-test("聚合：注入候选计入零曝光判定，注入口径单独报数", () => {
-  const { store, service } = setup();
-  service.saveWithDedupe({ type: "decision", title: "被注入", content: "被注入候选的内容说明", importance: 4 });
-  // importance 2 低于注入阈值 3：活跃但不进注入候选 → 零曝光 → 僵尸
-  service.saveWithDedupe({ type: "decision", title: "没动静", content: "低重要度不进注入候选的内容", importance: 2 });
-  // 回拨 created_at 避开 nowIso 同毫秒单调顶推的 1ms 豁免边界：刚写入的记忆
-  // 可能比 recallStats 的 Date.now() 晚 1ms，exemptDays:0 时会落进豁免桶
-  // （宁漏勿误伤），断言就变成看运气。回拨到 10 天前，判定确定性成立。
-  const old = new Date(Date.now() - 10 * 86400000).toISOString();
-  for (const m of store.all()) {
-    store.db.prepare("UPDATE memories SET created_at = ? WHERE id = ?").run(old, m.id);
-  }
-  service.injectCandidates({ maxItems: 5 });
-  const stats = service.recallStats({ windowDays: 30, exemptDays: 0 });
-  assert.equal(stats.injection.runs, 1);
-  assert.ok(stats.injection.injectedCount >= 1);
-  assert.equal(stats.zombie.activeCount, 2);
-  assert.equal(stats.zombie.zombieCount, 1, "被注入的不算僵尸（注入=曝光），未进候选的计僵尸");
-  store.close();
-});
-
-test("slotFillRate = 注入条数 / (轮数 × 槽位数)", () => {
-  const { store, service } = setup();
-  for (let i = 0; i < 3; i++) {
-    service.saveWithDedupe({ type: "decision", title: `t${i}`, content: "x", importance: 4 });
-  }
-  service.injectCandidates({ maxItems: 5 });
-  const stats = service.recallStats({ windowDays: 30, exemptDays: 0, maxInjectSlots: 4 });
-  assert.equal(stats.injection.runs, 1);
-  assert.equal(stats.injection.injectedCount, 3);
-  assert.equal(stats.injection.slotFillRate, 3 / 4);
-  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";
+
+// #217 增量（2026-09-19 拍板）：注入是曝光型访问事件，注入终选集落
+// mode='inject' 审计行（跟随 recallRecordDefault；空选不记）。留痕与消费
+// 解耦：heatEnabled=false 时行照写，touch（heat 消费侧）不发生。
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  // 与 index.js 相同的接线：审计记账 → recall_runs（best effort）
+  service.setRecallRecorder((recall) => {
+    store.saveRecallRun({
+      query: recall.query,
+      mode: recall.mode,
+      topK: recall.topK,
+      threshold: recall.threshold ?? null,
+      candidates: recall.candidates ?? [],
+      created_at: recall.createdAt
+    });
+  });
+  return { store, service };
+}
+
+const injectRow = (store) =>
+  store.listRecallRunsSince(new Date(Date.now() - 86400000).toISOString())
+    .rows.find((r) => r.mode === "inject");
+
+test("注入落账：终选集写一行 mode='inject'，candidates 为实际注入条目", () => {
+  const { store, service } = setup();
+  service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
+  service.saveWithDedupe({ type: "decision", title: "乙", content: "内容乙", importance: 3 });
+  const selected = service.injectCandidates({ maxItems: 5 });
+  assert.ok(selected.length >= 2);
+  const row = injectRow(store);
+  assert.ok(row, "注入应落一行审计");
+  assert.equal(row.mode, "inject");
+  // recall_runs.query 是 NOT NULL（store.js:61）：注入无查询词，用空串而非 null
+  assert.equal(row.query, "");
+  assert.deepEqual(row.candidates.map((c) => c.id), selected.map((m) => m.id));
+  store.close();
+});
+
+test("recallRecordDefault=false 不落账（与检索侧同门）", () => {
+  const { store, service } = setup({ recallRecordDefault: false });
+  service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
+  service.injectCandidates({ maxItems: 5 });
+  assert.equal(injectRow(store), undefined);
+  store.close();
+});
+
+test("空选不落账（没有访问发生）", () => {
+  const { store, service } = setup();
+  service.injectCandidates({ maxItems: 5 });
+  assert.equal(injectRow(store), undefined);
+  store.close();
+});
+
+test("留痕与消费解耦：heat 关闭时行照写、touch 不发生", () => {
+  // 显式 false = 生产 config 经 resolveConfig 后的默认值；touchRecalled 的
+  // 门控是 === false 才跳过（service.js:515）
+  const { store, service } = setup({ heatEnabled: false });
+  const m = service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 }).memory;
+  const before = store.getById(m.id).last_accessed_at ?? null;
+  service.injectCandidates({ maxItems: 5 });
+  assert.ok(injectRow(store), "heat 关闭时注入行仍照写");
+  assert.equal(store.getById(m.id).last_accessed_at ?? null, before, "touch 属 heat 消费侧，不发生");
+  store.close();
+});
+
+test("聚合：注入候选计入零曝光判定，注入口径单独报数", () => {
+  const { store, service } = setup();
+  service.saveWithDedupe({ type: "decision", title: "被注入", content: "被注入候选的内容说明", importance: 4 });
+  // importance 2 低于注入阈值 3：活跃但不进注入候选 → 零曝光 → 僵尸
+  service.saveWithDedupe({ type: "decision", title: "没动静", content: "低重要度不进注入候选的内容", importance: 2 });
+  // 回拨 created_at 避开 nowIso 同毫秒单调顶推的 1ms 豁免边界：刚写入的记忆
+  // 可能比 recallStats 的 Date.now() 晚 1ms，exemptDays:0 时会落进豁免桶
+  // （宁漏勿误伤），断言就变成看运气。回拨到 10 天前，判定确定性成立。
+  const old = new Date(Date.now() - 10 * 86400000).toISOString();
+  for (const m of store.all()) {
+    store.db.prepare("UPDATE memories SET created_at = ? WHERE id = ?").run(old, m.id);
+  }
+  service.injectCandidates({ maxItems: 5 });
+  const stats = service.recallStats({ windowDays: 30, exemptDays: 0 });
+  assert.equal(stats.injection.runs, 1);
+  assert.ok(stats.injection.injectedCount >= 1);
+  assert.equal(stats.zombie.activeCount, 2);
+  assert.equal(stats.zombie.zombieCount, 1, "被注入的不算僵尸（注入=曝光），未进候选的计僵尸");
+  store.close();
+});
+
+test("slotFillRate = 注入条数 / (轮数 × 槽位数)", () => {
+  const { store, service } = setup();
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "decision", title: `t${i}`, content: "x", importance: 4 });
+  }
+  service.injectCandidates({ maxItems: 5 });
+  const stats = service.recallStats({ windowDays: 30, exemptDays: 0, maxInjectSlots: 4 });
+  assert.equal(stats.injection.runs, 1);
+  assert.equal(stats.injection.injectedCount, 3);
+  assert.equal(stats.injection.slotFillRate, 3 / 4);
+  store.close();
+});
+
+// #369：history 曾被注入白名单挡在门外（蒸馏产得出、注入收不进）。这两条断言分
+// 别锁「收编生效」与「重要度闸门对 history 不豁免」——后者一旦失效，短流水账会
+// 直接挤掉决策类条目，那才是这个改动真正的风险面。
+test("#369: history 进注入候选池", () => {
+  const { service } = setup();
+  service.saveWithDedupe({ type: "history", title: "切到暗色主题", content: "用户本次会话把界面切成暗色主题", importance: 4 });
+  const titles = service.injectCandidates({ maxItems: 5 }).map((m) => m.title);
+  assert.ok(titles.includes("切到暗色主题"), "importance>=3 的 history 应进注入候选");
+});
+
+test("#369: 低于重要度闸门的 history 不得例外放行", () => {
+  const { service } = setup();
+  service.saveWithDedupe({ type: "history", title: "打开过一次终端", content: "用户中途打开过一次终端", importance: 2 });
+  const titles = service.injectCandidates({ maxItems: 5 }).map((m) => m.title);
+  assert.ok(!titles.includes("打开过一次终端"), "history 不是 summary/preference，闸门照样生效");
+});
+
+// pattern 只由手工写入，却已被 dreamMergeGuard 列为长保留受保护类型——巩固层当资产
+// 护住、注入面一次不给看是同一条口径的两头不一致。这条锁它进池。
+test("#369: 手写的 pattern 进注入候选池", () => {
+  const { service } = setup();
+  service.saveWithDedupe({ type: "pattern", title: "重复字符串先抽共用模块", content: "多处重复的截断逻辑先收拢成共用模块，再改调用方", importance: 5 });
+  const titles = service.injectCandidates({ maxItems: 5 }).map((m) => m.title);
+  assert.ok(titles.includes("重复字符串先抽共用模块"), "importance>=3 的 pattern 应进注入候选");
+});
+
+// CodeRabbit on PR #404：语义缓存回填分支曾独漏重要度门槛（向量路与 BM25 路都带）。
+// 一正一反：反向锁「低于闸门的行走缓存也不许进池」，正向锁「达标的照常进池」，
+// 免得断言退化成常量真；缓存没被灌进来时正向那条会先红，用例不会空压。
+test("#369: 语义缓存回填同样受重要度闸门约束", async () => {
+  const { service } = setup();
+  const low = service.saveWithDedupe({ type: "history", title: "终端开了一次", content: "用户中途打开过一次终端做检查", importance: 2 });
+  const high = service.saveWithDedupe({ type: "history", title: "终端方案定案", content: "用户终端接入方案已定案并验证", importance: 4 });
+  await service.searchMemories("终端", { mode: "keyword", useRerank: false, recordRecall: false });
+  const ids = service.injectCandidates({ query: "终端", maxItems: 5 }).map((m) => m.id);
+  assert.ok(ids.includes(high.memory.id), "i4 的 history 应经缓存回填进池（正向对照）");
+  assert.equal(ids.includes(low.memory.id), false, "低于闸门的行不得借语义缓存绕开门槛");
+});

package/test/inject-rotation.test.js

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