nlm-memory 0.4.2 → 0.5.1

package/tests/integration/session-start-hook.test.ts

@@ -1,126 +0,0 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { runHook } from "../../src/hook/session-start-hook.js";
-import type { RecallHitInput } from "../../src/core/hook/select.js";
-
-const hits = (...ids: string[]): ReadonlyArray<RecallHitInput> =>
-  ids.map((id, i) => ({
-    id,
-    label: `Session ${id}`,
-    startedAt: "2026-05-15T10:00:00.000Z",
-    matchScore: 0.9 - i * 0.01,
-  }));
-
-describe("session-start runHook", () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-session-start-"));
-    process.env["NLM_HOOK_STATE_DIR"] = join(tmp, "state");
-    process.env["NLM_HOOK_LOG"] = join(tmp, "hook-log.jsonl");
-  });
-
-  afterEach(() => {
-    delete process.env["NLM_HOOK_STATE_DIR"];
-    delete process.env["NLM_HOOK_LOG"];
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("shadow mode logs to hook-log but returns no stdout", async () => {
-    const out = await runHook(
-      { conversationId: "c1", query: "nlm-memory-ts recall" },
-      { mode: "shadow", recall: async () => hits("sess_a") },
-    );
-    expect(out).toBe("");
-    const log = readFileSync(join(tmp, "hook-log.jsonl"), "utf8").trim();
-    const entry = JSON.parse(log) as Record<string, unknown>;
-    expect(entry["wouldInject"]).toEqual(["sess_a"]);
-    expect(entry["mode"]).toBe("shadow");
-    // gate is always "evaluate" — no prompt classifier in session-start
-    expect(entry["gate"]).toBe("evaluate");
-  });
-
-  it("shadow mode does not write the memo", async () => {
-    await runHook(
-      { conversationId: "c1", query: "nlm-memory-ts" },
-      { mode: "shadow", recall: async () => hits("sess_a") },
-    );
-    expect(existsSync(join(tmp, "state", "c1.json"))).toBe(false);
-  });
-
-  it("live mode returns the pointer block and writes the memo", async () => {
-    const out = await runHook(
-      { conversationId: "c1", query: "nlm-memory-ts recall" },
-      { mode: "live", recall: async () => hits("sess_a", "sess_b") },
-    );
-    expect(out).toContain("## Possibly-relevant prior sessions (nlm-memory)");
-    expect(out).toContain("sess_a");
-    const memo = JSON.parse(
-      readFileSync(join(tmp, "state", "c1.json"), "utf8"),
-    ) as string[];
-    expect([...memo].sort()).toEqual(["sess_a", "sess_b"]);
-  });
-
-  it("live mode dedups: a second fire does not re-surface the same session", async () => {
-    const deps = { mode: "live" as const, recall: async () => hits("sess_a") };
-    const first = await runHook({ conversationId: "c1", query: "nlm-memory-ts" }, deps);
-    expect(first).toContain("sess_a");
-    const second = await runHook({ conversationId: "c1", query: "nlm-memory-ts" }, deps);
-    expect(second).toBe("");
-  });
-
-  it("returns empty and does not throw when recall rejects", async () => {
-    const out = await runHook(
-      { conversationId: "c1", query: "nlm-memory-ts" },
-      {
-        mode: "live",
-        recall: async () => {
-          throw new Error("daemon down");
-        },
-      },
-    );
-    expect(out).toBe("");
-  });
-
-  it("returns empty string in both modes when recall returns no hits", async () => {
-    for (const mode of ["shadow", "live"] as const) {
-      const out = await runHook(
-        { conversationId: `c-${mode}`, query: "nlm-memory-ts" },
-        { mode, recall: async () => [] },
-      );
-      expect(out).toBe("");
-    }
-  });
-
-  it("hook-log entry has promptPreview set to the query", async () => {
-    await runHook(
-      { conversationId: "c1", query: "whtnxt-agent session recall" },
-      { mode: "shadow", recall: async () => hits("sess_x") },
-    );
-    const entry = JSON.parse(
-      readFileSync(join(tmp, "hook-log.jsonl"), "utf8").trim(),
-    ) as Record<string, unknown>;
-    expect(entry["promptPreview"]).toBe("whtnxt-agent session recall");
-  });
-
-  it("live mode writes memo for each new session ID across multiple fires", async () => {
-    // First fire surfaces sess_a
-    await runHook(
-      { conversationId: "c1", query: "nlm-memory-ts" },
-      { mode: "live", recall: async () => hits("sess_a") },
-    );
-    // Second fire surfaces sess_b (sess_a already in memo — deduped out, sess_b is new)
-    const second = await runHook(
-      { conversationId: "c1", query: "nlm-memory-ts" },
-      { mode: "live", recall: async () => hits("sess_a", "sess_b") },
-    );
-    expect(second).toContain("sess_b");
-    expect(second).not.toContain("sess_a");
-    const memo = JSON.parse(
-      readFileSync(join(tmp, "state", "c1.json"), "utf8"),
-    ) as string[];
-    expect([...memo].sort()).toEqual(["sess_a", "sess_b"]);
-  });
-});

package/tests/integration/source-registry.test.ts

@@ -1,120 +0,0 @@
-/**
- * Phase 0 — SourceRegistry integration. Real SQLite, migrations apply,
- * seed defaults, CRUD round-trip, name uniqueness.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
-import { SourceRegistry } from "../../src/core/sources/source-registry.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-describe("SourceRegistry", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-  let registry: SourceRegistry;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-sources-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    registry = new SourceRegistry(store.rawDb());
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("starts empty and seeds six presets", () => {
-    expect(registry.list()).toEqual([]);
-    registry.seedDefaults();
-    const rows = registry.list();
-    expect(rows.map((r) => r.kind)).toEqual(["claude-code", "hermes", "hermes-agent", "aider", "opencode", "pi"]);
-    expect(rows.every((r) => r.runtimeLabel.endsWith("/1.0"))).toBe(true);
-  });
-
-  it("seedDefaults is idempotent", () => {
-    registry.seedDefaults();
-    registry.seedDefaults();
-    expect(registry.list().length).toBe(6);
-  });
-
-  it("inserts a custom JSONL source and round-trips parse config", () => {
-    const inserted = registry.insert({
-      kind: "jsonl-generic",
-      name: "Cursor",
-      pathOrUrl: "/tmp/cursor",
-      runtimeLabel: "cursor/0.1",
-      parseConfig: { sessionIdField: "id", textField: "content" },
-    });
-    expect(inserted.id).toBeGreaterThan(0);
-    const fetched = registry.get(inserted.id);
-    expect(fetched?.parseConfig).toEqual({ sessionIdField: "id", textField: "content" });
-  });
-
-  it("rejects duplicate names at the unique-constraint level", () => {
-    registry.insert({ kind: "webhook", name: "Push", runtimeLabel: "push/1" });
-    expect(() => registry.insert({ kind: "webhook", name: "Push", runtimeLabel: "push/2" }))
-      .toThrow();
-  });
-
-  it("update patches only the supplied fields", () => {
-    const row = registry.insert({ kind: "webhook", name: "API", runtimeLabel: "api/1" });
-    const updated = registry.update(row.id, { enabled: false });
-    expect(updated?.enabled).toBe(false);
-    expect(updated?.runtimeLabel).toBe("api/1");
-  });
-
-  it("delete removes the row", () => {
-    const row = registry.insert({ kind: "webhook", name: "Tmp", runtimeLabel: "tmp/1" });
-    expect(registry.delete(row.id)).toBe(true);
-    expect(registry.get(row.id)).toBeNull();
-  });
-
-  it("mints a token on insert for webhook sources, redacts on list/get", () => {
-    const row = registry.insert({ kind: "webhook", name: "Tool A", runtimeLabel: "tool-a/1" });
-    expect(row.token).toMatch(/^nlm_[a-f0-9]{48}$/);
-    expect(row.hasToken).toBe(true);
-    const listed = registry.list().find((r) => r.id === row.id);
-    expect(listed?.token).toBeNull();
-    expect(listed?.hasToken).toBe(true);
-    expect(registry.get(row.id)?.token).toBeNull();
-  });
-
-  it("findByToken resolves to the owning source", () => {
-    const row = registry.insert({ kind: "webhook", name: "Tool B", runtimeLabel: "tool-b/1" });
-    expect(row.token).toBeTruthy();
-    const found = registry.findByToken(row.token!);
-    expect(found?.id).toBe(row.id);
-    expect(registry.findByToken("nlm_invalid")).toBeNull();
-    expect(registry.findByToken("")).toBeNull();
-  });
-
-  it("non-webhook sources do not get tokens", () => {
-    const row = registry.insert({
-      kind: "jsonl-generic", name: "Logs", runtimeLabel: "logs/1", pathOrUrl: "/tmp/logs",
-    });
-    expect(row.token).toBeNull();
-    expect(row.hasToken).toBe(false);
-  });
-
-  it("regenerateToken issues a new token only for webhook sources", () => {
-    const wh = registry.insert({ kind: "webhook", name: "Tool C", runtimeLabel: "tool-c/1" });
-    const first = wh.token!;
-    const second = registry.regenerateToken(wh.id)!;
-    expect(second).not.toBe(first);
-    expect(registry.findByToken(first)).toBeNull();
-    expect(registry.findByToken(second)?.id).toBe(wh.id);
-
-    const jsonl = registry.insert({
-      kind: "jsonl-generic", name: "L2", runtimeLabel: "l/1", pathOrUrl: "/tmp/x",
-    });
-    expect(registry.regenerateToken(jsonl.id)).toBeNull();
-  });
-});

package/tests/integration/sqlite-fact-store.test.ts

@@ -1,346 +0,0 @@
-/**
- * SqliteFactStore against real SQLite + real migrations. Uses a tmp DB per
- * test so we exercise the actual schema, not a fake.
- *
- * Phase B.1: storage substrate only. No extraction, no recall service.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { SqliteFactStore } from "../../src/core/storage/sqlite-fact-store.js";
-import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
-import { makeFact } from "../fixtures/facts.js";
-import { makeSession } from "../fixtures/sessions.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-describe("SqliteFactStore (integration)", () => {
-  let tmp: string;
-  let sessionStore: SqliteSessionStore;
-  let factStore: SqliteFactStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-facts-"));
-    sessionStore = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    factStore = new SqliteFactStore(sessionStore.rawDb());
-    // Facts FK to sessions(id); seed one parent session so inserts don't trip
-    // the foreign key constraint.
-    sessionStore.insertSessionForTest(
-      makeSession({ id: "sess_parent", label: "Parent session" }),
-    );
-  });
-
-  afterEach(() => {
-    sessionStore.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("inserts and retrieves a fact round-trip", async () => {
-    const fact = makeFact({ id: "fact_1", sourceSessionId: "sess_parent" });
-    await factStore.insert(fact);
-    const fetched = await factStore.getById("fact_1");
-    expect(fetched).toEqual(fact);
-  });
-
-  it("returns null for missing ids", async () => {
-    expect(await factStore.getById("nonexistent")).toBeNull();
-  });
-
-  it("insertMany commits atomically", async () => {
-    await factStore.insertMany([
-      makeFact({ id: "fact_a", subject: "alpha", sourceSessionId: "sess_parent" }),
-      makeFact({ id: "fact_b", subject: "beta", sourceSessionId: "sess_parent" }),
-    ]);
-    expect(await factStore.getById("fact_a")).not.toBeNull();
-    expect(await factStore.getById("fact_b")).not.toBeNull();
-  });
-
-  it("insertMany rolls back the whole batch on duplicate id", async () => {
-    await factStore.insert(
-      makeFact({ id: "fact_existing", sourceSessionId: "sess_parent" }),
-    );
-    await expect(
-      factStore.insertMany([
-        makeFact({ id: "fact_new", subject: "alpha", sourceSessionId: "sess_parent" }),
-        makeFact({ id: "fact_existing", subject: "beta", sourceSessionId: "sess_parent" }),
-      ]),
-    ).rejects.toThrow();
-    expect(await factStore.getById("fact_new")).toBeNull();
-  });
-
-  it("findCurrent returns only non-superseded facts", async () => {
-    await factStore.insert(
-      makeFact({
-        id: "fact_old",
-        subject: "nlm-memory-ts",
-        predicate: "framework",
-        value: "Fastify",
-        sourceSessionId: "sess_parent",
-        createdAt: "2026-05-18T10:00:00Z",
-      }),
-    );
-    await factStore.insert(
-      makeFact({
-        id: "fact_new",
-        subject: "nlm-memory-ts",
-        predicate: "framework",
-        value: "Hono",
-        sourceSessionId: "sess_parent",
-        createdAt: "2026-05-19T10:00:00Z",
-      }),
-    );
-    await factStore.markSuperseded("fact_old", "fact_new");
-
-    const current = await factStore.findCurrent("nlm-memory-ts", "framework");
-    expect(current?.id).toBe("fact_new");
-    expect(current?.value).toBe("Hono");
-  });
-
-  it("findCurrent returns null when no current fact exists", async () => {
-    expect(await factStore.findCurrent("nlm-memory-ts", "framework")).toBeNull();
-  });
-
-  it("list filters by subject and excludes superseded by default", async () => {
-    await factStore.insertMany([
-      makeFact({
-        id: "f1",
-        subject: "mac-pro",
-        predicate: "endpoint",
-        value: "http://macpro:8080/v1",
-        sourceSessionId: "sess_parent",
-        createdAt: "2026-05-19T10:00:00Z",
-      }),
-      makeFact({
-        id: "f2",
-        subject: "mac-pro",
-        predicate: "model",
-        value: "qwen2.5-3b",
-        sourceSessionId: "sess_parent",
-        createdAt: "2026-05-19T10:05:00Z",
-      }),
-      makeFact({
-        id: "f3",
-        subject: "other",
-        predicate: "framework",
-        value: "Hono",
-        sourceSessionId: "sess_parent",
-      }),
-    ]);
-    await factStore.markSuperseded("f1", "f2");
-
-    const current = await factStore.list({ subject: "mac-pro" });
-    expect(current.map((f) => f.id)).toEqual(["f2"]);
-
-    const all = await factStore.list({
-      subject: "mac-pro",
-      includeSuperseded: true,
-    });
-    expect(all.map((f) => f.id)).toEqual(["f2", "f1"]); // created_at DESC
-  });
-
-  it("list with predicate narrows further", async () => {
-    await factStore.insertMany([
-      makeFact({ id: "f1", subject: "x", predicate: "alpha", sourceSessionId: "sess_parent" }),
-      makeFact({ id: "f2", subject: "x", predicate: "beta", sourceSessionId: "sess_parent" }),
-    ]);
-    const out = await factStore.list({ subject: "x", predicate: "beta" });
-    expect(out.map((f) => f.id)).toEqual(["f2"]);
-  });
-
-  it("listBySession returns all facts (including superseded) for a session", async () => {
-    sessionStore.insertSessionForTest(makeSession({ id: "sess_other" }));
-    await factStore.insertMany([
-      makeFact({ id: "f1", subject: "a", sourceSessionId: "sess_parent" }),
-      makeFact({ id: "f2", subject: "b", sourceSessionId: "sess_parent" }),
-      makeFact({ id: "f3", subject: "c", sourceSessionId: "sess_other" }),
-    ]);
-    await factStore.markSuperseded("f1", "f2");
-
-    const out = await factStore.listBySession("sess_parent");
-    expect(out.map((f) => f.id).sort()).toEqual(["f1", "f2"]);
-  });
-
-  it("markSuperseded throws when either id is missing", async () => {
-    await factStore.insert(makeFact({ id: "real", sourceSessionId: "sess_parent" }));
-    await expect(factStore.markSuperseded("nope", "real")).rejects.toThrow(/not found/);
-    await expect(factStore.markSuperseded("real", "nope")).rejects.toThrow(/not found/);
-  });
-
-  it("markSuperseded rejects self-supersedence", async () => {
-    await factStore.insert(makeFact({ id: "self", sourceSessionId: "sess_parent" }));
-    await expect(factStore.markSuperseded("self", "self")).rejects.toThrow(/itself/);
-  });
-
-  it("markSuperseded with null reverses an earlier supersedence", async () => {
-    await factStore.insertMany([
-      makeFact({ id: "a", subject: "s", predicate: "p", value: "v1", sourceSessionId: "sess_parent" }),
-      makeFact({ id: "b", subject: "s", predicate: "p", value: "v2", sourceSessionId: "sess_parent" }),
-    ]);
-    await factStore.markSuperseded("a", "b");
-    expect((await factStore.getById("a"))?.supersededBy).toBe("b");
-    await factStore.markSuperseded("a", null);
-    expect((await factStore.getById("a"))?.supersededBy).toBeNull();
-  });
-
-  it("CHECK constraints reject invalid kind", async () => {
-    await expect(
-      factStore.insert(
-        // @ts-expect-error — exercising the CHECK constraint at runtime
-        makeFact({ id: "bad", kind: "garbage", sourceSessionId: "sess_parent" }),
-      ),
-    ).rejects.toThrow();
-  });
-
-  it("CHECK constraints reject confidence out of [0, 1]", async () => {
-    await expect(
-      factStore.insert(
-        makeFact({ id: "bad", confidence: 1.5, sourceSessionId: "sess_parent" }),
-      ),
-    ).rejects.toThrow();
-  });
-
-  it("FK constraint rejects facts pointing at missing sessions", async () => {
-    await expect(
-      factStore.insert(
-        makeFact({ id: "orphan", sourceSessionId: "no_such_session" }),
-      ),
-    ).rejects.toThrow();
-  });
-
-  describe("listForRecall (B.3)", () => {
-    beforeEach(async () => {
-      await factStore.insertMany([
-        makeFact({
-          id: "f_hono", subject: "nlm-memory-ts", predicate: "framework",
-          value: "Hono", confidence: 0.9, sourceSessionId: "sess_parent",
-        }),
-        makeFact({
-          id: "f_endpoint", kind: "attribute", subject: "mac-pro", predicate: "endpoint",
-          value: "http://macpro:8080/v1", confidence: 0.85, sourceSessionId: "sess_parent",
-        }),
-        makeFact({
-          id: "f_low", subject: "x", predicate: "other", value: "y",
-          confidence: 0.5, sourceSessionId: "sess_parent",
-        }),
-        makeFact({
-          id: "f_fastify", subject: "nlm-memory-ts", predicate: "framework",
-          value: "Fastify", confidence: 0.9, sourceSessionId: "sess_parent",
-        }),
-      ]);
-      await factStore.markSuperseded("f_fastify", "f_hono");
-    });
-
-    it("filters by subject + predicate, excluding superseded by default", async () => {
-      const out = await factStore.listForRecall({
-        subject: "nlm-memory-ts",
-        predicate: "framework",
-      });
-      expect(out.map((f) => f.id)).toEqual(["f_hono"]);
-    });
-
-    it("applies minConfidence at the SQL layer", async () => {
-      const all = await factStore.listForRecall({ minConfidence: 0 });
-      expect(all.map((f) => f.id).sort()).toEqual(["f_endpoint", "f_hono", "f_low"]);
-      const high = await factStore.listForRecall({ minConfidence: 0.8 });
-      expect(high.map((f) => f.id).sort()).toEqual(["f_endpoint", "f_hono"]);
-    });
-
-    it("kind filter restricts the result set", async () => {
-      const out = await factStore.listForRecall({ kind: "attribute" });
-      expect(out.map((f) => f.id)).toEqual(["f_endpoint"]);
-    });
-  });
-
-  describe("getHistory (B.3)", () => {
-    it("returns one chain per predicate when only subject is given", async () => {
-      await factStore.insertMany([
-        makeFact({
-          id: "f1", subject: "s", predicate: "framework", value: "Fastify",
-          sourceSessionId: "sess_parent", createdAt: "2026-05-18T00:00:00Z",
-        }),
-        makeFact({
-          id: "f2", subject: "s", predicate: "framework", value: "Hono",
-          sourceSessionId: "sess_parent", createdAt: "2026-05-19T00:00:00Z",
-        }),
-        makeFact({
-          id: "f3", subject: "s", predicate: "endpoint", value: ":8080",
-          sourceSessionId: "sess_parent", createdAt: "2026-05-19T00:00:00Z",
-        }),
-      ]);
-      await factStore.markSuperseded("f1", "f2");
-
-      const chains = await factStore.getHistory("s");
-      expect(chains).toHaveLength(2);
-      const framework = chains.find((c) => c.predicate === "framework");
-      expect(framework?.history.map((f) => f.id)).toEqual(["f2", "f1"]);
-      const endpoint = chains.find((c) => c.predicate === "endpoint");
-      expect(endpoint?.history.map((f) => f.id)).toEqual(["f3"]);
-    });
-
-    it("narrows to a single chain when predicate is provided", async () => {
-      await factStore.insertMany([
-        makeFact({
-          id: "a", subject: "s", predicate: "framework", value: "v1",
-          sourceSessionId: "sess_parent", createdAt: "2026-05-18T00:00:00Z",
-        }),
-        makeFact({
-          id: "b", subject: "s", predicate: "framework", value: "v2",
-          sourceSessionId: "sess_parent", createdAt: "2026-05-19T00:00:00Z",
-        }),
-        makeFact({
-          id: "c", subject: "s", predicate: "endpoint", value: ":8080",
-          sourceSessionId: "sess_parent",
-        }),
-      ]);
-      const chains = await factStore.getHistory("s", "framework");
-      expect(chains).toHaveLength(1);
-      expect(chains[0]?.history.map((f) => f.id)).toEqual(["b", "a"]);
-    });
-
-    it("returns empty array when no matches", async () => {
-      const chains = await factStore.getHistory("nonexistent");
-      expect(chains).toEqual([]);
-    });
-  });
-
-  describe("semanticSearch (B.3)", () => {
-    it("returns nearest neighbors by L2 distance over fact_embeddings", async () => {
-      await factStore.insertMany([
-        makeFact({ id: "near", sourceSessionId: "sess_parent" }),
-        makeFact({ id: "far", subject: "other", sourceSessionId: "sess_parent" }),
-      ]);
-      // Unit vectors: nearVec aligned with query, farVec orthogonal.
-      const near = new Float32Array(768);
-      near[0] = 1;
-      const far = new Float32Array(768);
-      far[1] = 1;
-      factStore.upsertEmbedding("near", near);
-      factStore.upsertEmbedding("far", far);
-
-      const query = new Float32Array(768);
-      query[0] = 1;
-      const neighbors = await factStore.semanticSearch(query, 5);
-      expect(neighbors[0]?.factId).toBe("near");
-      expect(neighbors[0]!.distance).toBeLessThan(neighbors[1]!.distance);
-    });
-
-    it("upsertEmbedding replaces, not duplicates", async () => {
-      await factStore.insert(makeFact({ id: "f1", sourceSessionId: "sess_parent" }));
-      const v1 = new Float32Array(768);
-      v1[0] = 1;
-      const v2 = new Float32Array(768);
-      v2[1] = 1;
-      factStore.upsertEmbedding("f1", v1);
-      factStore.upsertEmbedding("f1", v2);
-      const count = sessionStore.rawDb()
-        .prepare<[], { c: number }>("SELECT COUNT(*) AS c FROM fact_embeddings WHERE fact_id = 'f1'")
-        .get();
-      expect(count?.c).toBe(1);
-    });
-  });
-});