@modusensus/dsh-mneme 0.7.31 → 0.7.32

package/test/dream-candidate-hybrid.test.js

@@ -0,0 +1,281 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createDreamScheduler } from "../src/dream.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+import { parseEntries } from "./helpers/dream-mock.js";
+
+// Issue #125：候选集构造从"纯时间窗口"扩成"窗口 ∪ 向量翻出的高相似组"。
+// 实测背景：45 对「双方活跃且 sim≥0.85」里 0 对能同时进窗口（窗口覆盖率 11.7%）,
+// 纯时间窗口让"该合并的一对"几乎永远碰不到面。
+//
+// 观察点统一用 mock LLM 收到的候选列表（listText 里的 id=/title= 行）——那就是
+// snapshot 的真实内容，比读内部变量更接近"LLM 实际看到了什么"。
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const vectorIndex = createVectorIndex({ store });
+  const embedder = {
+    embedSingle: async () => [1, 0, 0],
+    embed: async (texts) => texts.map(() => [1, 0, 0]),
+    schedule: () => {},
+    modelHash: "mock#1",
+    dimension: 3
+  };
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vectorIndex);
+  return { store, service, vectorIndex, embedder };
+}
+
+/** Save a memory with a pinned embedding. */
+function seed(service, vectorIndex, title, vec) {
+  const m = service.saveWithDedupe({ type: "project", title, content: `${title} 的内容`, importance: 3 }).memory;
+  vectorIndex.saveEmbedding(m.id, vec);
+  return m;
+}
+
+/** Capture the candidate titles the LLM was handed. */
+// 注意：不能用 helpers 的 mockCtx —— 它靠 userText.startsWith("id=") 区分阶段，而
+// semantic 可用时候选列表以「# 聚类 N」开头（语义预分组），会被误判成 summary。
+// 这里改用 system prompt 判定，与 listText 的形态解耦。
+function stubCtx(consolidationReply) {
+  const seen = { titles: [] };
+  const ctx = {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        const sys = options.messages.find((m) => m.role === "system")?.content?.[0]?.text ?? "";
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        const isConsolidation = sys.includes("记忆巩固");
+        if (isConsolidation) {
+          seen.titles = parseEntries(userText).map((e) => e.title);
+          yield { type: "text-delta", index: 0, text: typeof consolidationReply === "function" ? consolidationReply() : consolidationReply };
+        } else {
+          yield { type: "text-delta", index: 0, text: "记忆库总览：测试桩。" };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  return { ctx, seen };
+}
+
+function capture() {
+  return stubCtx("[]");
+}
+
+function scheduler(config, semantic) {
+  return createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0, semantic });
+}
+
+const baseCfg = { dreamProvider: "mock", dreamModel: "mock-model" };
+
+test("issue#125 window (default): candidates are exactly the newest dreamMaxSnapshotSize entries", async () => {
+  const { store, service } = setup();
+  // 同毫秒保存会让 updated_at 并列、排序退化到 id（UUID 随机）——插小延时保证严格递增。
+  for (let i = 0; i < 5; i++) {
+    service.saveWithDedupe({ type: "project", title: `记忆${i}`, content: `内容${i}`, importance: 3 });
+    await sleep(3);
+  }
+  const { ctx, seen } = capture();
+  await scheduler().runDream(ctx, service, { ...baseCfg, dreamMaxSnapshotSize: 3 });
+  assert.deepEqual(seen.titles, ["记忆4", "记忆3", "记忆2"], "newest three, updated_at desc — 与 v0.7.31 逐条一致");
+  store.close();
+});
+
+test("issue#125 hybrid: a highly similar pair sitting outside the window is pulled in", async () => {
+  const { store, service, vectorIndex, embedder } = setup();
+  // 窗口外（最老）：一对高相似（同向量 → cos 1.0）
+  const a = seed(service, vectorIndex, "老旧方案A", [1, 0, 0]);
+  await sleep(3);
+  const b = seed(service, vectorIndex, "老旧方案B", [1, 0, 0]);
+  await sleep(3);
+  // 窗口内（最新 3 条）：彼此不相似（正交）
+  seed(service, vectorIndex, "近期甲", [0, 1, 0]);
+  await sleep(3);
+  seed(service, vectorIndex, "近期乙", [0, 0, 1]);
+  await sleep(3);
+  seed(service, vectorIndex, "近期丙", [0.5, 0.5, 0.7]);
+
+  const semantic = { embedder, vectorIndex };
+  const { ctx, seen } = capture();
+  await scheduler({}, semantic).runDream(ctx, service, {
+    ...baseCfg, dreamMaxSnapshotSize: 3, dreamCandidateMode: "hybrid"
+  });
+  assert.ok(seen.titles.includes(a.title) && seen.titles.includes(b.title),
+    "the out-of-window similar pair reached the candidate list");
+  store.close();
+});
+
+test("issue#125 hybrid: dreamCandidateMax widens the cap, the window is still included", async () => {
+  const { store, service, vectorIndex, embedder } = setup();
+  const a = seed(service, vectorIndex, "外窗A", [1, 0, 0]);
+  await sleep(3);
+  const b = seed(service, vectorIndex, "外窗B", [1, 0, 0]);
+  await sleep(3);
+  seed(service, vectorIndex, "窗内甲", [0, 1, 0]);
+  await sleep(3);
+  seed(service, vectorIndex, "窗内乙", [0, 0, 1]);
+
+  const semantic = { embedder, vectorIndex };
+  const { ctx, seen } = capture();
+  await scheduler({}, semantic).runDream(ctx, service, {
+    ...baseCfg, dreamMaxSnapshotSize: 2, dreamCandidateMode: "hybrid", dreamCandidateMax: 4
+  });
+  assert.equal(seen.titles.length, 4, "candidate total capped at max(window, dreamCandidateMax)");
+  assert.ok(seen.titles.includes(a.title) && seen.titles.includes(b.title), "vector group kept");
+  assert.equal(new Set(seen.titles).size, seen.titles.length, "no duplicate members");
+  store.close();
+});
+
+test("issue#125 hybrid: three mutually similar entries arrive as one contiguous group", async () => {
+  const { store, service, vectorIndex, embedder } = setup();
+  // 一簇 3 条互相相似（同向量）
+  const c1 = seed(service, vectorIndex, "簇甲", [1, 0, 0]);
+  await sleep(3);
+  const c2 = seed(service, vectorIndex, "簇乙", [1, 0, 0]);
+  await sleep(3);
+  const c3 = seed(service, vectorIndex, "簇丙", [1, 0, 0]);
+  await sleep(3);
+  seed(service, vectorIndex, "窗外无关", [0, 1, 0]);
+
+  const semantic = { embedder, vectorIndex };
+  const { ctx, seen } = capture();
+  await scheduler({}, semantic).runDream(ctx, service, {
+    ...baseCfg, dreamMaxSnapshotSize: 1, dreamCandidateMode: "hybrid", dreamCandidateMax: 4
+  });
+  const idx = [c1.title, c2.title, c3.title].map((t) => seen.titles.indexOf(t));
+  assert.ok(idx.every((i) => i >= 0), "all cluster members are candidates");
+  const sorted = [...idx].sort((x, y) => x - y);
+  assert.deepEqual(sorted, [sorted[0], sorted[0] + 1, sorted[0] + 2],
+    "cluster members are contiguous — 一簇按一个候选单元展开，不会被拆成散落的对");
+  store.close();
+});
+
+test("issue#125 hybrid without an embedder falls back to the plain window (never fails)", async () => {
+  const { store, service } = setup();
+  for (let i = 0; i < 4; i++) {
+    service.saveWithDedupe({ type: "project", title: `回滚${i}`, content: `内容${i}`, importance: 3 });
+    await sleep(3);
+  }
+  const { ctx, seen } = capture();
+  // semantic = null → hybrid 分支不激活
+  const result = await scheduler({}, null).runDream(ctx, service, {
+    ...baseCfg, dreamMaxSnapshotSize: 2, dreamCandidateMode: "hybrid"
+  });
+  assert.equal(seen.titles.length, 2, "falls back to the window");
+  assert.equal(result.ok, true, "the run still succeeds");
+  assert.deepEqual(seen.titles, ["回滚3", "回滚2"]);
+  store.close();
+});
+
+test("issue#125 hybrid: a similarity cluster outside the window is resolvable in one run", async () => {
+  const { store, service, vectorIndex, embedder } = setup();
+  const a = seed(service, vectorIndex, "旧版本", [1, 0, 0]);
+  await sleep(3);
+  const b = seed(service, vectorIndex, "新版本", [1, 0, 0]);
+  await sleep(3);
+  seed(service, vectorIndex, "近期条目", [0, 1, 0]);
+
+  const semantic = { embedder, vectorIndex };
+  // LLM 只对这一对下一道 merge 决策——它在窗口外，window 档下永远不会被看到。
+  const { ctx } = stubCtx(() => JSON.stringify([
+    { action: "merge", ids: [b.id, a.id], keepSource: b.id, title: "版本总览", content: "合并后", importance: 4 }
+  ]));
+  const result = await scheduler({}, semantic).runDream(ctx, service, {
+    ...baseCfg, dreamMaxSnapshotSize: 2, dreamCandidateMode: "hybrid"
+  });
+  assert.equal(result.ok, true, "the out-of-window pair is adjudicated (not a whole-batch rejection)");
+  assert.equal(store.getById(a.id).archived, true, "the older version was merged away");
+  assert.equal(store.getById(b.id).title, "版本总览");
+  store.close();
+});
+
+// ------------------------------------------------------- backfill & 降级路径
+
+test("issue#125 hybrid: entries without a cached vector are embedded on the fly", async () => {
+  const { store, service, vectorIndex, embedder } = setup();
+  // 故意不预设向量：collectCandidateVectors 必须自己补齐后再比较。
+  const a = service.saveWithDedupe({ type: "project", title: "无向量A", content: "内容A", importance: 3 }).memory;
+  await sleep(3);
+  const b = service.saveWithDedupe({ type: "project", title: "无向量B", content: "内容B", importance: 3 }).memory;
+  await sleep(3);
+  seed(service, vectorIndex, "窗内条目", [0, 1, 0]);
+  const { ctx, seen } = capture();
+  await scheduler({}, { embedder, vectorIndex }).runDream(ctx, service, {
+    ...baseCfg, dreamMaxSnapshotSize: 1, dreamCandidateMode: "hybrid", dreamCandidateMax: 4
+  });
+  assert.ok(seen.titles.includes(a.title) && seen.titles.includes(b.title),
+    "missing vectors are backfilled (embedder.embed), then the pair is compared");
+  store.close();
+});
+
+test("issue#125 hybrid: cross-type pairs join only when allowCrossTypeMerge is on", async () => {
+  const { store, service, vectorIndex, embedder } = setup();
+  const proj = service.saveWithDedupe({ type: "project", title: "项目侧", content: "x", importance: 3 }).memory;
+  vectorIndex.saveEmbedding(proj.id, [1, 0, 0]);
+  await sleep(3);
+  const pref = service.saveWithDedupe({ type: "preference", title: "偏好侧", content: "y", importance: 3 }).memory;
+  vectorIndex.saveEmbedding(pref.id, [1, 0, 0]);
+  await sleep(3);
+  seed(service, vectorIndex, "窗内条目", [0, 1, 0]);
+  const semantic = { embedder, vectorIndex };
+  const cfg = { ...baseCfg, dreamMaxSnapshotSize: 1, dreamCandidateMode: "hybrid", dreamCandidateMax: 4 };
+
+  const off = capture();
+  await scheduler({}, semantic).runDream(off.ctx, service, cfg);
+  assert.ok(!off.seen.titles.includes(pref.title), "cross-type pair stays out by default (same-type only)");
+
+  const on = capture();
+  await scheduler({}, semantic).runDream(on.ctx, service, { ...cfg, allowCrossTypeMerge: true });
+  assert.ok(on.seen.titles.includes(proj.title) && on.seen.titles.includes(pref.title),
+    "cross-type pair enters the candidate set once explicitly allowed");
+  store.close();
+});
+
+test("issue#125 hybrid: a throwing embedder degrades to the plain window", async () => {
+  const { store, service, vectorIndex } = setup();
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "project", title: `降级${i}`, content: `内容${i}`, importance: 3 });
+    await sleep(3);
+  }
+  const boom = {
+    embedSingle: async () => { throw new Error("embed down"); },
+    embed: async () => { throw new Error("embed down"); },
+    schedule: () => {},
+    modelHash: "x",
+    dimension: 3
+  };
+  const { ctx, seen } = capture();
+  const result = await scheduler({}, { embedder: boom, vectorIndex }).runDream(ctx, service, {
+    ...baseCfg, dreamMaxSnapshotSize: 2, dreamCandidateMode: "hybrid"
+  });
+  assert.equal(result.ok, true, "向量层是增强而非依赖：嵌入失败不能让 run 失败");
+  assert.deepEqual(seen.titles, ["降级2", "降级1"], "falls back to the plain window");
+  store.close();
+});
+
+test("issue#125 hybrid: a throwing vector index degrades to the plain window", async () => {
+  const { store, service, embedder } = setup();
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "project", title: `索引坏${i}`, content: `内容${i}`, importance: 3 });
+    await sleep(3);
+  }
+  // getEmbedding 在 hybridCandidateMembers 的 try 内抛错 → 整体回落纯窗口。
+  const badIndex = {
+    getEmbedding: () => { throw new Error("index down"); },
+    saveEmbedding: () => {}
+  };
+  const { ctx, seen } = capture();
+  const result = await scheduler({}, { embedder, vectorIndex: badIndex }).runDream(ctx, service, {
+    ...baseCfg, dreamMaxSnapshotSize: 2, dreamCandidateMode: "hybrid"
+  });
+  assert.equal(result.ok, true, "run still succeeds");
+  assert.deepEqual(seen.titles, ["索引坏2", "索引坏1"], "falls back to the plain window");
+  store.close();
+});

package/test/dream.test.js

@@ -27,6 +27,56 @@ test("unknown id rejects whole list", () => {
   assert.ok(errors.some((e) => e.includes("zzz")));
 });
 
+// --- Issue #135: 唯一前缀解析 -------------------------------------------------
+// 模型常把 36 位 UUID 回填成前缀（报告实测 78/78 个 8 位前缀都能唯一对应窗口内
+// 真实记忆，且 few-shot 示例的 "m1"/"m2" 占位符在诱导这种缩写）。校验前的唯一
+// 前缀解析把它们还原成完整 id，而不是逐条 unknown id 后被覆盖率闸整单拒绝。
+
+test("Issue #135: unique short prefixes resolve to full ids (ids + keepSource)", () => {
+  const idA = "f77a0d17-2586-41fe-a789-d69f4d1cee83";
+  const idB = "bc17c9ed-e84c-4b9f-bc36-48f8e9a6b3e0";
+  const snap = snapshot([idA, idB]);
+  const decisions = [
+    { action: "merge", ids: ["f77a0d17", "bc17c9ed"], title: "合并", content: "合并后的内容", importance: 4, keepSource: "f77a0d17" }
+  ];
+  const { ok, errors, resolvedShortIds } = validateDecisions(decisions, snap);
+  assert.equal(ok, true, JSON.stringify(errors));
+  assert.equal(resolvedShortIds, 3, "two ids + keepSource resolved");
+  assert.deepEqual(decisions[0].ids, [idA, idB], "ids rewritten in place");
+  assert.equal(decisions[0].keepSource, idA, "keepSource rewritten");
+});
+
+test("Issue #135: conflict winner/loser short prefixes resolve", () => {
+  const idA = "f77a0d17-2586-41fe-a789-d69f4d1cee83";
+  const idB = "bc17c9ed-e84c-4b9f-bc36-48f8e9a6b3e0";
+  const snap = snapshot([idA, idB]);
+  const decisions = [{ action: "conflict", winner: "f77a0d17", loser: "bc17c9ed", reason: "内容矛盾" }];
+  const { ok, errors, resolvedShortIds } = validateDecisions(decisions, snap);
+  assert.equal(ok, true, JSON.stringify(errors));
+  assert.equal(resolvedShortIds, 2);
+  assert.equal(decisions[0].winner, idA, "winner rewritten");
+  assert.equal(decisions[0].loser, idB, "loser rewritten");
+});
+
+test("Issue #135: ambiguous prefix stays unresolved and reports unknown id", () => {
+  const snap = snapshot([
+    "aaaaaaaa-1111-4111-8111-111111111111",
+    "aaaaaaaa-2222-4222-8222-222222222222"
+  ]);
+  const { ok, errors, resolvedShortIds } = validateDecisions([{ action: "archive", ids: ["aaaaaaaa"] }], snap);
+  assert.equal(ok, false);
+  assert.equal(resolvedShortIds, 0, "ambiguous prefix is never guessed");
+  assert.ok(errors.some((e) => e.includes("unknown id")), JSON.stringify(errors));
+});
+
+test("Issue #135: unmatched prefix is left for the validator to report", () => {
+  const snap = snapshot(["f77a0d17-2586-41fe-a789-d69f4d1cee83"]);
+  const { ok, errors, resolvedShortIds } = validateDecisions([{ action: "archive", ids: ["deadbeef"] }], snap);
+  assert.equal(ok, false);
+  assert.equal(resolvedShortIds, 0, "no match means no rewrite");
+  assert.ok(errors.some((e) => e.includes("deadbeef")), JSON.stringify(errors));
+});
+
 test("invalid action rejects", () => {
   const snap = snapshot(["a"]);
   const { ok } = validateDecisions([{ action: "explode", ids: ["a"] }], snap);
@@ -486,6 +536,36 @@ test("runDream fails safe on invalid decisions", async () => {
   store.close();
 });
 
+test("Issue #135: failed validation persists { _validationFailed, errors, skipped } into the run row", async () => {
+  const { store, service } = dreamSetup();
+  const saved = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  let calls = 0;
+  const ctx = {
+    llm: {
+      stream: async function* () {
+        calls++;
+        yield { type: "text-delta", text: calls === 1 ? JSON.stringify([{ action: "archive", ids: ["deadbeef"] }]) : "summary" };
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    },
+    logger: { warn: () => {}, info: () => {} }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.equal(result.ok, false, "coverage gate rejects (0% explicit coverage)");
+  assert.ok(Array.isArray(result.decisions) && result.decisions[0]?._validationFailed === true,
+    "failure result carries the validation detail");
+  assert.ok(result.decisions[0].skipped.some((s) => s.error.includes("deadbeef")),
+    "skipped keeps the per-item reason");
+  // 落库验证：dream_runs.decisions 不再是 NULL，事后可离线定位失败原因。
+  const run = store.getDreamRun(result.runId);
+  assert.ok(run?.decisions?.[0]?._validationFailed === true, "detail persisted in dream_runs.decisions");
+  assert.ok(run.decisions[0].skipped.length >= 1);
+  const lang = store.getById(saved.memory.id);
+  assert.equal(lang.archived, false, "unknown-id decision must not touch real memories");
+  store.close();
+});
+
 // --- item ①: CAS guard against concurrent edits ----------------------------
 
 test("applyDecisions CAS: merge onto a concurrently-edited target is skipped as a conflict, not applied", () => {
@@ -1029,6 +1109,49 @@ test("issue#89: dream run with a skipped invalid decision lands the valid subset
   store.close();
 });
 
+// Issue #104（跟进 #137 失败路径）：degraded（合法子集已应用）轮的跳过明细此前只进
+// logger.warn，splice 之后就地从 decisions 里消失，落库的已是幸存列表——离线回放
+// dream_runs 无法判断被跳的是跨类型 merge、update 保护期还是 unknown id。这里断言
+// 明细进了独立的 skipped 列（而非内联进 decisions），且携带可定位的逐条原因。
+test("issue#104: degraded run persists the skipped decision detail into dream_runs.skipped", async () => {
+  const { store, service } = dreamSetup();
+  const a = service.saveWithDedupe({ type: "project", title: "旧A", content: "过时A" }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "旧B", content: "过时B" }).memory;
+  const pref = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" }).memory;
+  const c = service.saveWithDedupe({ type: "project", title: "旧C", content: "过时C" }).memory;
+  const ctx = {
+    logger: { warn: () => {}, info: () => {} },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          // 一条跨类型 merge（非法 → 跳过）+ 两条合法 archive（显式覆盖 2/4，过 50% 下限）
+          yield { type: "text-delta", index: 0, text: JSON.stringify([
+            { action: "merge", ids: [pref.id, a.id], keepSource: pref.id, title: "跨类型", content: "不应合并", importance: 4 },
+            { action: "archive", ids: [b.id], reason: "stale" },
+            { action: "archive", ids: [c.id], reason: "stale" }
+          ]) };
+        } else {
+          yield { type: "text-delta", index: 0, text: "记忆库总览：degraded 轮的跳过明细可从审计行回放。" };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "mock", dreamModel: "mock-model" });
+  assert.equal(result.status, "degraded", "run degrades on the skipped decision");
+  // 落库验证：skipped 列不再是 NULL，逐条带 index/action/error，事后无需重跑即可定位成因。
+  const run = store.getDreamRun(result.runId);
+  assert.ok(Array.isArray(run?.skipped) && run.skipped.length === 1, "skipped detail persisted in dream_runs.skipped");
+  assert.equal(run.skipped[0].index, 0, "the skipped entry is the cross-type merge");
+  assert.equal(run.skipped[0].action, "merge");
+  assert.match(run.skipped[0].error, /multiple types/, "per-item skip reason is kept");
+  // 独立字段，不污染按「决策数组」消费 decisions 的下游读者。
+  assert.ok(!run.decisions.some((d) => d && d._skipped !== undefined), "decisions stays free of inline markers");
+  store.close();
+});
+
 test("issue#89: dreamSkipInvalid:false restores the whole-batch strict rejection", async () => {
   const { store, service } = dreamSetup();
   const a = service.saveWithDedupe({ type: "project", title: "旧A", content: "过时A" }).memory;
@@ -1076,3 +1199,52 @@ test("issue#89: minIntervalMs throttles re-triggering regardless of run outcome"
   assert.equal(dream.maybeSchedule(service), true, "interval elapsed → eligible again (baseline unmoved by failure)");
   store.close();
 });
+
+// --- Issue #126：新动作（supersede / differentiate）在 dream 路径也必须产 receipt ---
+// buildRecordReceipts 此前只认 merge/conflict/update，新动作会静默不产 receipt，让
+// receipt_chain 留洞。dream 的 consolidation prompt 虽然不含这两个动作，但校验器
+// 的 ACTIONS 是共用的——模型自由发挥（或将来把动作集扩到 dream）时审计不能丢。
+
+test("issue#126: a supersede decision on the dream path produces a supersede receipt", async () => {
+  const { store, service } = dreamSetup();
+  const oldMem = service.saveWithDedupe({ type: "project", title: "方案 v1", content: "用 pm2 常驻" }).memory;
+  const newMem = service.saveWithDedupe({ type: "project", title: "方案 v2", content: "改用 systemd" }).memory;
+  const ctx = mockCtx({
+    onConsolidation: () => JSON.stringify([
+      { action: "supersede", winner: newMem.id, loser: oldMem.id, reason: "版本演进" }
+    ])
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "mock", dreamModel: "mock-model" });
+  assert.equal(result.status, "ok", "supersede applied and the summary landed");
+  assert.equal(store.getById(oldMem.id).archived, true, "older entry archived");
+  assert.equal(store.getById(newMem.id).content, "改用 systemd", "winner body untouched");
+  const receipts = store.listReceipts();
+  const supersedeReceipt = receipts.find((r) => r.kind === "supersede");
+  assert.ok(supersedeReceipt, "supersede receipt lands in receipt_chain");
+  assert.equal(supersedeReceipt.record_id, oldMem.id, "receipt records the superseded side");
+  assert.equal(supersedeReceipt.winner_id, newMem.id);
+  assert.equal(supersedeReceipt.loser_id, oldMem.id);
+  store.close();
+});
+
+test("issue#126: a differentiate decision on the dream path produces one receipt per entry", async () => {
+  const { store, service } = dreamSetup();
+  const a = service.saveWithDedupe({ type: "project", title: "内网端口", content: "内网走 22" }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "外网端口", content: "外网映射 2222" }).memory;
+  const ctx = mockCtx({
+    onConsolidation: () => JSON.stringify([
+      { action: "differentiate", ids: [a.id, b.id], distinctions: ["内网直连", "外网映射"] }
+    ])
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "mock", dreamModel: "mock-model" });
+  assert.equal(result.status, "ok", "differentiate applied and the summary landed");
+  assert.equal(store.getById(a.id).archived, false, "neither side is archived");
+  assert.equal(store.getById(b.id).archived, false);
+  const receipts = store.listReceipts().filter((r) => r.kind === "differentiate");
+  assert.equal(receipts.length, 2, "one receipt per differentiated entry");
+  assert.deepEqual(receipts.map((r) => r.record_id).sort(), [a.id, b.id].sort());
+  assert.ok(receipts.every((r) => r.count_before === 1 && r.count_after === 1), "no count change for differentiate");
+  store.close();
+});

package/test/embedding-ready.test.js

@@ -0,0 +1,196 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createEmbedder } from "../src/embedding.js";
+
+// issue #135: the legacy OpenAI-compatible embedder is an object literal with no
+// async init, so api.js's generic `"ready" in embedder` branch used to fall
+// through to "assume usable" — the status card stayed green while baseUrl /
+// apiKey / model were all empty and not a single vector could be produced
+// ("绿色假阳性"). These tests pin the real predicate and the getter semantics.
+
+const FULL = {
+  enabled: true,
+  baseUrl: "https://api.example.com/v1",
+  apiKey: "sk-test",
+  model: "text-embedding-3-small"
+};
+
+/** Build the embedder against a settings double + a recording store. */
+function make(cfg, { live = false } = {}) {
+  const writes = [];
+  const box = { cfg };
+  const embedder = createEmbedder({
+    store: { setEmbedding: (id, vector) => writes.push({ id, vector }) },
+    settings: { getVectorConfig: () => (live ? box.cfg : cfg) },
+    logger: { info() {}, warn() {} }
+  });
+  return { embedder, writes, box };
+}
+
+test("#135 legacy OpenAI embedder reports ready/configured from the config", () => {
+  const { embedder } = make(FULL);
+  assert.equal(embedder.ready, true, "fully configured → ready");
+  assert.equal(embedder.configured, true);
+
+  // Any of the four fields missing → not configured. `enabled` flips to false,
+  // the rest are blanked (the shape the settings panel leaves behind when the
+  // user never filled the vector section in).
+  for (const key of ["enabled", "baseUrl", "apiKey", "model"]) {
+    const broken = { ...FULL, [key]: key === "enabled" ? false : "" };
+    const { embedder: e } = make(broken);
+    assert.equal(e.configured, false, `blank ${key} → not configured`);
+    assert.equal(e.ready, false, `blank ${key} → not ready`);
+  }
+
+  // Defensive: a settings double returning {} (or nothing) must not throw.
+  assert.equal(make({}).embedder.ready, false);
+  assert.equal(make(undefined).embedder.ready, false);
+});
+
+test("#135 ready/configured are live getters, not boot-time snapshots", () => {
+  // The panel writes vector-config through settings; the legacy embedder reads
+  // it per call (same as embed()), so fixing the config must not need a restart.
+  const { embedder, box } = make(FULL, { live: true });
+  assert.equal(embedder.ready, true);
+  box.cfg = { ...FULL, apiKey: "" };
+  assert.equal(embedder.ready, false, "getter re-reads the live config");
+  assert.equal(embedder.configured, false);
+  box.cfg = FULL;
+  assert.equal(embedder.ready, true, "…and recovers once the config is complete");
+});
+
+test("#135 unconfigured embedder never reaches the network", async () => {
+  const { embedder, writes } = make({ ...FULL, apiKey: "" });
+  // A real fetch here would go out with an empty bearer token.
+  assert.equal(await embedder.embed("hello"), null);
+  assert.equal(await embedder.embedSingle("hello"), null);
+
+  embedder.schedule({ id: "m1", title: "t", content: "c" });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  assert.deepEqual(writes, [], "schedule() must not store an embedding");
+
+  // A memory without an id is a no-op (never a store write with undefined id).
+  embedder.schedule(null);
+  embedder.schedule({});
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  assert.deepEqual(writes, []);
+});
+
+test("#135 unconfigured embedder reports no model fingerprint or dimension", () => {
+  const { embedder } = make(FULL);
+  assert.equal(embedder.name, "OpenAI", "explicit name for the status card");
+  assert.equal(embedder.dimension, undefined, "no dimension before a first embed");
+  // model#hex — same fingerprint format the local embedders use.
+  assert.match(embedder.modelHash, /^text-embedding-3-small#[0-9a-f]+$/);
+  assert.equal(make({ ...FULL, model: "" }).embedder.modelHash, undefined);
+  assert.equal(make({ ...FULL, enabled: false }).embedder.modelHash, undefined);
+});
+
+// ── 覆盖补齐：embed 成功/降级、embedSingle 兜底、reindexMissing、schedule 成功路径 ──
+
+/** 临时替换全局 fetch（embedText 直接调它），fn 结束后恢复。 */
+async function withFetch(impl, fn) {
+  const original = globalThis.fetch;
+  globalThis.fetch = impl;
+  try {
+    return await fn();
+  } finally {
+    globalThis.fetch = original;
+  }
+}
+
+const okResponse = (embedding) => ({
+  ok: true,
+  json: async () => ({ data: [{ embedding }] })
+});
+
+test("embed: 完整配置时走真实 fetch，成功返回向量并记下维度", async () => {
+  const { embedder } = make(FULL);
+  await withFetch(async () => okResponse([1, 2, 3, 4]), async () => {
+    const vec = await embedder.embed("猫咪");
+    assert.deepEqual(vec, [1, 2, 3, 4]);
+    assert.equal(embedder.dimension, 4, "成功嵌入后记下维度供指纹用");
+  });
+});
+
+test("embed: 网络失败 / 非 2xx / 响应不可用都降级为 null，不抛", async () => {
+  const { embedder } = make(FULL);
+  await withFetch(async () => { throw new Error("ECONNREFUSED"); }, async () => {
+    assert.equal(await embedder.embed("x"), null);
+  });
+  await withFetch(async () => ({ ok: false }), async () => {
+    assert.equal(await embedder.embed("x"), null);
+  });
+  await withFetch(async () => ({ ok: true, json: async () => { throw new Error("bad json"); } }), async () => {
+    assert.equal(await embedder.embed("x"), null);
+  });
+  await withFetch(async () => ({ ok: true, json: async () => ({ data: [] }) }), async () => {
+    assert.equal(await embedder.embed("x"), null, "空 data 数组不可用");
+  });
+});
+
+test("embedSingle: embed 缺失时兜底返回 null（统一旧接口契约）", async () => {
+  const { embedder } = make(FULL);
+  assert.equal(await embedder.embedSingle.call({}, "x"), null, "无 embed 方法时返回 null 而非抛错");
+});
+
+test("reindexMissing: 逐行回填并统计 indexed/skipped，有成功才记模型指纹", async () => {
+  let markCalls = 0;
+  const rows = [{ id: "m1", title: "t1", content: "c1" }, { id: "m2", title: "t2", content: "c2" }];
+  const writes = [];
+  const embedder = createEmbedder({
+    store: {
+      setEmbedding: (id, v) => writes.push({ id, v }),
+      needsEmbedding: () => rows
+    },
+    settings: { getVectorConfig: () => FULL },
+    vectorIndex: { markModel: () => { markCalls++; } }
+  });
+  let call = 0;
+  await withFetch(async () => okResponse([call++, 0]), async () => {
+    const result = await embedder.reindexMissing(50);
+    assert.equal(result.indexed, 2);
+    assert.equal(result.skipped, 0);
+    assert.equal(writes.length, 2);
+    assert.equal(markCalls, 1, "有成功回填才记模型指纹");
+  });
+});
+
+test("reindexMissing: 未启用时直接返回 0/0，不碰 store", async () => {
+  const { embedder } = make({ ...FULL, enabled: false });
+  const result = await embedder.reindexMissing(50);
+  assert.deepEqual(result, { indexed: 0, skipped: 0 });
+});
+
+test("reindexMissing: 嵌入失败的行走 skipped，不算 indexed", async () => {
+  const writes = [];
+  const embedder = createEmbedder({
+    store: {
+      setEmbedding: (id, v) => writes.push({ id, v }),
+      needsEmbedding: () => [{ id: "m1", title: "t", content: "c" }]
+    },
+    settings: { getVectorConfig: () => FULL }
+  });
+  await withFetch(async () => ({ ok: false }), async () => {
+    const result = await embedder.reindexMissing(50);
+    assert.equal(result.indexed, 0);
+    assert.equal(result.skipped, 1, "嵌入失败的行走 skipped，不算 indexed");
+  });
+});
+
+test("schedule: 嵌入成功时写入 store 并记 info 日志（embedFor 成功路径）", async () => {
+  const writes = [];
+  let logged = 0;
+  const embedder = createEmbedder({
+    store: { setEmbedding: (id, v) => writes.push({ id, v }) },
+    settings: { getVectorConfig: () => FULL },
+    logger: { info: () => { logged++; }, warn() {} },
+    vectorIndex: { markModel() {} }
+  });
+  await withFetch(async () => okResponse([0.1, 0.2]), async () => {
+    embedder.schedule({ id: "m9", title: "t", content: "c" });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  });
+  assert.equal(writes.length, 1);
+  assert.equal(logged, 1, "成功嵌入记一行 info 日志");
+});