@modusensus/dsh-mneme 0.2.4 → 0.2.6

package/test/reflection.test.js

@@ -0,0 +1,226 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { validateDecisions, applyDecisions } from "../src/dream/decisions.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// snapshot helper: memories eligible for consolidation (non-archived, non-summary)
+function makeSnapshot(store) {
+  const snap = new Map();
+  for (const m of store.all()) {
+    if (!m.archived && m.type !== "summary") snap.set(m.id, m);
+  }
+  return snap;
+}
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+/** Insert a memory and backdate created_at to `hoursAgo`. */
+function seedMemory(service, store, fields, hoursAgo = 48) {
+  const created = service.saveWithDedupe(fields);
+  const mem = created.memory;
+  if (hoursAgo) {
+    const old = new Date(Date.now() - hoursAgo * 3600000).toISOString();
+    store.db.prepare("UPDATE memories SET created_at = ? WHERE id = ?").run(old, mem.id);
+  }
+  return store.getById(mem.id);
+}
+
+// --- update validation ---------------------------------------------------
+
+test("update validation rejects multiple ids", () => {
+  const { store } = setup();
+  const snap = makeSnapshot(store);
+  const { ok, errors } = validateDecisions(
+    [{ action: "update", ids: ["a", "b"], content: "new" }], snap
+  );
+  assert.equal(ok, false);
+  assert.ok(errors.some((e) => e.includes("exactly one id")));
+});
+
+test("update validation rejects no actual change", () => {
+  const { store, service } = setup();
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  const snap = makeSnapshot(store);
+  const { ok, errors } = validateDecisions(
+    [{ action: "update", ids: [mem.id], content: "喜欢 Python" }], snap
+  );
+  assert.equal(ok, false);
+  assert.ok(errors.some((e) => e.includes("change at least one field")));
+});
+
+test("update validation rejects summary type", () => {
+  const { store, service } = setup();
+  const mem = seedMemory(service, store, { type: "summary", title: "总览", content: "overview" });
+  const snap = makeSnapshot(store);
+  // summary is excluded from snapshot, so also test direct: simulate by forcing it in
+  snap.set(mem.id, mem);
+  const { ok, errors } = validateDecisions(
+    [{ action: "update", ids: [mem.id], content: "new overview" }], snap
+  );
+  assert.equal(ok, false);
+  assert.ok(errors.some((e) => e.includes("summary") || e.includes("not eligible")));
+});
+
+test("update validation rejects too-young memory (< minAgeHours)", () => {
+  const { store, service } = setup();
+  const mem = seedMemory(service, store, { type: "preference", title: "新", content: "新记忆" }, 1); // 1 hour old
+  const snap = makeSnapshot(store);
+  const { ok, errors } = validateDecisions(
+    [{ action: "update", ids: [mem.id], content: "修正" }], snap, { minAgeHours: 24 }
+  );
+  assert.equal(ok, false);
+  assert.ok(errors.some((e) => e.includes("too young")));
+});
+
+test("update validation respects configurable minAgeHours", () => {
+  const { store, service } = setup();
+  const mem = seedMemory(service, store, { type: "preference", title: "新", content: "新记忆" }, 1);
+  const snap = makeSnapshot(store);
+  // minAgeHours=0 disables the age guard -> update of a 1h-old memory passes
+  const { ok, errors } = validateDecisions(
+    [{ action: "update", ids: [mem.id], content: "修正" }], snap, { minAgeHours: 0 }
+  );
+  assert.equal(ok, true, errors.join("; "));
+});
+
+test("update validation rejects > maxUpdatePerRun updates", () => {
+  const { store, service } = setup();
+  const a = seedMemory(service, store, { type: "preference", title: "A", content: "a" });
+  const b = seedMemory(service, store, { type: "preference", title: "B", content: "b" });
+  const c = seedMemory(service, store, { type: "preference", title: "C", content: "c" });
+  const snap = makeSnapshot(store);
+  const { ok, errors } = validateDecisions([
+    { action: "update", ids: [a.id], content: "a2" },
+    { action: "update", ids: [b.id], content: "b2" },
+    { action: "update", ids: [c.id], content: "c2" }
+  ], snap, { maxUpdatePerRun: 2 });
+  assert.equal(ok, false);
+  assert.ok(errors.some((e) => e.includes("too many update")));
+});
+
+test("update validation passes a single valid update", () => {
+  const { store, service } = setup();
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  const snap = makeSnapshot(store);
+  const { ok, errors } = validateDecisions(
+    [{ action: "update", ids: [mem.id], content: "喜欢 Rust" }], snap
+  );
+  assert.equal(ok, true, errors.join("; "));
+});
+
+// --- update application --------------------------------------------------
+
+test("update application changes the memory content", () => {
+  const { store, service } = setup();
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  const snap = makeSnapshot(store);
+  const decisions = [{ action: "update", ids: [mem.id], content: "喜欢 Rust" }];
+  assert.equal(validateDecisions(decisions, snap).ok, true);
+  const { applied } = applyDecisions(decisions, service);
+  assert.equal(applied, 1);
+  const updated = store.getById(mem.id);
+  assert.equal(updated.content, "喜欢 Rust");
+});
+
+test("update application is idempotent on replay", () => {
+  const { store, service } = setup();
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  const snap = makeSnapshot(store);
+  const decisions = [{ action: "update", ids: [mem.id], content: "喜欢 Rust" }];
+  applyDecisions(decisions, service);
+  const appliedAgain = applyDecisions(decisions, service);
+  assert.equal(appliedAgain.applied, 0, "replay of an already-applied update should be a no-op");
+});
+
+test("update application preserves unspecified fields", () => {
+  const { store, service } = setup();
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python", importance: 3 });
+  const snap = makeSnapshot(store);
+  const decisions = [{ action: "update", ids: [mem.id], content: "喜欢 Rust" }];
+  applyDecisions(decisions, service);
+  const updated = store.getById(mem.id);
+  assert.equal(updated.content, "喜欢 Rust");
+  assert.equal(updated.title, "语言", "title preserved");
+  assert.equal(updated.importance, 3, "importance preserved");
+});
+
+// --- failure tracking ----------------------------------------------------
+
+test("user correction records a failure_memories row", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { reflectionFailureTracking: true } });
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  service.update(mem.id, { content: "喜欢 Rust" });
+  const failures = store.listFailures();
+  assert.equal(failures.length, 1);
+  assert.equal(failures[0].failure_type, "user_correction");
+  assert.equal(failures[0].memory_id, mem.id);
+  assert.equal(failures[0].actual, "喜欢 Python");
+  assert.equal(failures[0].expected, "喜欢 Rust");
+});
+
+test("user correction records failure when only title changes", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { reflectionFailureTracking: true } });
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  service.update(mem.id, { title: "编程语言" }); // title change, content same
+  const failures = store.listFailures();
+  assert.equal(failures.length, 1, "title-only change should still record a failure");
+  assert.equal(failures[0].failure_type, "user_correction");
+});
+
+test("user correction records query context when provided", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { reflectionFailureTracking: true } });
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  service.update(mem.id, { content: "喜欢 Rust" }, { query: "用户说：不对，我喜欢 Rust" });
+  const failures = store.listFailures();
+  assert.equal(failures.length, 1);
+  assert.equal(failures[0].query, "用户说：不对，我喜欢 Rust");
+});
+
+test("user correction skips failure when nothing meaningful changes", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { reflectionFailureTracking: true } });
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python", importance: 3 });
+  service.update(mem.id, { title: "语言", content: "喜欢 Python", importance: 3 }); // identical
+  assert.equal(store.listFailures().length, 0, "no meaningful change -> no failure");
+});
+
+test("deleteOldFailures removes rows older than the cutoff", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { reflectionFailureTracking: true } });
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  service.update(mem.id, { content: "喜欢 Rust" });
+  assert.equal(store.listFailures().length, 1);
+  // cutoff in the future: everything is older, so all rows get deleted
+  const removed = store.deleteOldFailures(new Date(Date.now() + 86400000).toISOString());
+  assert.equal(removed, 1);
+  assert.equal(store.listFailures().length, 0);
+});
+
+test("failure tracking disabled by config", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { reflectionFailureTracking: false } });
+  const mem = seedMemory(service, store, { type: "preference", title: "语言", content: "喜欢 Python" });
+  service.update(mem.id, { content: "喜欢 Rust" });
+  assert.equal(store.listFailures().length, 0);
+});
+
+test("listFailures and getFailureStats work", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { reflectionFailureTracking: true } });
+  const a = seedMemory(service, store, { type: "preference", title: "A", content: "x1" });
+  const b = seedMemory(service, store, { type: "preference", title: "B", content: "y1" });
+  service.update(a.id, { content: "x2" });
+  service.update(b.id, { content: "y2" });
+  const failures = store.listFailures();
+  assert.equal(failures.length, 2);
+  const stats = store.getFailureStats();
+  assert.equal(stats.user_correction, 2);
+});

package/test/reranker.test.js

@@ -0,0 +1,197 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { LocalReranker } from "../src/reranker.js";
+
+/** Injected scorer: records (query, passage) calls, returns a fixed score. */
+function makeScorer(scoreOf) {
+  const calls = [];
+  const fn = async (query, passage) => {
+    calls.push({ query, passage });
+    return typeof scoreOf === "function" ? scoreOf(passage) : scoreOf;
+  };
+  return { fn, calls };
+}
+
+/** Fake feature-extraction engine: each input embeds to [1, k*0.25, 0, 0]. */
+function makeFakeExtractor(dim = 4, calls = []) {
+  let k = 0;
+  const fn = async (texts) => {
+    calls.push({ count: texts.length });
+    const rows = texts.map(() => {
+      const n = k++;
+      return Array.from({ length: dim }, (__, j) => (j === 0 ? 1 : j === 1 ? n * 0.25 : 0));
+    });
+    const flat = Float32Array.from(rows.flat());
+    return { data: flat, dims: [texts.length, dim] };
+  };
+  fn.dispose = () => {
+    fn.disposed = true;
+  };
+  return fn;
+}
+
+/** Fake text-classification engine exposing tokenizer + model for the tc path. */
+function makeFakeTc(logitsPerRow) {
+  const tokenizer = (texts, opts) => ({ texts, text_pair: opts.text_pair });
+  const model = async (inputs) => {
+    const n = inputs.texts.length;
+    const flat = new Float32Array(logitsPerRow.slice(0, n * 2));
+    return { logits: { data: flat, dims: [n, 2] } };
+  };
+  return { tokenizer, model, dispose: () => {} };
+}
+
+function candidates(ids) {
+  return ids.map((id) => ({ id, title: `T-${id}`, content: `C-${id}` }));
+}
+
+test("init with injected scorePair skips model loading", async () => {
+  let factoryCalled = false;
+  const { fn, calls } = makeScorer(0.7);
+  const r = new LocalReranker({
+    scorePair: fn,
+    engineFactory: async () => {
+      factoryCalled = true;
+      throw new Error("should never load");
+    }
+  });
+  await r.init();
+  assert.equal(factoryCalled, false);
+  const out = await r.rerank("q", candidates(["a"]));
+  assert.deepEqual(out, [{ id: "a", score: 0.7 }]);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].query, "q");
+  assert.equal(calls[0].passage, "T-a\nC-a");
+});
+
+test("rerank returns results sorted by descending score", async () => {
+  const { fn } = makeScorer((p) => (p.includes("A") ? 0.9 : p.includes("B") ? 0.5 : 0.2));
+  const r = new LocalReranker({ scorePair: fn });
+  await r.init();
+  const out = await r.rerank("q", candidates(["A", "B", "C"]));
+  assert.deepEqual(out.map((x) => x.id), ["A", "B", "C"]);
+  assert.deepEqual(out.map((x) => x.score), [0.9, 0.5, 0.2]);
+});
+
+test("rerank returns [] for empty candidates", async () => {
+  const { fn } = makeScorer(0.9);
+  const r = new LocalReranker({ scorePair: fn });
+  await r.init();
+  assert.deepEqual(await r.rerank("q", []), []);
+});
+
+test("rerank drops candidates below scoreThreshold", async () => {
+  const { fn } = makeScorer((p) => (p.includes("A") ? 0.8 : p.includes("B") ? 0.4 : 0.05));
+  const r = new LocalReranker({ scorePair: fn, scoreThreshold: 0.3 });
+  await r.init();
+  const out = await r.rerank("q", candidates(["A", "B", "C"]));
+  assert.deepEqual(out.map((x) => x.id), ["A", "B"]);
+});
+
+test("rerank clamps scores into 0..1", async () => {
+  const { fn } = makeScorer((p) => (p.includes("A") ? 1.5 : p.includes("B") ? -0.2 : NaN));
+  const r = new LocalReranker({ scorePair: fn, scoreThreshold: 0 });
+  await r.init();
+  const out = await r.rerank("q", candidates(["A", "B", "C"]));
+  assert.deepEqual(out.map((x) => x.score), [1, 0, 0]);
+});
+
+test("rerank truncates to maxCandidates", async () => {
+  const { fn, calls } = makeScorer(0.6);
+  const r = new LocalReranker({ scorePair: fn, maxCandidates: 2 });
+  await r.init();
+  const out = await r.rerank("q", candidates(["a", "b", "c", "d"]));
+  assert.equal(calls.length, 2);
+  assert.equal(out.length, 2);
+});
+
+test("passage falls back to title when content is missing", async () => {
+  const { fn, calls } = makeScorer(0.8);
+  const r = new LocalReranker({ scorePair: fn });
+  await r.init();
+  await r.rerank("q", [{ id: "x", title: "only-title", content: "" }]);
+  assert.equal(calls[0].passage, "only-title");
+});
+
+test("rerank propagates injected scorer failures", async () => {
+  const bad = async () => {
+    throw new Error("scorer boom");
+  };
+  const r = new LocalReranker({ scorePair: bad });
+  await r.init();
+  await assert.rejects(() => r.rerank("q", candidates(["a"])), /scorer boom/);
+});
+
+test("rerank throws on non-array candidates", async () => {
+  const r = new LocalReranker({ scorePair: async () => 0.5 });
+  await r.init();
+  await assert.rejects(() => r.rerank("q", "not-an-array"), /array/);
+});
+
+test("init throws when no strategy can load", async () => {
+  const r = new LocalReranker({
+    engineFactory: async () => {
+      throw new Error("Unsupported pipeline");
+    }
+  });
+  await assert.rejects(() => r.init(), /LocalReranker failed to load/);
+});
+
+test("init cascades rerank -> tc -> feature-extraction and batches", async () => {
+  const calls = [];
+  const loader = async (task) => {
+    if (task === "feature-extraction") return makeFakeExtractor(4, calls);
+    throw new Error(`Unsupported pipeline: ${task}`);
+  };
+  const r = new LocalReranker({ engineFactory: loader, batchSize: 2 });
+  await r.init();
+  const out = await r.rerank("q", candidates(["a", "b", "c"]));
+  // Query k=0 [1,0,0,0]; a,b,c embed at k=1..3 -> cosine 0.970, 0.894, 0.8,
+  // all above the default threshold.
+  assert.equal(out.length, 3);
+  assert.deepEqual(out.map((x) => x.id), ["a", "b", "c"]);
+  assert.ok(out[0].score >= out[1].score && out[1].score >= out[2].score);
+  // Query embed (cached) + two batches of size 2 and 1.
+  assert.deepEqual(calls.map((c) => c.count), [1, 2, 1]);
+  // Query vector is cached: a second rerank only makes batch calls.
+  await r.rerank("q", candidates(["a", "b", "c"]));
+  assert.deepEqual(calls.map((c) => c.count), [1, 2, 1, 2, 1]);
+});
+
+test("text-classification strategy scores via logit delta", async () => {
+  const loader = async (task) => {
+    if (task === "text-classification") return makeFakeTc([0, 1, 0, 0, -2, 2]);
+    throw new Error(`Unsupported pipeline: ${task}`);
+  };
+  const r = new LocalReranker({ engineFactory: loader });
+  await r.init();
+  const out = await r.rerank("q", candidates(["A", "B", "C"]));
+  // sigmoid(1-0)=0.731, sigmoid(0)=0.5, sigmoid(2-(-2))=0.982.
+  assert.deepEqual(out.map((x) => x.id), ["C", "A", "B"]);
+  assert.ok(Math.abs(out[0].score - 0.982) < 1e-3);
+  assert.ok(Math.abs(out[1].score - 0.731) < 1e-3);
+  assert.ok(Math.abs(out[2].score - 0.5) < 1e-3);
+});
+
+test("modelHash follows the embedder convention", () => {
+  const a = new LocalReranker({ model: "Xenova/bge-reranker-base" });
+  const b = new LocalReranker({ model: "Xenova/bge-reranker-base" });
+  assert.equal(a.modelHash, b.modelHash);
+  assert.match(a.modelHash, /^Xenova\/bge-reranker-base#[0-9a-f]+$/);
+  assert.notEqual(a.modelHash, new LocalReranker({ model: "other/model" }).modelHash);
+});
+
+test("dispose releases the loaded pipeline", async () => {
+  const extractor = makeFakeExtractor(4);
+  const r = new LocalReranker({
+    engineFactory: async (task) => {
+      if (task === "feature-extraction") return extractor;
+      throw new Error("Unsupported pipeline");
+    }
+  });
+  await r.init();
+  assert.ok(r.pipeline);
+  r.dispose();
+  assert.equal(r.pipeline, null);
+  assert.equal(extractor.disposed, true);
+});

package/test/semantic.test.js

@@ -0,0 +1,123 @@
+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";
+
+const DIM = 4;
+
+// Mock embedder: maps a query to a fixed vector so tests exercise the wiring
+// without downloading any model. Prefer embedSingle (local embedders); a
+// legacy embed() fallback is also exercised in one test.
+function mockEmbedder(overrides = {}) {
+  return {
+    embedSingle: async (text) => [1, 0, 0, 0],
+    embed: async (texts) => texts.map(() => [1, 0, 0, 0]),
+    modelHash: "mock#abc",
+    dimension: DIM,
+    ...overrides
+  };
+}
+
+function setup(embedder = mockEmbedder()) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const vectorIndex = createVectorIndex({ store });
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vectorIndex);
+  return { store, service, vectorIndex };
+}
+
+test("vector-index stores and searches embeddings with model metadata", async () => {
+  const { store, service, vectorIndex } = setup();
+  const m1 = service.saveWithDedupe({ type: "preference", title: "猫", content: "喜欢猫" });
+  vectorIndex.saveEmbedding(m1.memory.id, [1, 0, 0, 0]);
+  const m2 = service.saveWithDedupe({ type: "preference", title: "狗", content: "喜欢狗" });
+  vectorIndex.saveEmbedding(m2.memory.id, [0, 1, 0, 0]);
+
+  const hits = vectorIndex.search([1, 0, 0, 0], { threshold: 0.5 });
+  assert.ok(hits.length >= 1);
+  assert.equal(hits[0].id, m1.memory.id, "best vector match ranks first");
+
+  vectorIndex.markModel("mock#abc", DIM);
+  const stats = vectorIndex.getStats();
+  assert.equal(stats.modelHash, "mock#abc");
+  assert.equal(stats.dimension, DIM);
+  assert.equal(stats.embeddedCount, 2);
+
+  vectorIndex.deleteEmbedding(m2.memory.id);
+  assert.equal(vectorIndex.getEmbedding(m2.memory.id), undefined);
+});
+
+test("searchMemories auto = keyword first + vector fill", async () => {
+  const { service } = setup();
+  const m1 = service.saveWithDedupe({ type: "preference", title: "猫", content: "喜欢猫" });
+  const m2 = service.saveWithDedupe({ type: "preference", title: "狗狗", content: "喜欢狗和猫" });
+
+  const rows = await service.searchMemories("猫", { mode: "auto", topK: 10 });
+  assert.ok(rows.some((m) => m.id === m1.memory.id), "keyword hit present");
+  assert.ok(rows.some((m) => m.id === m2.memory.id), "vector fill present");
+});
+
+test("searchMemories hybrid = vector leads, keyword fills", async () => {
+  const { service, vectorIndex } = setup();
+  // "狗" is semantically stored under the vector; literal query misses it.
+  const mDog = service.saveWithDedupe({ type: "preference", title: "金毛", content: "金毛是狗" });
+  vectorIndex.saveEmbedding(mDog.memory.id, [1, 0, 0, 0]);
+  const mCat = service.saveWithDedupe({ type: "preference", title: "猫", content: "喜欢猫" });
+  vectorIndex.saveEmbedding(mCat.memory.id, [0, 0, 1, 0]);
+
+  const rows = await service.searchMemories("狗", { mode: "hybrid", topK: 10 });
+  // mock vector always returns the fixed [1,0,0,0] vector, which matches the
+  // dog embedding above → dog should surface even though keyword matches "金毛".
+  assert.ok(rows.some((m) => m.id === mDog.memory.id), "vector lead surfaces dog");
+});
+
+test("searchMemories keyword mode never touches the embedder", async () => {
+  let called = 0;
+  const { service } = setup(mockEmbedder({
+    embedSingle: async () => { called++; return [1, 0, 0, 0]; }
+  }));
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文交流" });
+  const rows = await service.searchMemories("中文", { mode: "keyword", topK: 10 });
+  assert.equal(rows.length, 1);
+  assert.equal(called, 0, "embedder must not be called in keyword mode");
+});
+
+test("searchMemories reranks merged candidates when a reranker is installed", async () => {
+  const { service } = setup();
+  const a = service.saveWithDedupe({ type: "preference", title: "猫", content: "喜欢猫" });
+  const b = service.saveWithDedupe({ type: "preference", title: "猫猫", content: "猫粮" });
+  // b is newer, so keyword order is [b, a]. The reranker reverses scores so
+  // the last candidate (a) wins — asserting the rerank actually reordered.
+  const reranker = {
+    rerank: async (query, candidates) =>
+      candidates.map((c, i) => ({ id: c.id, score: i })).sort((x, y) => y.score - x.score)
+  };
+  service.setReranker(reranker);
+
+  const rows = await service.searchMemories("猫", { mode: "keyword", topK: 10 });
+  assert.equal(rows[0].title, "猫", "rerank reorders to the higher score");
+  assert.equal(typeof rows[0].score, "number", "reranked rows carry a score");
+});
+
+test("searchMemories survives a throwing embedder (degrades to keyword)", async () => {
+  const { service } = setup(mockEmbedder({
+    embedSingle: async () => { throw new Error("model unavailable"); }
+  }));
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文交流" });
+  const rows = await service.searchMemories("中文", { mode: "auto", topK: 10 });
+  assert.equal(rows.length, 1, "keyword fallback still works");
+});
+
+test("legacy embedder (embed-only) is adapted by searchMemories", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const legacy = { embed: async (q) => [1, 0, 0, 0] };
+  service.setEmbedder(legacy); // no embedSingle, no vectorIndex
+  service.saveWithDedupe({ type: "preference", title: "猫", content: "喜欢猫" });
+  store.setEmbedding(service.all()[0].id, [1, 0, 0, 0]);
+
+  const rows = await service.searchMemories("猫", { mode: "vector", topK: 10 });
+  assert.ok(rows.some((m) => m.title === "猫"), "legacy embed() path works");
+});