recallnest 3.0.0 → 3.0.1

package/src/__tests__/skill-verifier.test.ts

@@ -1,122 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { verifyDraft, tokensOf, type VerifyDraft, type VerifyEvidence } from "../skill-verifier.js";
-
-describe("verifyDraft — tool coverage", () => {
-  test("passes when draft tools ⊆ evidence tools and narrative resonates", () => {
-    const draft: VerifyDraft = {
-      tools: ["git", "bun test"],
-      summary: "Fix the failing deploy by resetting the database migration",
-      steps: ["reset migration", "rerun deploy"],
-    };
-    const evidence: VerifyEvidence[] = [
-      { text: "deploy failed, reset migration then rerun deploy worked", tools: ["git", "bun test"] },
-      { text: "another deploy reset migration fix", tools: ["git"] },
-    ];
-    const r = verifyDraft(draft, evidence);
-    expect(r.ok).toBe(true);
-    expect(r.coverage).toBe(1);
-    expect(r.unmappedTools).toEqual([]);
-  });
-
-  test("fails coverage when draft claims a tool no evidence used (hallucinated command)", () => {
-    const draft: VerifyDraft = {
-      tools: ["fictional_cmd", "another_fake"],
-      summary: "deploy reset migration rerun",
-      steps: [],
-    };
-    const evidence: VerifyEvidence[] = [
-      { text: "deploy reset migration rerun worked", tools: ["git"] },
-    ];
-    const r = verifyDraft(draft, evidence);
-    expect(r.ok).toBe(false);
-    expect(r.reason).toContain("coverage");
-    expect(r.unmappedTools).toContain("fictional_cmd");
-  });
-
-  test("empty draft tools → coverage 1 (nothing to hallucinate), judged on resonance only", () => {
-    const draft: VerifyDraft = { tools: [], summary: "deploy reset migration", steps: [] };
-    const evidence: VerifyEvidence[] = [
-      { text: "deploy reset migration done", tools: [] },
-      { text: "deploy reset migration again", tools: [] },
-    ];
-    const r = verifyDraft(draft, evidence);
-    expect(r.coverage).toBe(1);
-    expect(r.ok).toBe(true);
-  });
-
-  test("coverage exactly 0.5 (1 of 2 tools mapped) passes the strict < 0.5 threshold", () => {
-    const r = verifyDraft(
-      { tools: ["git", "fake_cmd"], summary: "deploy reset migration rerun", steps: [] },
-      [{ text: "deploy reset migration rerun", tools: ["git"] }],
-    );
-    expect(r.coverage).toBe(0.5);
-    expect(r.reason ?? "").not.toContain("coverage");
-    expect(r.unmappedTools).toContain("fake_cmd");
-  });
-});
-
-describe("verifyDraft — evidence resonance", () => {
-  test("fails resonance when narrative shares no tokens with evidence", () => {
-    const draft: VerifyDraft = {
-      tools: [],
-      summary: "quantum entanglement teleportation protocol alpha",
-      steps: ["calibrate flux capacitor"],
-    };
-    const evidence: VerifyEvidence[] = [
-      { text: "deploy database migration reset rerun", tools: [] },
-      { text: "another unrelated commit push branch", tools: [] },
-    ];
-    const r = verifyDraft(draft, evidence);
-    expect(r.ok).toBe(false);
-    expect(r.reason).toContain("resonance");
-  });
-
-  test("CJK: passes resonance on Chinese pattern + cases sharing ≥2 bigrams", () => {
-    const draft: VerifyDraft = {
-      tools: [],
-      summary: "重启服务前先检查代理端口配置",
-      steps: ["确认代理端口", "重启服务"],
-    };
-    const evidence: VerifyEvidence[] = [
-      { text: "重启服务后代理端口失效，检查配置解决", tools: [] },
-      { text: "代理端口配置错误导致重启失败", tools: [] },
-    ];
-    const r = verifyDraft(draft, evidence);
-    expect(r.ok).toBe(true);
-    expect(r.resonance).toBeGreaterThanOrEqual(0.5);
-  });
-});
-
-describe("verifyDraft — boundaries", () => {
-  test("empty evidence → no-evidence verdict", () => {
-    const r = verifyDraft({ tools: ["git"], summary: "x", steps: [] }, []);
-    expect(r.ok).toBe(false);
-    expect(r.reason).toBe("no-evidence");
-  });
-
-  test("verdict always carries coverage + resonance numbers", () => {
-    const r = verifyDraft(
-      { tools: ["git"], summary: "deploy reset migration rerun", steps: [] },
-      [{ text: "deploy reset migration rerun", tools: ["git"] }],
-    );
-    expect(typeof r.coverage).toBe("number");
-    expect(typeof r.resonance).toBe("number");
-  });
-});
-
-describe("tokensOf", () => {
-  test("extracts ASCII identifiers ≥4 chars, drops stopwords", () => {
-    const toks = tokensOf("deploy the database migration");
-    expect(toks.has("deploy")).toBe(true);
-    expect(toks.has("database")).toBe(true);
-    expect(toks.has("migration")).toBe(true);
-    expect(toks.has("the")).toBe(false);
-  });
-
-  test("extracts CJK 2-gram bigrams", () => {
-    const toks = tokensOf("重启服务");
-    expect(toks.has("重启")).toBe(true);
-    expect(toks.has("启服")).toBe(true);
-    expect(toks.has("服务")).toBe(true);
-  });
-});

package/src/__tests__/source-heartbeat.test.ts

@@ -1,254 +0,0 @@
-import { describe, expect, it, beforeEach, afterEach } from "bun:test";
-import { existsSync, mkdirSync, rmSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  readHeartbeats,
-  writeHeartbeat,
-  checkSourceStaleness,
-  formatAge,
-  type HeartbeatFile,
-} from "../source-heartbeat.js";
-import { runDataCheckup } from "../data-checkup.js";
-import type { MemoryEntry, MemoryStore } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function tmpHeartbeatPath(): string {
-  const dir = join(tmpdir(), `recallnest-test-heartbeat-${Date.now()}`);
-  mkdirSync(dir, { recursive: true });
-  return join(dir, "source-heartbeat.json");
-}
-
-function makeEntry(id: string): MemoryEntry {
-  return {
-    id,
-    text: "test memory",
-    vector: [1, 0, 0, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: JSON.stringify({
-      evolution: {
-        status: "active",
-        version: 1,
-        accessCount: 0,
-        lastAccessedAt: null,
-        supersededBy: null,
-        consolidatedInto: null,
-        contributedToPattern: null,
-        sourceMemories: [],
-        validFrom: Date.now(),
-        validUntil: null,
-      },
-    }),
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]): Pick<MemoryStore, "list" | "listPage" | "stats" | "getVectors"> {
-  return {
-    // 复刻真实 store:list() 为性能不返回向量,诊断检查经 getVectors 补回。
-    async list() { return entries.map(e => ({ ...e, vector: [] })); },
-    async listPage(opts: { limit?: number; offset?: number } = {}) {
-      const { limit = 1000, offset = 0 } = opts;
-      return entries.slice(offset, offset + limit).map(e => ({ ...e, vector: [] }));
-    },
-    async stats() {
-      return { totalCount: entries.length, scopeCounts: {}, categoryCounts: {} };
-    },
-    async getVectors(ids: string[]) {
-      const map = new Map<string, number[]>();
-      for (const e of entries) {
-        if (ids.includes(e.id) && e.vector && e.vector.length > 0) map.set(e.id, e.vector);
-      }
-      return map;
-    },
-  } as Pick<MemoryStore, "list" | "listPage" | "stats" | "getVectors">;
-}
-
-// ---------------------------------------------------------------------------
-// Tests: readHeartbeats / writeHeartbeat
-// ---------------------------------------------------------------------------
-
-describe("source-heartbeat", () => {
-  let tmpPath: string;
-
-  beforeEach(() => {
-    tmpPath = tmpHeartbeatPath();
-  });
-
-  afterEach(() => {
-    try {
-      const dir = join(tmpPath, "..");
-      rmSync(dir, { recursive: true, force: true });
-    } catch { /* ignore */ }
-  });
-
-  it("returns empty object when file does not exist", () => {
-    const result = readHeartbeats(tmpPath);
-    expect(result).toEqual({});
-  });
-
-  it("writes and reads back a heartbeat", () => {
-    writeHeartbeat("obsidian", 42, [], tmpPath);
-
-    const heartbeats = readHeartbeats(tmpPath);
-    expect(Object.keys(heartbeats)).toEqual(["obsidian"]);
-    expect(heartbeats.obsidian.source).toBe("obsidian");
-    expect(heartbeats.obsidian.recordsIngested).toBe(42);
-    expect(heartbeats.obsidian.errors).toEqual([]);
-    expect(heartbeats.obsidian.lastIngest).toBeTruthy();
-  });
-
-  it("updates existing source without losing other sources", () => {
-    writeHeartbeat("obsidian", 10, [], tmpPath);
-    writeHeartbeat("email", 5, ["timeout"], tmpPath);
-    writeHeartbeat("obsidian", 20, [], tmpPath); // update
-
-    const heartbeats = readHeartbeats(tmpPath);
-    expect(Object.keys(heartbeats).sort()).toEqual(["email", "obsidian"]);
-    expect(heartbeats.obsidian.recordsIngested).toBe(20);
-    expect(heartbeats.email.recordsIngested).toBe(5);
-    expect(heartbeats.email.errors).toEqual(["timeout"]);
-  });
-
-  it("caps stored errors to 10", () => {
-    const manyErrors = Array.from({ length: 15 }, (_, i) => `error-${i}`);
-    writeHeartbeat("broken", 0, manyErrors, tmpPath);
-
-    const heartbeats = readHeartbeats(tmpPath);
-    expect(heartbeats.broken.errors.length).toBe(10);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: checkSourceStaleness
-// ---------------------------------------------------------------------------
-
-describe("checkSourceStaleness", () => {
-  let tmpPath: string;
-
-  beforeEach(() => {
-    tmpPath = tmpHeartbeatPath();
-  });
-
-  afterEach(() => {
-    try {
-      rmSync(join(tmpPath, ".."), { recursive: true, force: true });
-    } catch { /* ignore */ }
-  });
-
-  it("returns empty for fresh sources", () => {
-    writeHeartbeat("obsidian", 10, [], tmpPath);
-    const stale = checkSourceStaleness(7, tmpPath);
-    expect(stale).toEqual([]);
-  });
-
-  it("detects stale sources", () => {
-    // Manually write a stale heartbeat
-    const staleDate = new Date(Date.now() - 10 * 86_400_000).toISOString();
-    const heartbeats: HeartbeatFile = {
-      old_source: {
-        source: "old_source",
-        lastIngest: staleDate,
-        recordsIngested: 5,
-        errors: [],
-      },
-    };
-    const { writeFileSync } = require("node:fs");
-    writeFileSync(tmpPath, JSON.stringify(heartbeats));
-
-    const stale = checkSourceStaleness(7, tmpPath);
-    expect(stale.length).toBe(1);
-    expect(stale[0].source).toBe("old_source");
-    expect(stale[0].daysSince).toBeGreaterThanOrEqual(9);
-  });
-
-  it("returns empty for missing file", () => {
-    const stale = checkSourceStaleness(7, "/tmp/nonexistent-path.json");
-    expect(stale).toEqual([]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: formatAge
-// ---------------------------------------------------------------------------
-
-describe("formatAge", () => {
-  it("returns 'just now' for recent timestamps", () => {
-    expect(formatAge(new Date().toISOString())).toBe("just now");
-  });
-
-  it("returns hours for <24h", () => {
-    const twoHoursAgo = new Date(Date.now() - 2 * 3_600_000).toISOString();
-    expect(formatAge(twoHoursAgo)).toBe("2h ago");
-  });
-
-  it("returns days for >=24h", () => {
-    const threeDaysAgo = new Date(Date.now() - 3 * 86_400_000).toISOString();
-    expect(formatAge(threeDaysAgo)).toBe("3d ago");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: data_checkup integration
-// ---------------------------------------------------------------------------
-
-describe("data_checkup with source_health", () => {
-  let tmpPath: string;
-
-  beforeEach(() => {
-    tmpPath = tmpHeartbeatPath();
-  });
-
-  afterEach(() => {
-    try {
-      rmSync(join(tmpPath, ".."), { recursive: true, force: true });
-    } catch { /* ignore */ }
-  });
-
-  it("includes source_health check (8 checks total)", async () => {
-    const entries = [makeEntry("a"), makeEntry("b")];
-    const report = await runDataCheckup({
-      store: createMockStore(entries),
-      openConflictCount: 0,
-      heartbeatPath: tmpPath,
-    });
-
-    expect(report.checks.length).toBe(8);
-    const sourceCheck = report.checks.find((c) => c.name === "source_health");
-    expect(sourceCheck).toBeTruthy();
-    expect(sourceCheck!.status).toBe("ok");
-    expect(sourceCheck!.detail).toContain("No connector sources tracked yet");
-  });
-
-  it("reports warning for stale sources", async () => {
-    // Write a stale heartbeat
-    const staleDate = new Date(Date.now() - 10 * 86_400_000).toISOString();
-    const heartbeats: HeartbeatFile = {
-      email: {
-        source: "email",
-        lastIngest: staleDate,
-        recordsIngested: 5,
-        errors: [],
-      },
-    };
-    const { writeFileSync } = require("node:fs");
-    writeFileSync(tmpPath, JSON.stringify(heartbeats));
-
-    const entries = [makeEntry("a")];
-    const report = await runDataCheckup({
-      store: createMockStore(entries),
-      openConflictCount: 0,
-      heartbeatPath: tmpPath,
-    });
-
-    const sourceCheck = report.checks.find((c) => c.name === "source_health");
-    expect(sourceCheck).toBeTruthy();
-    expect(sourceCheck!.status).toBe("warning");
-    expect(sourceCheck!.detail).toContain("stale");
-  });
-});

package/src/__tests__/stable-context-length-contract.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { selectStableResults } from "../context-composer-stable-selection.js";
-import { ResumeContextResponseSchema } from "../session-schema.js";
-import type { RetrievalResult } from "../retriever.js";
-
-// selectStableResults 产出的行必须过得了 stableContext 的 schema 上限。
-// 这条曾经断过：formatStableResult 截到 230、schema 上限 220，中间的
-// interleaveUnique（context-composer-stable.ts:199-206）不再截一次，
-// 于是 221~230 字符的行会让 composeResumeContext 末尾的
-// ResumeContextResponseSchema.parse 抛错，**整个 resume_context 调用失败**
-// —— 不是降级，是抛异常。实测 14 条真实问法里 1 条命中。
-//
-// 用长文本喂进去，逼出最长可能的输出，再拿真 schema 验，
-// 这样将来任一侧的数字被改动都会在这里红，而不是等生产上抛。
-
-const SCHEMA_MAX = 220;
-
-function longPreference(): RetrievalResult {
-  return {
-    entry: {
-      id: "test-long-pref",
-      // 远超上限的正文，确保格式化后会吃满截断长度
-      text: `用户确立的一条长期偏好：${"跨端协作时先确认目标仓库与路径再动手，".repeat(30)}`,
-      vector: [],
-      category: "preferences",
-      scope: "memory:pivot",
-      importance: 0.9,
-      timestamp: Date.now(),
-    },
-    score: 1,
-    sources: {},
-  } as RetrievalResult;
-}
-
-describe("stableContext 长度契约", () => {
-  it("超长偏好格式化后不超过 schema 上限", () => {
-    const lines = selectStableResults("preferences", [longPreference()], 3, {
-      taskSeed: "跨端协作要注意什么",
-    });
-    expect(lines.length).toBeGreaterThan(0);
-    for (const line of lines) {
-      expect(line.length).toBeLessThanOrEqual(SCHEMA_MAX);
-    }
-  });
-
-  it("这些行能通过真实的 ResumeContextResponseSchema", () => {
-    const stableContext = selectStableResults("preferences", [longPreference()], 3, {
-      taskSeed: "跨端协作要注意什么",
-    });
-    // 只验长度这一维：其余必填字段给最小合法值，schema 变动时这里也会跟着红
-    expect(() =>
-      ResumeContextResponseSchema.parse({
-        summary: "test",
-        generatedAt: new Date().toISOString(),
-        stableContext,
-        relevantPatterns: [],
-        recentCases: [],
-      }),
-    ).not.toThrow();
-  });
-});

package/src/__tests__/store-patch-metadata.test.ts

@@ -1,235 +0,0 @@
-/**
- * Tests for the store-level metadata write channel (P0 Track A):
- * - update() atomic upsert via mergeInsert (no delete+add vanish window)
- * - patchMetadata() per-id serial queue: no lost increments under concurrency,
- *   rejection isolation, queue self-cleanup, prefix/full-id queue sharing
- * - listPage() true DB-level pagination with category filter and includeVector
- */
-import { afterEach, describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { MemoryStore, type MemoryEntry } from "../store.js";
-
-const cleanupPaths: string[] = [];
-
-afterEach(() => {
-  while (cleanupPaths.length > 0) {
-    const target = cleanupPaths.pop();
-    if (target) {
-      rmSync(target, { recursive: true, force: true });
-    }
-  }
-});
-
-function createStore(): MemoryStore {
-  const dbPath = mkdtempSync(join(tmpdir(), "recallnest-patch-meta-"));
-  cleanupPaths.push(dbPath);
-  return new MemoryStore({ dbPath, vectorDim: 3 });
-}
-
-async function seed(store: MemoryStore, overrides: Partial<MemoryEntry> = {}): Promise<MemoryEntry> {
-  return store.store({
-    text: "patch metadata target",
-    vector: [1, 0, 0],
-    category: "cases",
-    scope: "project:patch-test",
-    importance: 0.6,
-    metadata: "{}",
-    ...overrides,
-  });
-}
-
-describe("MemoryStore.update (mergeInsert upsert)", () => {
-  it("keeps the row continuously visible and intact after update", async () => {
-    const store = createStore();
-    const entry = await seed(store);
-
-    const updated = await store.update(entry.id, { metadata: JSON.stringify({ marker: 1 }) });
-    expect(updated).not.toBeNull();
-
-    // Immediately readable by id, by list, and by vector search
-    const byId = await store.getById(entry.id);
-    expect(byId?.id).toBe(entry.id);
-    expect(JSON.parse(byId?.metadata || "{}").marker).toBe(1);
-
-    const listed = await store.list(["project:patch-test"]);
-    expect(listed.map(e => e.id)).toContain(entry.id);
-
-    const hits = await store.vectorSearch([1, 0, 0], 5, 0, ["project:patch-test"]);
-    expect(hits.map(h => h.entry.id)).toContain(entry.id);
-
-    // Vector column survived the upsert
-    const vectors = await store.getVectors([entry.id]);
-    expect(vectors.get(entry.id)).toEqual([1, 0, 0]);
-
-    // No duplicate row was created
-    const all = await store.list(["project:patch-test"], undefined, 100, 0);
-    expect(all.filter(e => e.id === entry.id)).toHaveLength(1);
-  });
-});
-
-describe("MemoryStore.patchMetadata", () => {
-  it("does not lose increments under 20 concurrent mixed patches on one id", async () => {
-    const store = createStore();
-    const entry = await seed(store);
-
-    const jobs: Array<Promise<unknown>> = [];
-    for (let i = 0; i < 10; i++) {
-      jobs.push(store.patchMetadata(entry.id, meta => {
-        const usage = (meta.usage as Record<string, unknown> | undefined) ?? {};
-        const count = typeof usage.useCount === "number" ? usage.useCount : 0;
-        meta.usage = { ...usage, useCount: count + 1 };
-        return meta;
-      }));
-      jobs.push(store.patchMetadata(entry.id, meta => {
-        const count = typeof meta.accessCount === "number" ? meta.accessCount : 0;
-        meta.accessCount = count + 1;
-        return meta;
-      }));
-    }
-    await Promise.all(jobs);
-
-    const after = await store.getById(entry.id);
-    const meta = JSON.parse(after?.metadata || "{}");
-    expect(meta.usage.useCount).toBe(10);
-    expect(meta.accessCount).toBe(10);
-  });
-
-  it("rejects the failing patch only; later patches still run; queue self-cleans", async () => {
-    const store = createStore();
-    const entry = await seed(store);
-
-    const first = store.patchMetadata(entry.id, meta => {
-      meta.step = 1;
-      return meta;
-    });
-    const failing = store.patchMetadata(entry.id, () => {
-      throw new Error("boom");
-    });
-    const third = store.patchMetadata(entry.id, meta => {
-      meta.step = 3;
-      return meta;
-    });
-
-    await expect(failing).rejects.toThrow("boom");
-    await first;
-    await third;
-
-    const after = await store.getById(entry.id);
-    expect(JSON.parse(after?.metadata || "{}").step).toBe(3);
-    expect(store.pendingMetadataPatchCount).toBe(0);
-  });
-
-  it("routes prefix and full-id callers through the same queue", async () => {
-    const store = createStore();
-    const entry = await seed(store);
-    // getById prefix semantics = string prefix (LIKE 'xxx%'), so take the
-    // first 8 hex chars (the segment before the first hyphen).
-    const prefix = entry.id.slice(0, 8);
-
-    const jobs: Array<Promise<unknown>> = [];
-    for (let i = 0; i < 10; i++) {
-      jobs.push(store.patchMetadata(entry.id, meta => {
-        const count = typeof meta.n === "number" ? meta.n : 0;
-        meta.n = count + 1;
-        return meta;
-      }));
-      jobs.push(store.patchMetadata(prefix, meta => {
-        const count = typeof meta.n === "number" ? meta.n : 0;
-        meta.n = count + 1;
-        return meta;
-      }));
-    }
-    await Promise.all(jobs);
-
-    const after = await store.getById(entry.id);
-    expect(JSON.parse(after?.metadata || "{}").n).toBe(20);
-    expect(store.pendingMetadataPatchCount).toBe(0);
-  });
-
-  it("returns null for a missing id without queue residue", async () => {
-    const store = createStore();
-    await seed(store); // initialize table
-    const result = await store.patchMetadata("00000000-0000-4000-8000-000000000000", meta => meta);
-    expect(result).toBeNull();
-    // settle the no-op queue entry
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(store.pendingMetadataPatchCount).toBe(0);
-  });
-
-  it("enforces scope permissions like update()", async () => {
-    const store = createStore();
-    const entry = await seed(store);
-    await expect(
-      store.patchMetadata(entry.id, meta => meta, ["project:other"]),
-    ).rejects.toThrow(/outside accessible scopes/);
-  });
-});
-
-describe("MemoryStore.listPage", () => {
-  it("paginates at the DB level with category pushdown", async () => {
-    const store = createStore();
-    for (let i = 0; i < 7; i++) {
-      await seed(store, { text: `case ${i}`, category: "cases" });
-    }
-    for (let i = 0; i < 3; i++) {
-      await seed(store, { text: `pattern ${i}`, category: "patterns", vector: [0, 1, 0] });
-    }
-
-    const page1 = await store.listPage({ scopeFilter: ["project:patch-test"], category: "cases", limit: 4, offset: 0 });
-    const page2 = await store.listPage({ scopeFilter: ["project:patch-test"], category: "cases", limit: 4, offset: 4 });
-    expect(page1).toHaveLength(4);
-    expect(page2).toHaveLength(3);
-    expect([...page1, ...page2].every(e => e.category === "cases")).toBe(true);
-    // No overlap between pages
-    const ids = new Set([...page1, ...page2].map(e => e.id));
-    expect(ids.size).toBe(7);
-
-    const patterns = await store.listPage({ scopeFilter: ["project:patch-test"], category: "patterns", limit: 100 });
-    expect(patterns).toHaveLength(3);
-  });
-
-  it("omits vectors by default and returns them with includeVector", async () => {
-    const store = createStore();
-    await seed(store);
-
-    const [bare] = await store.listPage({ scopeFilter: ["project:patch-test"], limit: 1 });
-    expect(bare.vector).toEqual([]);
-
-    const [withVec] = await store.listPage({ scopeFilter: ["project:patch-test"], limit: 1, includeVector: true });
-    expect(withVec.vector).toEqual([1, 0, 0]);
-  });
-});
-
-describe("MemoryStore.repairSingletonVersionGroups", () => {
-  it("dissolves only singleton groups and preserves all unrelated metadata", async () => {
-    const store = createStore();
-    const singleton = await seed(store, {
-      text: "singleton",
-      metadata: JSON.stringify({
-        version_group: "vg-single",
-        version_rank: 1.4,
-        version_created: "2026-07-07T00:00:00.000Z",
-        marker: "keep",
-      }),
-    });
-    const pairA = await seed(store, {
-      text: "pair-a",
-      metadata: JSON.stringify({ version_group: "vg-pair", version_rank: 2, version_created: "2026-07-07T00:00:00.000Z" }),
-    });
-    const pairB = await seed(store, {
-      text: "pair-b",
-      metadata: JSON.stringify({ version_group: "vg-pair", version_rank: 1, version_created: "2026-07-07T00:00:00.000Z" }),
-    });
-
-    expect(await store.repairSingletonVersionGroups()).toBe(1);
-    const singletonMeta = JSON.parse((await store.getById(singleton.id))!.metadata!);
-    expect(singletonMeta).toEqual({ marker: "keep" });
-    expect(JSON.parse((await store.getById(pairA.id))!.metadata!).version_group).toBe("vg-pair");
-    expect(JSON.parse((await store.getById(pairB.id))!.metadata!).version_group).toBe("vg-pair");
-    expect(await store.repairSingletonVersionGroups()).toBe(0);
-  });
-});