@modusensus/dsh-mneme 0.8.1 → 0.8.3

package/src/tools.js

@@ -39,6 +39,8 @@ const MEMORY_ITEM_SCHEMA = {
     updated_at: { type: "string", required: true }
   }
 };
+// 导出供回归测试断言 memory_get 与共享 schema 同源（#184 防漂移护栏）。
+export { MEMORY_ITEM_SCHEMA };
 
 // v0.8.0 A2：occurred 时间窗参数 → store 过滤选项（list/count 同口径）；
 // 未传参返回空对象，既有调用方不受影响。（A3 复核：此处入参仅含 occurred 边界。）
@@ -277,25 +279,10 @@ export function createTools(ctx, service, config, embedder) {
           type: "object",
           additionalProperties: false,
           properties: {
-            memory: {
-              type: "object",
-              additionalProperties: false,
-              properties: {
-                id: { type: "string", required: true },
-                title: { type: "string", required: true },
-                type: { type: "string", required: true },
-                importance: { type: "integer", required: true },
-                tags: { type: "array", items: { type: "string" } },
-                content: { type: "string", required: true },
-                source: { type: "string" },
-                agent_scope: { type: "string" },
-                workspace_scope: { type: "string" },
-                sensitivity: { type: "string" },
-                occurred_at: { type: "string" },
-                created_at: { type: "string" },
-                updated_at: { type: "string" }
-              }
-            }
+            // 与 memory_search / memory_list 共用同一份 item schema——DTO 由
+            // toApiList 统一产出，内联副本曾漏掉 v0.8.1 的 scope 来源三键，
+            // 任何被标注过的行都过不了 in-process 校验（#184）。
+            memory: MEMORY_ITEM_SCHEMA
           }
         },
         render: (_args, value) => {

package/src/vector-index.js

@@ -56,14 +56,8 @@ export function createVectorIndex({ store, logger }) {
 
     /** Read one memory's cached vector; undefined when none/parse failure. */
     getEmbedding(id) {
-      const row = db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
-      if (!row?.embedding) return undefined;
-      try {
-        const v = JSON.parse(row.embedding);
-        return Array.isArray(v) && v.length ? v : undefined;
-      } catch {
-        return undefined;
-      }
+      // Issue #202：走 store 的解析缓存（与 searchVector/getEmbeddings 同源）。
+      return store.getParsedEmbedding(id);
     },
 
     /** Cosine search over embedded rows; results carry a 0..1 score. */

package/test/api.test.js

@@ -644,17 +644,18 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(res.statusCode, 200);
   const data = JSON.parse(res.body);
   assert.deepEqual(data.overrides, {});
-  // effective 覆盖全部 51 个白名单键（含 v0.7.20 heatEnabled、Issue #89 新增
+  // effective 覆盖全部 52 个白名单键（含 v0.7.20 heatEnabled、Issue #89 新增
   // dreamSkipInvalid/allowCrossTypeMerge/dreamMinIntervalMinutes、面板可调的
   // dreamMaxTokens、睡眠路由 sleepProvider/sleepModel、PR1 新增的
   // recallFusion/signalTransparency、issue #109 新增的实体抽取路由
   // entityExtractionProvider/entityExtractionModel/entityExtractionReasoning、
   // issue #127 新增的 summarize 五键、issue #126 新增的 sleepActionSet，
   // 以及 issue #125 新增的候选集三键、issue #17（v0.8.0 A1/A3）新增的
-  // scopeEnabled/strictScope），未覆盖时取 bundle 配置的解析默认值；
+  // scopeEnabled/strictScope、issue #194 新增的 resilientModelDownload），
+  // 未覆盖时取 bundle 配置的解析默认值；
   // dreamProvider/dreamModel 无 schema 默认值（Config({}) 解析为 undefined），
-  // 不编造给前端 → 53 - 2 = 51
-  assert.equal(Object.keys(data.effective).length, 51);
+  // 不编造给前端 → 54 - 2 = 52
+  assert.equal(Object.keys(data.effective).length, 52);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);
@@ -1394,6 +1395,11 @@ test("POST /api/dsh-mneme/test-model succeeds and reports reply + latency", asyn
   assert.equal(data.modelId, "deepseek:deepseek-chat", "modelId reports the probed route");
   assert.equal(MOCK_LLM.lastOptions.provider, "deepseek");
   assert.equal(MOCK_LLM.lastOptions.purpose, "dsh-mneme-connectivity-test");
+  // 回归：探测必须是一条 user 消息（带 source）。system-only 对话自
+  // 0.1.6-alpha.1 起被官方 API 整单拒绝（「messages: at least one message
+  // is required」），探测按钮会 502。
+  assert.equal(MOCK_LLM.lastOptions.messages[0].role, "user");
+  assert.equal(MOCK_LLM.lastOptions.messages[0].source?.kind, "plugin");
   assert.equal("reasoningEffort" in MOCK_LLM.lastOptions, false, "no effort configured -> field omitted");
 });
 

package/test/dream-archive-guardrail.test.js

@@ -0,0 +1,116 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler, validateDecisions } from "../src/dream.js";
+import { mockCtx } from "./helpers/dream-mock.js";
+
+// 回归（issue #104 方向 2）：archive 决策语义越界 + 批量大扫除。
+// 实测事故：一轮 12 条互不相关主题被批量 archive，LLM 自述理由是「价值判断」
+// （对核心知识库长期参考价值较低、保持整洁和高信噪比），而提示词对 archive 的
+// 定义是「重复或过时」；12 条中 8 条疑似误伤，含 rejected_solution ×2、
+// constraint ×3、pitfall ×1 等长保留类型——这些类型的存在意义即长期保存，
+// 误归档损失最大。修复：
+//   1. 类型护栏——长保留类型（preference / pattern / rejected_solution /
+//      constraint / pitfall）的 archive 必须命中「重复/过时」类理由，否则单条
+//      跳过记 skipped（run 记 degraded），绝不整单拒绝；
+//   2. 批量上限——单轮 archive 条数封顶（dreamMaxArchivePerRun，默认 8），
+//      与 update 上限同类的全局闸门：skipInvalid 也不豁免，超限整单拒绝；
+//   3. 提示词同步强化（辅助防线）。
+// conflict 裁决的败者归档不经过 archive action，不受护栏影响。
+
+function snap(entries) {
+  return new Map(entries.map(([id, type]) => [id, { id, type, title: `t-${id}`, content: `c-${id}`, importance: 3, archived: false, forgotten: false }]));
+}
+
+// ---------------------------------------------------------- 类型护栏（纯函数）
+
+test("#104-2: long-retention archive with a duplicate/outdated rationale passes", () => {
+  const s = snap([["p1", "preference"], ["rs1", "rejected_solution"]]);
+  const decisions = [
+    { action: "archive", ids: ["p1"], reason: "与后续偏好重复，已被新条目取代" },
+    { action: "archive", ids: ["rs1"], reason: "duplicate of an earlier rejected approach (stale)" }
+  ];
+  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, true);
+  assert.deepEqual(skipped, [], "duplicate/outdated rationales are accepted");
+});
+
+test("#104-2: long-retention archive with a value-judgment rationale is skipped (run degrades)", () => {
+  const s = snap([["c1", "constraint"], ["k1", "project"]]);
+  const decisions = [
+    { action: "archive", ids: ["c1"], reason: "多为一次性调试细节，对核心知识库长期参考价值较低，保持整洁和高信噪比" },
+    { action: "archive", ids: ["k1"], reason: "价值较低" }
+  ];
+  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, true, "guard skips the single decision instead of rejecting the run");
+  assert.equal(skipped.length, 1, "only the guarded long-retention archive is skipped");
+  assert.match(skipped[0].error, /long-retention type\(s\) constraint/);
+  assert.match(skipped[0].error, /duplicate\/outdated rationale/);
+  // 幸存列表：普通类型照常归档，c1 被跳过后由隐式 keep 补位
+  assert.deepEqual(decisions.map((d) => d.action), ["archive", "keep"]);
+});
+
+test("#104-2: plain-type archive needs no rationale keywords (guard boundary)", () => {
+  const s = snap([["d1", "decision"], ["f1", "factor"]]);
+  const decisions = [
+    { action: "archive", ids: ["d1"], reason: "阶段性结论，已沉淀进项目记忆" },
+    { action: "archive", ids: ["f1"], reason: "清理" }
+  ];
+  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, true);
+  assert.deepEqual(skipped, [], "guard applies to long-retention types only");
+});
+
+test("#104-2: conflict-loser archive is exempt (adjudication, not archive action)", () => {
+  const s = snap([["w", "preference"], ["l", "preference"]]);
+  const decisions = [{ action: "conflict", winner: "w", loser: "l", reason: "内容矛盾，保留更新的信息" }];
+  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, true);
+  assert.deepEqual(skipped, [], "conflict adjudication does not go through the archive guard");
+});
+
+// ---------------------------------------------------------- 批量上限（纯函数）
+
+test("#104-2: archive count above the cap rejects the whole batch (global gate)", () => {
+  const entries = Array.from({ length: 10 }, (_, i) => [`d${i}`, "decision"]);
+  const s = snap(entries);
+  const decisions = entries.map(([id]) => ({ action: "archive", ids: [id], reason: "stale" }));
+  const { ok, errors } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, false, "9 archives > default cap 8 → reject even under skipInvalid");
+  assert.ok(errors.some((e) => e.includes("too many archive decisions")), `cap error present, got: ${errors.join("; ")}`);
+});
+
+test("#104-2: archive cap is configurable", () => {
+  const entries = Array.from({ length: 10 }, (_, i) => [`d${i}`, "decision"]);
+  const s = snap(entries);
+  const decisions = entries.map(([id]) => ({ action: "archive", ids: [id], reason: "stale" }));
+  const { ok, errors } = validateDecisions(decisions, s, { skipInvalid: true, maxArchivePerRun: 20 });
+  assert.equal(ok, true, `raised cap lets the sweep through, got: ${errors.join("; ")}`);
+});
+
+// ---------------------------------------------------------- 端到端（runDream）
+
+test("#104-2: runDream skips a value-judgment archive of a long-retention type and lands the rest", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  service.saveWithDedupe({ type: "project", title: "旧项目", content: "已完结并被取代", importance: 3 });
+  service.saveWithDedupe({ type: "constraint", title: "接口约束", content: "v1 接口只能串行调用", importance: 3 });
+  const ctx = mockCtx({
+    onConsolidation: (listText) => {
+      const entries = [...listText.matchAll(/id=([^\s|]+)\s*\|\s*type=(\w+)/g)].map((m) => ({ id: m[1], type: m[2] }));
+      const projectId = entries.find((e) => e.type === "project").id;
+      const constraintId = entries.find((e) => e.type === "constraint").id;
+      return JSON.stringify([
+        { action: "archive", ids: [projectId], reason: "重复或过时" },
+        { action: "archive", ids: [constraintId], reason: "保持知识库整洁，参考价值较低" }
+      ]);
+    }
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.notEqual(result.status, "failed", "guard skips instead of failing the run");
+  const constraint = service.all().find((m) => m.type === "constraint");
+  assert.equal(constraint.archived, false, "value-judgment archive of a long-retention type must not land");
+  store.close();
+});

package/test/dream-coverage-degrade.test.js

@@ -0,0 +1,86 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler, validateDecisions } from "../src/dream.js";
+import { mockCtx } from "./helpers/dream-mock.js";
+
+// 回归（issue #104 方向 1）：dreamMinExplicitCoverage 覆盖率护栏误伤「挑重点」
+// 型输出。提示词明文要求「无问题的条目无需输出」（lang.js 硬性规则），模型
+// 只显式决策少数条目是提示词要求的行为；但护栏把显式覆盖率 < 下限判成
+// 「截断 → 隐式 keep 洗白」整单拒绝——heptaspirit 实测官方路由 + 强模型也
+// 天天命中（81 轮 failed 全是 coverage，applied=0，LLM 调用本身已成功）。
+// 修复：coverage 不足降级为 degraded（合法子集照常应用 + 未提及条目隐式
+// keep），降级理由落库 outcome.degradations；护栏以状态暴露而非一票否决。
+// 明确异常信号（create 上限等）保持整单拒绝不变；dreamImplicitKeep=false 的
+// 严格模式不受影响。
+
+function snapshot(ids, type = "project") {
+  return new Map(ids.map((id, i) => [id, { id, type, title: `t${i}`, content: `c${i}`, importance: 3, archived: false, forgotten: false }]));
+}
+
+// ---------------------------------------------------------- validateDecisions
+
+test("#104-1: coverage shortfall degrades — ok:true + reason surfaced, implicit keeps fill", () => {
+  const snap = snapshot(["a", "b", "c", "d"]);
+  const decisions = [{ action: "update", ids: ["a"], title: "t-new", content: "c-new" }];
+  const { ok, errors, coverageShortfall } = validateDecisions(decisions, snap, {
+    dreamImplicitKeep: true,
+    dreamMinExplicitCoverage: 0.5,
+    skipInvalid: true
+  });
+  assert.equal(ok, true, "valid subset is applied instead of whole-order rejection");
+  assert.deepEqual(errors, [], "coverage shortfall is not a per-decision error");
+  assert.match(String(coverageShortfall), /coverage/, "degradation reason surfaced for audit");
+  assert.equal(decisions.length, 4, "unclaimed ids filled with implicit keeps");
+});
+
+test("#104-1: sufficient coverage carries no shortfall marker", () => {
+  const snap = snapshot(["a", "b"]);
+  const decisions = [{ action: "archive", ids: ["a"], reason: "stale" }, { action: "keep", ids: ["b"] }];
+  const { ok, coverageShortfall } = validateDecisions(decisions, snap, {
+    dreamImplicitKeep: true,
+    dreamMinExplicitCoverage: 0.5
+  });
+  assert.equal(ok, true);
+  assert.equal(coverageShortfall ?? null, null);
+});
+
+test("#104-1: strict mode (implicitKeep=false) unchanged — missing ids still reject", () => {
+  const snap = snapshot(["a", "b"]);
+  const decisions = [{ action: "keep", ids: ["a"] }];
+  const { ok } = validateDecisions(decisions, snap, { dreamImplicitKeep: false });
+  assert.equal(ok, false, "strict mode keeps whole-order rejection");
+});
+
+// ---------------------------------------------------------- runDream 端到端
+
+test("#104-1: runDream records degraded (not failed) with the coverage reason in the run row", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  for (let i = 0; i < 20; i++) {
+    service.saveWithDedupe({ type: "project", title: `主题${i}`, content: `内容${i}`, importance: 3 });
+  }
+  // 只显式决策 1/20 = 5%（< 默认下限 50%）——提示词要求的「挑重点」形态
+  const ctx = mockCtx({
+    onConsolidation: (listText) => {
+      const ids = [...listText.matchAll(/id=([^\s|]+)\s*\|\s*type=(\w+)/g)].map((m) => m[1]);
+      return JSON.stringify([{ action: "archive", ids: [ids[0]], reason: "stale variant" }]);
+    }
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek",
+    dreamModel: "deepseek-chat",
+    dreamMinExplicitCoverage: 0.5
+  });
+  assert.equal(result.status, "degraded", "coverage shortfall degrades the run, not rejects it");
+  assert.equal(result.ok, true, "valid subset absorbed — scheduler baseline advances");
+  assert.ok(result.applied >= 1, "the explicit decision was applied");
+
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.status, "degraded");
+  const degradations = run.outcome?.degradations ?? [];
+  assert.ok(degradations.some((s) => String(s).includes("coverage")), "coverage reason persisted in outcome.degradations");
+  store.close();
+});

package/test/dream.test.js

@@ -789,8 +789,10 @@ test("autoDream with 650 memories: sliding window truncates snapshot + implicit
     dreamProvider: "deepseek", dreamModel: "deepseek-chat", dreamMaxSnapshotSize: 200,
     // mock only claims 20/200 = 10%; the implicit-keep coverage floor must be
     // lowered so this deliberate "tiny explicit claim" scenario still passes
-    // (it exercises the window + keep-fill, not the coverage guard)
-    dreamMinExplicitCoverage: 0.1
+    // (it exercises the window + keep-fill, not the coverage guard). Same for
+    // the archive cap: 20 mock archives exceed the default 8 — #104 方向 2.
+    dreamMinExplicitCoverage: 0.1,
+    dreamMaxArchivePerRun: 20
   });
   assert.equal(result.ok, true, "run succeeds instead of 677-error rejection");
   assert.ok(result.applied > 0, "archive decisions applied");
@@ -807,16 +809,18 @@ test("autoDream with 650 memories: sliding window truncates snapshot + implicit
 
 // --- v0.4.4 fix: 残缺输出防洗白（显式覆盖率下限） + 严格模式透传 --------------
 
-test("validateDecisions rejects a truncated output whose explicit coverage is below the floor", () => {
+test("validateDecisions degrades a low-coverage valid output (Issue #104 方向 1)", () => {
   const snap = snapshot(["a", "b", "c", "d"]);
   const decisions = [{ action: "keep", ids: ["a"] }]; // claims 1/4 = 25%
-  const { ok, errors } = validateDecisions(decisions, snap, { dreamMinExplicitCoverage: 0.5 });
-  assert.equal(ok, false, "low explicit coverage rejects the whole list");
-  assert.ok(
-    errors.some((e) => e.includes("explicit decision coverage 25% < minimum 50%")),
-    `coverage error present, got: ${errors.join("; ")}`
+  const { ok, errors, coverageShortfall } = validateDecisions(decisions, snap, { dreamMinExplicitCoverage: 0.5 });
+  assert.equal(ok, true, "valid subset applies — coverage shortfall degrades instead of rejecting");
+  assert.deepEqual(errors, [], "shortfall is not a per-decision error");
+  assert.match(
+    String(coverageShortfall),
+    /explicit decision coverage 25% < minimum 50%/,
+    `coverage reason surfaced, got: ${coverageShortfall}`
   );
-  assert.equal(decisions.length, 1, "no keep-fill pushed on rejection (nothing washed white)");
+  assert.equal(decisions.length, 4, "implicit keeps fill the unclaimed ids");
 });
 
 test("validateDecisions covers the whole snapshot when explicit coverage meets the floor", () => {
@@ -1014,7 +1018,7 @@ test("validateDecisions skipInvalid: a single invalid decision is skipped, valid
   assert.ok(decisions.some((d) => d.action === "keep" && d.ids.includes("j")), "j auto-kept");
 });
 
-test("validateDecisions skipInvalid: an all-invalid batch still rejects (coverage floor guards truncation)", () => {
+test("validateDecisions skipInvalid: an all-invalid batch still rejects (zero-survivor guard, #104 方向 1 重审后保留)", () => {
   const snap = new Map([
     ["p", { id: "p", type: "preference", title: "语言", content: "中文", importance: 3, archived: false, forgotten: false }],
     ["j", { id: "j", type: "project", title: "插件", content: "内容", importance: 3, archived: false, forgotten: false }],
@@ -1029,7 +1033,7 @@ test("validateDecisions skipInvalid: an all-invalid batch still rejects (coverag
   const { ok, errors, skipped } = validateDecisions(decisions, snap, { skipInvalid: true });
   assert.equal(ok, false, "no valid decisions left → whole batch rejected");
   assert.equal(skipped.length, 2);
-  assert.ok(errors.some((e) => e.includes("coverage")), "coverage error present");
+  assert.ok(errors.some((e) => e.includes("nothing valid survived")), "zero-survivor guard error present");
   assert.equal(decisions.length, 2, "rejected batch left untouched (splice only on the success path)");
 });
 

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

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

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();
+});