@modusensus/dsh-mneme 0.8.1 → 0.8.2

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/llm-message-source.test.js

@@ -0,0 +1,177 @@
+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 } from "../src/dream.js";
+import { createSummarizer } from "../src/summarize.js";
+import { runSleep } from "../src/dream/sleep.js";
+import { extractEntities } from "../src/entities/extractor.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// 回归：dsh-llm 的消息契约要求每条消息带 source。provider 适配器会直接读
+// message.source.kind 来区分用户内容与工具结果（例如
+// @mars-sea/dsh-commandcode-provider 的 messagesToCC），缺字段时请求在序列化
+// 阶段就抛 "Cannot read properties of undefined (reading 'kind')"，四条 LLM 管线
+// （dream / sleep / summarize / entity extraction）全军覆没、耗时 0ms。
+// 这里用同等严格的桩驱动真实管线，任何新加的消息漏了 source 都会失败。
+function assertMessageSources(options) {
+  for (const message of options.messages ?? []) {
+    assert.equal(
+      message.source?.kind,
+      "plugin",
+      `LLM 消息缺 source（provider 会抛 TypeError）: ${message.role} / ${String(message.content?.[0]?.text ?? "").slice(0, 40)}`
+    );
+  }
+}
+
+const logger = { warn: () => {}, info: () => {} };
+
+function makeService() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+// dsh-llm chunk 形状与真实 provider 对齐：文本增量 + 终止 chunk。
+function reply(text, finish = { reason: { kind: "stop" } }) {
+  return (async function* () {
+    yield { type: "text-delta", index: 0, text };
+    yield { type: "finish", ...finish };
+  })();
+}
+
+// ---------------------------------------------------------------- dream
+
+test("dream: consolidation and summary messages carry source", async () => {
+  const { store, service } = makeService();
+  service.saveWithDedupe({ type: "project", title: "主题01", content: "规范内容", importance: 5 });
+  service.saveWithDedupe({ type: "project", title: "主题01·变体", content: "旧变体", importance: 3 });
+
+  const calls = [];
+  const ctx = {
+    logger,
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "source-model" }) },
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        assertMessageSources(options);
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        yield* reply(userText.startsWith("id=") ? "[]" : "记忆库总览：已巩固。");
+      }
+    }
+  };
+
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const run = await dream.runDream(ctx, service, {});
+  assert.equal(run.ok, true, "dream run succeeds against the strict provider stub");
+  assert.ok(calls.some((c) => c.purpose === "compaction"), "consolidation called the LLM");
+  assert.ok(calls.length >= 2, "consolidation + summary both called");
+  store.close();
+});
+
+// ---------------------------------------------------------------- summarize
+
+test("summarize: distilled transcript and prompt messages carry source", async () => {
+  const { store, service } = makeService();
+  const events = [];
+  const calls = [];
+  const ctx = {
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {};
+    },
+    logger,
+    llm: {
+      stream(options) {
+        calls.push(options);
+        assertMessageSources(options);
+        return reply("[]", { kind: "ok" });
+      }
+    }
+  };
+  createSummarizer(ctx, service, { autoSummarize: true });
+
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-source",
+    requestHeader: () => ({ config: { provider: "mock", model: "source-model" } }),
+    events: [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "帮我选型" }] } },
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(calls.length, 1, "summarization called the LLM");
+  store.close();
+});
+
+// ---------------------------------------------------------------- sleep
+
+test("sleep: conflict and pattern messages carry source", async () => {
+  const { store, service } = makeService();
+  const vectorIndex = createVectorIndex({ store });
+  const embedder = {
+    embedSingle: async () => [1, 0, 0],
+    embed: async () => [1, 0, 0],
+    schedule: () => {},
+    modelHash: "mock#1",
+    dimension: 3
+  };
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vectorIndex);
+  // 冲突候选要在向量索引里真有向量（同 sleep.test.js 的 seedConflictPair）；
+  // 同时给 pattern 阶段留下 2 条素材。
+  const a = service.saveWithDedupe({ type: "project", title: "主题X", content: "内容A 关于主题X", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "主题X副本", content: "内容B 关于主题X", importance: 3 }).memory;
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
+
+  const calls = [];
+  const ctx = {
+    logger,
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        assertMessageSources(options);
+        yield* reply("[]");
+      }
+    }
+  };
+  const config = {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 2,
+    sleepMaxPatternPerRun: 3
+  };
+  const result = await runSleep(ctx, service, config, logger, { embedder, vectorIndex }, null);
+
+  assert.ok(calls.some((c) => c.purpose === "sleep-conflict"), "conflict phase called the LLM");
+  assert.ok(calls.some((c) => c.purpose === "sleep-pattern"), "pattern phase called the LLM");
+  assert.ok(result.runId, "sleep run produced a receipt");
+  store.close();
+});
+
+// ---------------------------------------------------------------- entity extraction
+
+test("entity extraction: messages handed to the llm adapter carry source", async () => {
+  const { store, service } = makeService();
+  const memory = service.saveWithDedupe({ type: "project", title: "协作", content: "Alpha 与 Beta 一起干活", importance: 3 }).memory;
+
+  const calls = [];
+  const callLLM = async (messages) => {
+    calls.push(messages);
+    assertMessageSources({ messages });
+    return "[]";
+  };
+
+  await extractEntities(memory, { store, config: {}, callLLM, logger });
+
+  assert.equal(calls.length, 1, "extraction called the LLM adapter");
+  store.close();
+});

package/test/reranker-single-logit.test.js

@@ -0,0 +1,73 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { LocalReranker } from "../src/reranker.js";
+
+// 回归（issue #188）：Xenova/bge-reranker-base 是单 logit 交叉编码器——每个
+// (query, passage) 对只输出 1 个 logit。tc 策略此前在 cols===1 时把 l1 退化成
+// l0，sigmoid(l0 - l1) = sigmoid(0) = 0.5：所有候选分数恒为常量，重排静默失效
+// （不抛错、日志照常 ready、语义状态照常 reranker="ready"，只有分数是死的）。
+// 单 logit 头的正类概率是 sigmoid(logit)；sigmoid(l1 - l0) 只对双 logit 头
+// （num_labels=2 的导出，如 bge-reranker-v2-m3）成立。修复后按 cols 分支，
+// 两路各有回归；另加「分数全等 → warn 一次」的静默失效绊线。
+
+function sigmoid(x) {
+  return 1 / (1 + Math.exp(-x));
+}
+
+function candidates(ids) {
+  return ids.map((id) => ({ id, title: `T-${id}`, content: `C-${id}` }));
+}
+
+// 只支持 text-classification 的假引擎：cascade 先试 "rerank"（transformers
+// 4.2.0 无此任务，真机上也必然先失败），随后落到 tc。
+function makeTcFactory(dims, data) {
+  return async (task) => {
+    if (task === "rerank") throw new Error("unsupported task: rerank");
+    assert.equal(task, "text-classification");
+    return {
+      tokenizer: (texts, _opts) => ({ texts }),
+      model: async (inputs) => ({ logits: { dims, data: Float64Array.from(data.slice(0, inputs.texts.length * dims[1])) } })
+    };
+  };
+}
+
+test("#188: single-logit head scores sigmoid(logit) instead of constant 0.5", async () => {
+  // 报告的实测 logits：相关 -0.556、无关 -10.193，区分度近 10——模型判断得
+  // 很好，只是旧公式把它们全抹成 0.5000。
+  const r = new LocalReranker({
+    engineFactory: makeTcFactory([3, 1], [-0.5561, -10.193, 8.7])
+  });
+  await r.init();
+  const out = await r.rerank("查询", candidates(["rel", "noise", "hit"]));
+  // sigmoid(-0.5561)≈0.3645 保留；sigmoid(-10.193)≈3.7e-5 被 0.1 阈值滤掉；
+  // sigmoid(8.7)≈0.9998 居首。修复前三者全 0.5、顺序不变。
+  assert.deepEqual(out.map((x) => x.id), ["hit", "rel"]);
+  assert.ok(Math.abs(out[0].score - sigmoid(8.7)) < 1e-6, "hit = sigmoid(logit)");
+  assert.ok(Math.abs(out[1].score - sigmoid(-0.5561)) < 1e-6, "rel = sigmoid(logit)");
+  r.dispose();
+});
+
+test("#188: dual-logit head keeps softmax-positive-class semantics", async () => {
+  // l0=-2,l1=2 → sigmoid(4)；l0=1,l1=1.5 → sigmoid(0.5)——与原实现逐字节等价。
+  const r = new LocalReranker({
+    engineFactory: makeTcFactory([2, 2], [-2, 2, 1, 1.5])
+  });
+  await r.init();
+  const out = await r.rerank("查询", candidates(["a", "b"]));
+  assert.deepEqual(out.map((x) => x.id), ["a", "b"]);
+  assert.ok(Math.abs(out[0].score - sigmoid(4)) < 1e-6);
+  assert.ok(Math.abs(out[1].score - sigmoid(0.5)) < 1e-6);
+  r.dispose();
+});
+
+test("#188: constant-score batch warns once (silent-failure tripwire)", async () => {
+  const warns = [];
+  const r = new LocalReranker({
+    scorePair: async () => 0.5,
+    logger: { warn: (m) => warns.push(m), info: () => {} }
+  });
+  await r.rerank("查询", candidates(["a", "b", "c"]));
+  await r.rerank("查询", candidates(["a", "b", "c"]));
+  assert.equal(warns.length, 1, "constant-score batch warns exactly once across calls");
+  r.dispose();
+});

package/test/skip-invalid-restore.test.js

@@ -151,17 +151,19 @@ test("validateDecisions skipInvalid: conflict without a distinct winner/loser is
 
 // ------------------------------------------------------- skipInvalid 与全局闸门
 
-test("validateDecisions skipInvalid: valid subset below the coverage floor still rejects the whole batch", () => {
+test("validateDecisions skipInvalid: valid subset below the coverage floor degrades (Issue #104 方向 1)", () => {
   const snap = makeSnap(["p", "j", "x"]);
   const decisions = [
     { action: "archive", ids: ["p"], reason: "stale" },
     { action: "merge", ids: ["p", "j"], keepSource: "p", title: "跨类型", content: "m", importance: 4 }
   ];
-  const { ok, errors, skipped } = validateDecisions(decisions, snap, { skipInvalid: true });
-  assert.equal(ok, false, "skip does not bypass the coverage floor");
+  const { ok, errors, skipped, coverageShortfall } = validateDecisions(decisions, snap, { skipInvalid: true });
+  assert.equal(ok, true, "valid subset applies — shortfall degrades instead of rejecting");
+  assert.deepEqual(errors, []);
   assert.equal(skipped.length, 1);
-  assert.ok(errors.some((e) => e.includes("coverage")), "coverage error present");
-  assert.equal(decisions.length, 2, "rejected batch left untouched (splice only on the success path)");
+  assert.match(String(coverageShortfall), /coverage/, "shortfall reason surfaced for audit");
+  // claimed {p} = 1/3 = 33% < 50%；j/x 隐式 keep 补齐
+  assert.deepEqual(decisions.map((d) => d.action), ["archive", "keep", "keep"]);
 });
 
 test("validateDecisions skipInvalid: updates skipped for other reasons do not count toward the update cap", () => {