@modusensus/dsh-mneme 0.8.0 → 0.8.2

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/src/version-check.js

@@ -0,0 +1,122 @@
+// 版本自检（issue #174 后续，2026-09-15 拍板）：独立插件不把「用户在用哪个
+// 版本」托付给插件市场——市场收录有 ~26h 年龄闸门 + 30min 缓存，且安装时
+// 精确指定过版本的 profile 会被 pnpm 钉子挡住（update 尊重既有 semver 范围，
+// 永不跨 minor/major，#174 的报障者正是这样用着 0.7.32 的行为模型来报 bug）。
+//
+// 本模块只做三件事：
+//   1. 向 npm registry 查 @modusensus/dsh-mneme 的 latest dist-tag（带 TTL
+//      缓存 + 超时 + 全失败静默——离线/被墙/registry 异常都返回 null，调用方
+//      据 null 渲染「未知」，前端不打扰）；
+//   2. 与运行版本做纯函数比对（classify）；
+//   3. 对外暴露 registry URL 白名单校验（validateRegistryUrl）——发请求前
+//      强制 https + 精确 host，构造上排除本机与内网地址。
+import { readFileSync } from "node:fs";
+
+// 运行版本：src/ 与 lib/ 都在插件根下一层，相对 import.meta.url 解析一致；
+// 读取失败（打包/受限环境）降级 "unknown"，横幅随之静默。
+const PACKAGE_VERSION = (() => {
+  try {
+    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+})();
+
+// registry 查询地址是模块常量而非用户输入；validateRegistryUrl 仍作为发请求
+// 前的强制闸（构造上即排除非 https 与非白名单 host，双保险且可单测）。
+const REGISTRY_URL = "https://registry.npmjs.org/@modusensus%2Fdsh-mneme/latest";
+const REGISTRY_HOST = "registry.npmjs.org";
+// 市场收录本身有 ~1 天年龄闸门，1h 的 registry 缓存远低于该粒度，足够新鲜。
+const CACHE_TTL_MS = 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 5000;
+
+// 精确 host 白名单：协议必须 https，且 host 逐字等于 registry.npmjs.org。
+// 这一条即构造性排除本机回环、私有网段与保留地址——不做任何
+// 「看起来像公网」的宽松判断，将来换源必须显式改这里的常量。
+export function validateRegistryUrl(candidate) {
+  let url;
+  try {
+    url = new URL(candidate);
+  } catch {
+    return false;
+  }
+  return url.protocol === "https:" && url.hostname === REGISTRY_HOST;
+}
+
+/** 解析 `x.y.z` / `x.y.z-后缀` 为可比较结构；解析失败返回 null。 */
+function parseVersion(text) {
+  if (typeof text !== "string") return null;
+  const match = text.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    // 有 prerelease 后缀的同号版本视为更旧（0.9.0-rc.1 < 0.9.0）。
+    prerelease: match[4] !== undefined
+  };
+}
+
+/**
+ * 三元组语义化比较：a<b → -1，a>b → 1，无法比较 → null（调用方归入 unknown）。
+ * 仅比较数字部分；数字相等时，带 prerelease 的一方更旧（0.9.0-rc.1 < 0.9.0），
+ * 两侧都带则视为同版——横幅只关心「是否落后于 latest」，不追求完整 semver 序。
+ */
+export function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return null;
+  for (const key of ["major", "minor", "patch"]) {
+    if (va[key] !== vb[key]) return va[key] < vb[key] ? -1 : 1;
+  }
+  if (va.prerelease !== vb.prerelease) return va.prerelease ? -1 : 1;
+  return 0;
+}
+
+/**
+ * 运行版本 vs registry latest 的展示归类。latest 为 null（查询失败/离线）
+ * 或任一侧解析失败时归 unknown——前端对 unknown 完全静默。
+ */
+export function classify(version, latest) {
+  const cmp = compareVersions(version, latest);
+  if (cmp === null) return "unknown";
+  if (cmp < 0) return "outdated";
+  if (cmp > 0) return "ahead";
+  return "up-to-date";
+}
+
+// 模块级缓存：面板可能多处/多次拉取，TTL 内一律复用，不重复打 registry。
+// at 用 -Infinity 作「从未拉取」哨兵：任何时钟下 now-at 都是正无穷，首轮
+// 必然真实请求（测试的假时钟从 0 起也不会被误判成新鲜缓存）。
+let cache = { at: -Infinity, latest: null };
+
+/**
+ * 查询 registry latest。TTL 内直接命中缓存；任何失败（网络/超时/非 2xx/
+ * 响应形状不对/URL 校验不过）都静默返回 null——版本提示是锦上添花，绝不
+ * 让它成为新的故障面。失败不写缓存：TTL 起点保持旧值，下次调用立刻重试。
+ */
+export async function fetchLatestVersion({ fetchImpl = typeof fetch === "function" ? fetch : () => Promise.reject(new Error("no fetch")), now = Date.now } = {}) {
+  if (now() - cache.at < CACHE_TTL_MS) return cache.latest;
+  if (!validateRegistryUrl(REGISTRY_URL)) return null;
+  let manifest;
+  try {
+    const response = await fetchImpl(REGISTRY_URL, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) return null;
+    manifest = await response.json();
+  } catch {
+    return null;
+  }
+  const latest = typeof manifest?.version === "string" && manifest.version ? manifest.version : null;
+  cache = { at: now(), latest };
+  return latest;
+}
+
+/** 仅供测试：清空模块级缓存与时间戳。 */
+export function resetCacheForTest() {
+  cache = { at: -Infinity, latest: null };
+}
+
+export { PACKAGE_VERSION, REGISTRY_URL, CACHE_TTL_MS };

package/test/api.test.js

@@ -1394,6 +1394,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/conflict-freeze.test.js

@@ -111,13 +111,23 @@ test("store: countConflictPending 只统计未决行", () => {
   store.close();
 });
 
-test("store: 已解决的同一对后续可再次 pending", () => {
+test("store: 已解决的同一对在内容变化后才可再次 pending（issue #170 复核项 4）", async () => {
   const store = openStore();
-  const p1 = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "r" });
+  const a = store.save({ type: "project", title: "对A", content: "内容A" });
+  const b = store.save({ type: "project", title: "对B", content: "内容B" });
+  const p1 = store.saveConflictPending({ memory_a: a.id, memory_b: b.id, reason: "r" });
   store.resolveConflictPending(p1.id, { winner: "a" });
-  // 去重只看未决行 —— 已解决后再现同一对应产生新 pending
-  const p2 = store.saveConflictPending({ memory_a: "b", memory_b: "a", reason: "again" });
-  assert.notEqual(p2.id, p1.id, "已解决行不参与去重");
+  // 内容未变 → 已裁决对不重新入队：「保留双方」是有效决定，不是待办。
+  const suppressed = store.saveConflictPending({ memory_a: b.id, memory_b: a.id, reason: "again" });
+  assert.equal(suppressed, undefined, "未变化的已裁决对被抑制");
+  assert.equal(store.countConflictPending(), 0);
+  // 任一侧被改过（updated_at 晚于 resolved_at）→ 重新入队产生新 pending。
+  // 留真实时间间隔：updated_at/resolved_at 毫秒精度，同毫秒算未变。
+  await new Promise((resolve) => setTimeout(resolve, 5));
+  store.update(a.id, { content: "内容A（改）" });
+  const p2 = store.saveConflictPending({ memory_a: b.id, memory_b: a.id, reason: "changed" });
+  assert.ok(p2, "内容变化后的对重新入队");
+  assert.notEqual(p2.id, p1.id, "新 pending 是新行");
   assert.equal(p2.resolved_at, undefined);
   assert.equal(store.countConflictPending(), 1);
   store.close();

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