@modusensus/dsh-mneme 0.7.31 → 0.8.0

package/test/client.test.js

@@ -121,10 +121,10 @@ test("trigger renders a wide row or a rail icon from the wide flag", () => {
   );
 });
 
-// The entry lives ABOVE the workspaces region: the real button is portalled
-// just before the host's regionArea container (below New Session, above the
-// workspace list), while the sidebar.footer.action registration remains as
-// the React anchor and the in-place fallback when the host markup changes.
+// The entry lives at the top of the plugin-entry group: the real button is
+// portalled right after the host's New-Session row (above the entries other
+// plugins inject there), while the sidebar.footer.action registration remains
+// as the React anchor and the in-place fallback when the host markup changes.
 test("sidebar entry portals above the workspaces region with footer fallback", () => {
   assert.ok(
     clientSource.includes('ctx.slots.inject("sidebar.footer.action"'),
@@ -139,8 +139,8 @@ test("sidebar entry portals above the workspaces region with footer fallback", (
     "the portal must anchor at the host's regionArea container"
   );
   assert.ok(
-    clientSource.includes("insertBefore(created, region)"),
-    "the entry must sit immediately above the workspaces region"
+    clientSource.includes("insertBefore(created, target)"),
+    "the entry must be placed through the idempotent place() helper"
   );
   assert.ok(
     clientSource.includes("if (!host) return fallback;"),
@@ -160,13 +160,40 @@ test("sidebar entry portals above the workspaces region with footer fallback", (
   );
 });
 
+// Issue #130: ecosystem plugins (task board, skill explorer, …) inject their
+// own entries right after the New-Session row, and late inserters land above
+// earlier ones — a fixed "before regionArea" slot degrades into the tail of
+// that group, detaching the memory button from its familiar top spot. The
+// entry therefore (a) resolves the same anchor as the ecosystem's shared
+// sidebar-entry-core (logoRow row, legacy direct-child button), (b) re-asserts
+// its slot from the existing observer, and (c) stays idempotent — the anchor
+// check short-circuits before any DOM write, so observers never ping-pong.
+test("entry re-asserts the New-Session-adjacent slot against ecosystem entries", () => {
+  assert.ok(
+    clientSource.includes(`btn.closest('[class*="logoRow"]')`),
+    "the anchor must resolve the New-Session logo row like the ecosystem core"
+  );
+  assert.ok(
+    clientSource.includes("const target = anchor ? anchor.nextSibling : region;"),
+    "the entry must sit right after the New-Session row, falling back before regionArea"
+  );
+  assert.ok(
+    clientSource.includes("if (created.parentElement === parent && created.nextSibling === target) return;"),
+    "placement must be idempotent so the observer never writes on steady state"
+  );
+  assert.ok(
+    /place\(cur\);\s*\n\s*const cls = findNative\(cur\)/.test(clientSource),
+    "the observer must re-place the entry on childList churn, not just re-sync the class"
+  );
+});
+
 // Three alignment/softness guarantees born from field feedback: (a) the
 // portalled entry keeps tracking the live New-Session class (host and skin
 // rewrite it asynchronously, so a mount-time snapshot goes stale), (b) it
-// fills the same width as that button and inherits its native centering,
+// inherits that button's width and margins along with its native centering,
 // (c) the toolbar dropdown escapes the transform stacking trap — the
 // container needs the z-index because transform creates the context.
-test("entry tracks native class, fills native width, and lifts the toolbar dropdown", () => {
+test("entry tracks native class, inherits native sizing, and lifts the toolbar dropdown", () => {
   assert.ok(
     clientSource.includes("new MutationObserver"),
     "the entry must re-sync the copied class via MutationObserver"
@@ -175,9 +202,14 @@ test("entry tracks native class, fills native width, and lifts the toolbar dropd
     clientSource.includes('attributeFilter: ["class"]'),
     "the observer must watch class attribute changes"
   );
+  assert.doesNotMatch(
+    clientSource,
+    /\.mneme-topentry-native\{(?:[^}]*;)?width:/,
+    "the entry must use the native button width, which reserves its horizontal margins"
+  );
   assert.ok(
-    /\.mneme-topentry-native\{width:100%;/.test(clientSource),
-    "the entry button must fill the same width as the New-Session row"
+    clientSource.includes(".mneme-topentry{display:flex;flex-direction:column}"),
+    "the entry wrapper must stretch the native button within a column flex layout"
   );
   assert.equal(
     clientSource.includes(".mneme-topentry-native .mneme-topentry-label{flex:1;min-width:0;text-align:left;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}"),
@@ -593,3 +625,113 @@ test("settings feedback card: prefilled issue + mailto + browse, version from /i
     assert.ok(occurrences >= 2, `i18n key memory.settings.${key} must exist in both zh and en (got ${occurrences})`);
   }
 });
+
+// UI 文案必须双语齐全（中英各一条）。用户明确要求所有 UI 文字都做 i18n，
+// 这条守卫用「每个键恰好出现两次」兜住：出现奇数次就是漏译，>2 次说明重复。
+test("i18n keys are bilingual: every key appears exactly twice (zh + en)", () => {
+  const counts = new Map();
+  for (const match of clientSource.matchAll(/^\s*"([a-zA-Z0-9_.]+)"\s*:\s*"/gm)) {
+    counts.set(match[1], (counts.get(match[1]) ?? 0) + 1);
+  }
+  const odd = [...counts.entries()].filter(([, n]) => n !== 2).map(([key, n]) => `${key}×${n}`);
+  assert.deepEqual(odd, [], `这些 i18n 键没有做到中英各一条：${odd.join(", ")}`);
+  assert.ok(counts.size > 100, `解析到的键太少（${counts.size}），正则可能没匹配到 i18n 表`);
+});
+
+// issue #135：向量状态卡必须区分「没配」与「配了却一条都没嵌上」。此前卡片只看
+// ready，而未配置的 legacy embedder（ready 恒 true）一路显示成正常 provider。
+test("vector status card surfaces the configured/degraded split", () => {
+  // 1. 读后端新字段，缺失（旧服务端）时退化成旧行为而不是误报未配置
+  assert.ok(
+    clientSource.includes('typeof j?.configured === "boolean" ? j.configured : null'),
+    "the card must read `configured` and tolerate older servers that omit it"
+  );
+  assert.ok(
+    clientSource.includes("j?.degraded === true"),
+    "the card must read `degraded`"
+  );
+  // 2. 三态互斥：未配置优先于初始化中，降级只在既非未配置也非初始化时成立
+  assert.ok(
+    clientSource.includes("const unconfigured = !off && state.configured === false;"),
+    "unconfigured must be its own state, not folded into ready"
+  );
+  assert.ok(
+    clientSource.includes("const pending = !off && !unconfigured && state.ready !== true;"),
+    "an unconfigured embedder must not be reported as initializing"
+  );
+  assert.ok(
+    clientSource.includes("const degraded = !off && !unconfigured && !pending && state.degraded === true;"),
+    "degraded must only apply to a configured, settled embedder"
+  );
+  // 3. 三个状态各自的标签/说明走 i18n，双语齐备
+  for (const key of ["vectorUnconfigured", "vectorUnconfiguredHint", "vectorDegradedHint"]) {
+    const occurrences = clientSource.split(`"memory.status.${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key memory.status.${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(
+    clientSource.includes('t("memory.status.vectorUnconfigured")'),
+    "the unconfigured state must render its own label"
+  );
+  assert.ok(
+    clientSource.includes('t("memory.status.vectorDegradedHint")'),
+    "the degraded state must render its own caption (0 of {m} indexed)"
+  );
+});
+
+// v0.8.0 A4（issue #17）：作用域隔离的面板面——设置卡新组（scopeEnabled /
+// strictScope 开关）+ 记忆条目的 scope provenance 展示。i18n 键必须中英双语
+// 齐全；徽章/详情行沿用 heat 徽章的「字段缺省即不渲染」模式，前端不感知开关。
+/**
+ * A4（issue #17）面板面回归：作用域隔离的设置卡分组、十个 i18n 键的中英双语
+ * 齐备（沿用 occurrences ≥ 2 模式），以及 ScopeBadge 组件与三处接线（cards
+ * 脚部 / timeline 行 / 详情抽屉 dmeta）的真实存在性——只做源码断言，不挂
+ * React 渲染环境，与文件内其他 clientSource 断言同一风格。
+ */
+test("scope isolation ships panel switches and provenance surfaces (A4)", () => {
+  assert.ok(
+    /key: "group\.scope", items: \["scopeEnabled", "strictScope"\]/.test(clientSource),
+    "FEATURE_GROUPS must carry a dedicated scope group"
+  );
+  for (const key of [
+    "memory.features.group.scope",
+    "memory.features.scopeEnabled",
+    "memory.features.scopeEnabled.hint",
+    "memory.features.strictScope",
+    "memory.features.strictScope.hint",
+    "memory.explorer.scopeBadge",
+    "memory.explorer.detail.agentScope",
+    "memory.explorer.detail.workspaceScope",
+    "memory.explorer.detail.sensitivity",
+    "memory.explorer.detail.occurred"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(/const ScopeBadge = \(\{ m, t \}\)/.test(clientSource), "ScopeBadge component must exist");
+  assert.ok(clientSource.includes("h(ScopeBadge, { m, t })"), "ScopeBadge must be wired into browse views");
+  assert.ok(clientSource.includes('t("memory.explorer.detail.agentScope")'), "drawer must render agent scope row");
+  assert.ok(clientSource.includes('t("memory.explorer.detail.occurred")'), "drawer must render occurred row");
+});
+
+// v0.8.0 冲突集中处理：状态页的待确认冲突队列（reason + 双方内容对比 +
+// 保留 A/B/仅标记动作），resolveConflictPending 的第一个前端出口。双语齐备。
+test("conflict queue ships a central review surface on the status tab", () => {
+  for (const key of [
+    "memory.status.conflictQueue.reason",
+    "memory.status.conflictQueue.sideA",
+    "memory.status.conflictQueue.sideB",
+    "memory.status.conflictQueue.keepA",
+    "memory.status.conflictQueue.keepB",
+    "memory.status.conflictQueue.markReviewed",
+    "memory.status.conflictQueue.applyHint",
+    "memory.status.conflictQueue.missing",
+    "memory.status.conflictQueue.refresh"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(/function ConflictsQueue\(\{ t \}\)/.test(clientSource), "ConflictsQueue component must exist");
+  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts"'), "queue must fetch the conflicts endpoint");
+  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts/resolve"'), "queue must call the resolve endpoint");
+  assert.ok(clientSource.includes("h(ConflictsQueue, { t })"), "status tab must render the queue");
+});

package/test/commands.test.js

@@ -40,14 +40,51 @@ test("add registers live; remove unregisters live", () => {
   store.close();
 });
 
-test("handler returns the instruction as success text", async () => {
+test("handler submits the instruction to the agent and returns a receipt", async () => {
   const { store, manager, registered } = setup();
   manager.add({ name: "fmt", description: "格式化", instruction: "请按项目的 lint 规则格式化当前文件" });
   const def = registered.get("fmt");
   assert.ok(def, "definition registered");
-  const result = await def.handler({ agent: {}, rawInput: "", signal: null });
+  assert.equal(def.input.hint, "可选：追加给模型的补充说明");
+  const submitted = [];
+  const agent = { followup: (message) => submitted.push(message) };
+  const result = await def.handler({ agent, rawInput: "", signal: null });
   assert.equal(result.kind, "success");
-  assert.equal(result.text, "请按项目的 lint 规则格式化当前文件");
+  assert.equal(result.text, "已提交指令：fmt");
+  assert.equal(submitted.length, 1);
+  assert.equal(submitted[0].role, "user");
+  assert.deepEqual(submitted[0].content, [{ type: "text", text: "请按项目的 lint 规则格式化当前文件" }]);
+  assert.deepEqual(submitted[0].source, { kind: "user" });
+  store.close();
+});
+
+test("rawInput suffix is appended for the model", async () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "mneme", instruction: "以「小墨」的口吻自我介绍" });
+  const def = registered.get("mneme");
+  const submitted = [];
+  await def.handler({ agent: { followup: (m) => submitted.push(m) }, rawInput: "  顺便列出归档数量  " });
+  assert.equal(submitted[0].content[0].text, "以「小墨」的口吻自我介绍\n\n顺便列出归档数量");
+  store.close();
+});
+
+test("handler without a receiving agent falls back to surfacing the instruction", () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "fmt", instruction: "legacy text" });
+  const def = registered.get("fmt");
+  const result = def.handler({ rawInput: "" });
+  assert.equal(result.kind, "success");
+  assert.equal(result.text, "legacy text");
+  store.close();
+});
+
+test("handler returns an error result when the agent rejects the submission", () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "boom", instruction: "x" });
+  const def = registered.get("boom");
+  const result = def.handler({ agent: { followup: () => { throw new Error("nope"); } } });
+  assert.equal(result.kind, "error");
+  assert.match(result.text, /boom/);
   store.close();
 });
 

package/test/config.test.js

@@ -46,5 +46,21 @@ test("startup probe: the reranker module never statically imports transformers/o
     !src.includes('from "@huggingface/transformers"'),
     "no static transformers.js import in reranker.js"
   );
-  assert.match(src, /await import\("@huggingface\/transformers"\)/, "transformers.js loads lazily via dynamic import");
+  // issue #131 之后，懒加载的落点从 reranker 内部搬到了 src/runtime/loader.js
+  // （三层解析：自管 payload → 宿主裸 specifier）。判据随之改成两条，意图不变：
+  // reranker 不得静态导入，且必须经由 loader 间接加载；动态 import 只允许出现在
+  // loader 里（它是唯一知道「运行时从哪来」的模块）。
+  assert.match(src, /from "\.\/runtime\/loader\.js"/, "reranker 经 runtime/loader.js 取运行时");
+  assert.match(src, /loadTransformers\(/, "reranker 必须走三层解析，而不是自己拼 import");
+  assert.ok(
+    !/^\s*import[^\n]*@huggingface\/transformers/m.test(src),
+    "reranker 不允许任何形式的静态 transformers 导入"
+  );
+
+  const loaderSrc = readFileSync(new URL("../src/runtime/loader.js", import.meta.url), "utf8");
+  assert.match(loaderSrc, /import\(specifier\)/, "loader 用动态 import 保持懒加载");
+  assert.ok(
+    !/^\s*import[^\n]*@huggingface\/transformers/m.test(loaderSrc),
+    "loader 不得静态导入 transformers，否则惰性加载就失效了"
+  );
 });

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