@modusensus/dsh-mneme 0.8.2 → 0.8.4

package/test/reflection.test.js

@@ -1,226 +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);
-});
+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/reindex-backfill.test.js

@@ -1,62 +1,62 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { backfillMissingEmbeddings } from "../src/index.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createVectorIndex } from "../src/vector-index.js";
-
-// Issue #128：boot 回填曾被模型指纹门短路——任意一条嵌入成功写入 vector_meta
-// 指纹后，指纹匹配的每次启动都在门上直接 return，写入时嵌入失败（embedder 未
-// 就绪 / 服务商限流）的活跃行从此永远补不上（报告实测 88 条活跃记忆长期缺失，
-// /vector-reindex 的配额还被归档死行吃掉）。
-
-test("Issue #128: fingerprint match no longer blocks backfill; archived rows are skipped", async () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const active = service.saveWithDedupe({ type: "preference", title: "活跃", content: "内容" }).memory;
-  const dead = service.saveWithDedupe({ type: "preference", title: "死行", content: "内容" }).memory;
-  store.setArchived(dead.id, true);
-
-  // 指纹已与 embedder 一致 —— 旧的早退条件在此成立，旧实现会整场不回填。
-  const vectorIndex = createVectorIndex({ store });
-  vectorIndex.markModel("mock-model#abc", 3);
-  const embedded = [];
-  const embedder = {
-    embedSingle: async (text) => { embedded.push(text); return [1, 0, 0]; },
-    modelHash: "mock-model#abc",
-    dimension: 3
-  };
-
-  const logs = [];
-  const indexed = await backfillMissingEmbeddings({
-    store, embedder, vectorIndex,
-    logger: { info: (m) => logs.push(m) },
-    rateLimitMs: 0
-  });
-
-  assert.equal(indexed, 1, "the active row is backfilled despite the matching fingerprint");
-  assert.equal(store.getEmbeddings([active.id]).get(active.id)?.length, 3, "active row now carries a vector");
-  assert.equal(store.getEmbeddings([dead.id]).get(dead.id), undefined, "archived row is skipped");
-  assert.equal(vectorIndex.modelHash(), "mock-model#abc", "fingerprint unchanged (markModel idempotent)");
-  assert.ok(logs.some((m) => m.includes("backfilled 1")), "boot log records the backfill");
-  store.close();
-});
-
-test("Issue #128: backfill is bounded by maxTotal; the rest stays queued", async () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  for (let i = 0; i < 5; i++) {
-    service.saveWithDedupe({ type: "preference", title: `记忆${i}`, content: `内容${i}` });
-  }
-  const embedder = { embedSingle: async () => [1, 0, 0], modelHash: "h#1", dimension: 3 };
-  const vectorIndex = createVectorIndex({ store });
-
-  const indexed = await backfillMissingEmbeddings({
-    store, embedder, vectorIndex,
-    logger: { info() {} },
-    maxTotal: 4, batchSize: 2, rateLimitMs: 0
-  });
-  assert.equal(indexed, 4, "stops at the maxTotal bound");
-  assert.equal(store.needsEmbedding(10).length, 1, "remaining rows stay queued for the next boot");
-  store.close();
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { backfillMissingEmbeddings } from "../src/index.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// Issue #128：boot 回填曾被模型指纹门短路——任意一条嵌入成功写入 vector_meta
+// 指纹后，指纹匹配的每次启动都在门上直接 return，写入时嵌入失败（embedder 未
+// 就绪 / 服务商限流）的活跃行从此永远补不上（报告实测 88 条活跃记忆长期缺失，
+// /vector-reindex 的配额还被归档死行吃掉）。
+
+test("Issue #128: fingerprint match no longer blocks backfill; archived rows are skipped", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const active = service.saveWithDedupe({ type: "preference", title: "活跃", content: "内容" }).memory;
+  const dead = service.saveWithDedupe({ type: "preference", title: "死行", content: "内容" }).memory;
+  store.setArchived(dead.id, true);
+
+  // 指纹已与 embedder 一致 —— 旧的早退条件在此成立，旧实现会整场不回填。
+  const vectorIndex = createVectorIndex({ store });
+  vectorIndex.markModel("mock-model#abc", 3);
+  const embedded = [];
+  const embedder = {
+    embedSingle: async (text) => { embedded.push(text); return [1, 0, 0]; },
+    modelHash: "mock-model#abc",
+    dimension: 3
+  };
+
+  const logs = [];
+  const indexed = await backfillMissingEmbeddings({
+    store, embedder, vectorIndex,
+    logger: { info: (m) => logs.push(m) },
+    rateLimitMs: 0
+  });
+
+  assert.equal(indexed, 1, "the active row is backfilled despite the matching fingerprint");
+  assert.equal(store.getEmbeddings([active.id]).get(active.id)?.length, 3, "active row now carries a vector");
+  assert.equal(store.getEmbeddings([dead.id]).get(dead.id), undefined, "archived row is skipped");
+  assert.equal(vectorIndex.modelHash(), "mock-model#abc", "fingerprint unchanged (markModel idempotent)");
+  assert.ok(logs.some((m) => m.includes("backfilled 1")), "boot log records the backfill");
+  store.close();
+});
+
+test("Issue #128: backfill is bounded by maxTotal; the rest stays queued", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  for (let i = 0; i < 5; i++) {
+    service.saveWithDedupe({ type: "preference", title: `记忆${i}`, content: `内容${i}` });
+  }
+  const embedder = { embedSingle: async () => [1, 0, 0], modelHash: "h#1", dimension: 3 };
+  const vectorIndex = createVectorIndex({ store });
+
+  const indexed = await backfillMissingEmbeddings({
+    store, embedder, vectorIndex,
+    logger: { info() {} },
+    maxTotal: 4, batchSize: 2, rateLimitMs: 0
+  });
+  assert.equal(indexed, 4, "stops at the maxTotal bound");
+  assert.equal(store.needsEmbedding(10).length, 1, "remaining rows stay queued for the next boot");
+  store.close();
+});