nlm-memory 0.5.0 → 0.5.2

package/tests/integration/mcp-recall-logging.test.ts

@@ -1,88 +0,0 @@
-/**
- * The MCP recall handlers must write to the recall telemetry, the same way
- * the HTTP /api/recall path does. Without this, every agent recall via MCP
- * is invisible to query_log.jsonl / fact_query_log.jsonl and the Recall
- * page — which is the path that actually matters for adoption telemetry.
- */
-
-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 {
-  recallFactsHandler,
-  recallSessionsHandler,
-  type McpDeps,
-} from "../../src/mcp/server.js";
-
-// logQuery is fire-and-forget (void) in the handler — poll for the line.
-async function waitForLine(path: string): Promise<string> {
-  for (let i = 0; i < 60; i++) {
-    if (existsSync(path)) {
-      const txt = readFileSync(path, "utf8").trim();
-      if (txt) return txt;
-    }
-    await new Promise((r) => setTimeout(r, 25));
-  }
-  throw new Error(`no log line written to ${path} within timeout`);
-}
-
-describe("MCP recall handlers write telemetry", () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-mcplog-"));
-    process.env["NLM_QUERY_LOG"] = join(tmp, "query_log.jsonl");
-    process.env["NLM_FACT_QUERY_LOG"] = join(tmp, "fact_query_log.jsonl");
-  });
-
-  afterEach(() => {
-    delete process.env["NLM_QUERY_LOG"];
-    delete process.env["NLM_FACT_QUERY_LOG"];
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("recall_sessions logs an mcp-source query", async () => {
-    const deps = {
-      recall: {
-        search: async () => ({
-          query: "pgvector",
-          entity: null,
-          kind: null,
-          mode: "keyword",
-          limit: 10,
-          total: 2,
-          results: [{ id: "s1" }, { id: "s2" }],
-        }),
-      },
-    } as unknown as McpDeps;
-
-    await recallSessionsHandler(deps, { query: "pgvector", mode: "keyword", limit: 10 });
-
-    const entry = JSON.parse(await waitForLine(process.env["NLM_QUERY_LOG"] as string));
-    expect(entry.source).toBe("mcp");
-    expect(entry.query).toBe("pgvector");
-    expect(entry.n_results).toBe(2);
-    expect(entry.returned_ids).toEqual(["s1", "s2"]);
-  });
-
-  it("recall_facts logs an mcp-source query", async () => {
-    const deps = {
-      factRecall: {
-        search: async () => ({
-          query: "routing",
-          total: 1,
-          results: [{ id: "fact_x" }],
-        }),
-      },
-    } as unknown as McpDeps;
-
-    await recallFactsHandler(deps, { query: "routing", mode: "keyword", limit: 10 });
-
-    const entry = JSON.parse(await waitForLine(process.env["NLM_FACT_QUERY_LOG"] as string));
-    expect(entry.source).toBe("mcp");
-    expect(entry.query).toBe("routing");
-    expect(entry.n_results).toBe(1);
-    expect(entry.returned_ids).toEqual(["fact_x"]);
-  });
-});

package/tests/integration/mcp.test.ts

@@ -1,260 +0,0 @@
-/**
- * MCP adapter integration. Exercises the tool handlers directly (no stdio
- * transport) to prove the in-process binding to RecallService + SessionStore
- * works end-to-end.
- */
-
-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 { FactRecallService } from "../../src/core/recall-facts/fact-recall-service.js";
-import { RecallService } from "../../src/core/recall/recall-service.js";
-import { SqliteFactStore } from "../../src/core/storage/sqlite-fact-store.js";
-import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
-import {
-  createMcpServer,
-  getFactHistoryHandler,
-  getSessionHandler,
-  recallFactsHandler,
-  recallSessionsHandler,
-} from "../../src/mcp/server.js";
-import type { EmbedResult, LLMClient } from "../../src/ports/llm-client.js";
-import type { Session } from "../../src/shared/types.js";
-import { makeFact } from "../fixtures/facts.js";
-import { makeSession } from "../fixtures/sessions.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-function unit(values: number[]): Float32Array {
-  const padded = new Float32Array(768);
-  values.forEach((v, i) => {
-    padded[i] = v;
-  });
-  let sum = 0;
-  for (const v of padded) sum += v * v;
-  const norm = Math.sqrt(sum) || 1;
-  for (let i = 0; i < padded.length; i++) padded[i] = (padded[i] ?? 0) / norm;
-  return padded;
-}
-
-class FixedEmbedder implements LLMClient {
-  constructor(private readonly vector: Float32Array) {}
-  async embed(): Promise<EmbedResult> {
-    return { vector: this.vector, model: "fixed-test" };
-  }
-  async classify(): Promise<never> {
-    throw new Error("not used");
-  }
-}
-
-const seed: ReadonlyArray<{ session: Session; embedding: Float32Array }> = [
-  {
-    session: makeSession({
-      id: "sess_a",
-      label: "Hono router setup",
-      entities: ["NLM"],
-      decisions: ["chose Hono"],
-    }),
-    embedding: unit([1, 0, 0]),
-  },
-  {
-    session: makeSession({
-      id: "sess_b",
-      label: "pgvector migration plan",
-      entities: ["NLM", "Postgres"],
-      open: ["cutover timing"],
-    }),
-    embedding: unit([0, 1, 0]),
-  },
-];
-
-interface ParsedTool {
-  content: { type: string; text: string }[];
-  isError?: boolean;
-}
-
-function parsePayload(result: ParsedTool): unknown {
-  const first = result.content[0];
-  if (!first) throw new Error("empty tool result");
-  return JSON.parse(first.text);
-}
-
-describe("MCP adapter", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-  let recall: RecallService;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-mcp-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    for (const { session, embedding } of seed) {
-      store.insertSessionForTest(session);
-      store.insertEmbeddingForTest(session.id, embedding);
-    }
-    recall = new RecallService({
-      store,
-      llm: new FixedEmbedder(unit([0, 1, 0])),
-    });
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("recall_sessions returns the keyword hit", async () => {
-    const result = await recallSessionsHandler(
-      { recall, store },
-      { query: "pgvector", mode: "keyword" },
-    );
-    expect(result.isError).toBeUndefined();
-    const body = parsePayload(result) as { total: number; results: { id: string }[] };
-    expect(body.total).toBe(1);
-    expect(body.results[0]?.id).toBe("sess_b");
-  });
-
-  it("recall_sessions defaults to hybrid mode + 10-item limit", async () => {
-    const result = await recallSessionsHandler({ recall, store }, { query: "hono" });
-    const body = parsePayload(result) as { mode: string; limit: number };
-    expect(body.mode).toBe("hybrid");
-    expect(body.limit).toBe(10);
-  });
-
-  it("recall_sessions threads entity + kind filters into RecallService", async () => {
-    const result = await recallSessionsHandler(
-      { recall, store },
-      { query: "pgvector", entity: "NLM", kind: "open" },
-    );
-    const body = parsePayload(result) as {
-      entity: string;
-      kind: string;
-      results: { id: string }[];
-    };
-    expect(body.entity).toBe("NLM");
-    expect(body.kind).toBe("open");
-    expect(body.results.every((r) => r.id === "sess_b")).toBe(true);
-  });
-
-  it("get_session returns the full session for a known id", async () => {
-    const result = await getSessionHandler({ recall, store }, { id: "sess_a" });
-    expect(result.isError).toBeUndefined();
-    const body = parsePayload(result) as { id: string; entities: string[] };
-    expect(body.id).toBe("sess_a");
-    expect(body.entities).toContain("NLM");
-  });
-
-  it("get_session includes supersedence links when an edge exists", async () => {
-    store.insertEdgeForTest("sess_a", "sess_b", "supersedes");
-    const newer = await getSessionHandler({ recall, store }, { id: "sess_a" });
-    const older = await getSessionHandler({ recall, store }, { id: "sess_b" });
-    const newerBody = parsePayload(newer) as { supersedes: string[]; supersededBy: string | null };
-    const olderBody = parsePayload(older) as { supersedes: string[]; supersededBy: string | null };
-    expect(newerBody.supersedes).toEqual(["sess_b"]);
-    expect(newerBody.supersededBy).toBeNull();
-    expect(olderBody.supersededBy).toBe("sess_a");
-    expect(olderBody.supersedes).toEqual([]);
-  });
-
-  it("get_session returns an error tool result on missing id", async () => {
-    const result = await getSessionHandler(
-      { recall, store },
-      { id: "does_not_exist" },
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toContain("not found");
-  });
-
-  it("createMcpServer registers both tools without throwing", () => {
-    const server = createMcpServer({ recall, store });
-    expect(server).toBeDefined();
-  });
-
-  describe("fact tools (B.3)", () => {
-    let factStore: SqliteFactStore;
-    let factRecall: FactRecallService;
-
-    beforeEach(async () => {
-      factStore = new SqliteFactStore(store.rawDb());
-      factRecall = new FactRecallService({
-        factStore,
-        llm: new FixedEmbedder(unit([1, 0, 0])),
-      });
-      await factStore.insertMany([
-        makeFact({
-          id: "f_hono",
-          subject: "nlm-memory-ts",
-          predicate: "framework",
-          value: "Hono",
-          confidence: 0.9,
-          sourceSessionId: "sess_a",
-        }),
-        makeFact({
-          id: "f_endpoint",
-          kind: "attribute",
-          subject: "mac-pro-llm-host",
-          predicate: "endpoint",
-          value: "http://macpro:8080/v1",
-          confidence: 0.85,
-          sourceSessionId: "sess_b",
-        }),
-      ]);
-    });
-
-    it("recall_facts returns the current fact for an exact subject+predicate", async () => {
-      const result = await recallFactsHandler(
-        { recall, store, factRecall, factStore },
-        { subject: "nlm-memory-ts", predicate: "framework" },
-      );
-      expect(result.isError).toBeUndefined();
-      const body = parsePayload(result) as {
-        total: number;
-        results: { id: string; value: string }[];
-      };
-      expect(body.total).toBe(1);
-      expect(body.results[0]?.id).toBe("f_hono");
-      expect(body.results[0]?.value).toBe("Hono");
-    });
-
-    it("recall_facts returns an error tool result when factRecall is missing", async () => {
-      const result = await recallFactsHandler(
-        { recall, store },
-        { subject: "x" },
-      );
-      expect(result.isError).toBe(true);
-    });
-
-    it("get_fact_history returns chains ordered newest → oldest", async () => {
-      await factStore.insertMany([
-        makeFact({
-          id: "f_old",
-          subject: "nlm-memory-ts",
-          predicate: "framework",
-          value: "Fastify",
-          createdAt: "2026-05-18T00:00:00Z",
-          confidence: 0.9,
-          sourceSessionId: "sess_a",
-        }),
-      ]);
-      await factStore.markSuperseded("f_old", "f_hono");
-
-      const result = await getFactHistoryHandler(
-        { recall, store, factRecall, factStore },
-        { subject: "nlm-memory-ts", predicate: "framework" },
-      );
-      const body = parsePayload(result) as {
-        chains: { history: { id: string }[] }[];
-      };
-      expect(body.chains).toHaveLength(1);
-      expect(body.chains[0]?.history.map((f) => f.id)).toEqual(["f_hono", "f_old"]);
-    });
-
-    it("createMcpServer registers fact tools when factRecall + factStore wired", () => {
-      const server = createMcpServer({ recall, store, factRecall, factStore });
-      expect(server).toBeDefined();
-    });
-  });
-});

package/tests/integration/memo-sweep.test.ts

@@ -1,91 +0,0 @@
-import { existsSync, mkdtempSync, readdirSync, rmSync, utimesSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { MemoSweepScheduler, sweepMemoDir } from "../../src/core/hook/memo-sweep.js";
-
-describe("memo sweep", () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-memo-sweep-"));
-  });
-
-  afterEach(() => rmSync(tmp, { recursive: true, force: true }));
-
-  function plantMemo(name: string, ageMs: number): string {
-    const path = join(tmp, name);
-    writeFileSync(path, "[]", "utf8");
-    if (ageMs > 0) {
-      const past = (Date.now() - ageMs) / 1000;
-      utimesSync(path, past, past);
-    }
-    return path;
-  }
-
-  it("returns a zero-count report when state dir does not exist", () => {
-    const report = sweepMemoDir({ stateDir: join(tmp, "nope") });
-    expect(report).toEqual({ scanned: 0, deleted: 0, kept: 0, errors: 0 });
-  });
-
-  it("deletes memos older than the dormant threshold and keeps fresh ones", () => {
-    plantMemo("fresh.json", 30 * 60 * 1000); // 30 min old — active
-    plantMemo("idle.json", 6 * 60 * 60 * 1000); // 6 hours — idle
-    plantMemo("dormant-a.json", 25 * 60 * 60 * 1000); // 25h — dormant
-    plantMemo("dormant-b.json", 30 * 24 * 60 * 60 * 1000); // 30 days — very dormant
-
-    const report = sweepMemoDir({ stateDir: tmp });
-    expect(report).toMatchObject({ scanned: 4, deleted: 2, kept: 2, errors: 0 });
-
-    const remaining = readdirSync(tmp).sort();
-    expect(remaining).toEqual(["fresh.json", "idle.json"]);
-  });
-
-  it("ignores non-json files in the state dir", () => {
-    plantMemo("dormant.json", 25 * 60 * 60 * 1000);
-    writeFileSync(join(tmp, "README.txt"), "not a memo");
-    writeFileSync(join(tmp, ".DS_Store"), "");
-
-    const report = sweepMemoDir({ stateDir: tmp });
-    expect(report.deleted).toBe(1);
-    expect(existsSync(join(tmp, "README.txt"))).toBe(true);
-    expect(existsSync(join(tmp, ".DS_Store"))).toBe(true);
-  });
-
-  it("honors a custom dormantMs threshold", () => {
-    plantMemo("two-hour-old.json", 2 * 60 * 60 * 1000);
-    // Threshold of 1 hour — anything older than 1h is dormant.
-    const report = sweepMemoDir({ stateDir: tmp, dormantMs: 60 * 60 * 1000 });
-    expect(report.deleted).toBe(1);
-  });
-
-  it("uses an injected `now` for deterministic time-window tests", () => {
-    const path = plantMemo("memo.json", 0);
-    // memo was just touched. Pretend "now" is 2 days in the future — it's dormant.
-    const future = Date.now() + 2 * 24 * 60 * 60 * 1000;
-    const report = sweepMemoDir({ stateDir: tmp, now: () => future });
-    expect(report.deleted).toBe(1);
-    expect(existsSync(path)).toBe(false);
-  });
-
-  it("MemoSweepScheduler.tick performs the sweep without scheduling", () => {
-    plantMemo("dormant.json", 25 * 60 * 60 * 1000);
-    plantMemo("fresh.json", 60_000);
-    const sweeper = new MemoSweepScheduler({ stateDir: tmp, logger: () => {} });
-    const report = sweeper.tick();
-    expect(report.deleted).toBe(1);
-    expect(report.kept).toBe(1);
-  });
-
-  it("MemoSweepScheduler.start does not throw and stop cleans up the timer", () => {
-    const sweeper = new MemoSweepScheduler({
-      stateDir: tmp,
-      intervalMs: 60_000,
-      logger: () => {},
-    });
-    expect(() => sweeper.start()).not.toThrow();
-    expect(() => sweeper.stop()).not.toThrow();
-    // Idempotent — double-stop is a no-op.
-    expect(() => sweeper.stop()).not.toThrow();
-  });
-});

package/tests/integration/prompt-recall-hook.test.ts

@@ -1,88 +0,0 @@
-import { mkdtempSync, existsSync, 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/prompt-recall-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("runHook", () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-hook-"));
-    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 but returns no stdout", async () => {
-    const out = await runHook(
-      { prompt: "what did we decide about pgvector", conversationId: "c1" },
-      { mode: "shadow", recall: async () => hits("sess_a") },
-    );
-    expect(out).toBe("");
-    const log = readFileSync(join(tmp, "hook-log.jsonl"), "utf8").trim();
-    expect(JSON.parse(log).wouldInject).toEqual(["sess_a"]);
-    expect(JSON.parse(log).mode).toBe("shadow");
-  });
-
-  it("shadow mode does not write the memo", async () => {
-    await runHook(
-      { prompt: "what did we decide", conversationId: "c1" },
-      { mode: "shadow", recall: async () => hits("sess_a") },
-    );
-    expect(existsSync(join(tmp, "state", "c1.json"))).toBe(false);
-  });
-
-  it("live mode returns the pointer block and records the memo", async () => {
-    const out = await runHook(
-      { prompt: "what did we decide about pgvector", conversationId: "c1" },
-      { 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"));
-    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({ prompt: "what did we decide", conversationId: "c1" }, deps);
-    expect(first).toContain("sess_a");
-    const second = await runHook({ prompt: "and what else did we decide", conversationId: "c1" }, deps);
-    expect(second).toBe("");
-  });
-
-  it("generative prompts skip recall entirely", async () => {
-    let called = false;
-    const out = await runHook(
-      { prompt: "draft a blog post about FTS5", conversationId: "c1" },
-      { mode: "live", recall: async () => { called = true; return hits("sess_a"); } },
-    );
-    expect(out).toBe("");
-    expect(called).toBe(false);
-    const log = readFileSync(join(tmp, "hook-log.jsonl"), "utf8").trim();
-    expect(JSON.parse(log).gate).toBe("generative");
-  });
-
-  it("returns empty and does not throw when recall rejects", async () => {
-    const out = await runHook(
-      { prompt: "what did we decide", conversationId: "c1" },
-      { mode: "live", recall: async () => { throw new Error("daemon down"); } },
-    );
-    expect(out).toBe("");
-  });
-});

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

@@ -1,107 +0,0 @@
-/**
- * Phase 0 task 3 — ProviderRegistry integration. Real SQLite, seed
- * defaults bridge from env, CRUD, secret redaction on list/get.
- */
-
-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 { ProviderRegistry } from "../../src/core/providers/provider-registry.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-describe("ProviderRegistry", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-  let registry: ProviderRegistry;
-  let savedKey: string | undefined;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-providers-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    registry = new ProviderRegistry(store.rawDb());
-    savedKey = process.env["DEEPSEEK_API_KEY"];
-  });
-
-  afterEach(() => {
-    if (savedKey === undefined) delete process.env["DEEPSEEK_API_KEY"];
-    else process.env["DEEPSEEK_API_KEY"] = savedKey;
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("seedDefaults inserts Ollama always, DeepSeek with key when present", () => {
-    process.env["DEEPSEEK_API_KEY"] = "sk-test-abc";
-    registry.seedDefaults();
-    const rows = registry.list();
-    expect(rows.map((r) => r.kind)).toEqual(["ollama", "deepseek"]);
-    const deepseek = rows.find((r) => r.kind === "deepseek");
-    expect(deepseek?.enabled).toBe(true);
-    expect(deepseek?.hasApiKey).toBe(true);
-    expect(deepseek?.apiKey).toBeNull(); // redacted
-  });
-
-  it("seedDefaults disables DeepSeek when key is absent", () => {
-    delete process.env["DEEPSEEK_API_KEY"];
-    registry.seedDefaults();
-    const deepseek = registry.getByName("DeepSeek");
-    expect(deepseek?.enabled).toBe(false);
-    expect(deepseek?.hasApiKey).toBe(false);
-  });
-
-  it("seedDefaults is idempotent", () => {
-    registry.seedDefaults();
-    registry.seedDefaults();
-    expect(registry.list().length).toBe(2);
-  });
-
-  it("inserts a custom provider with explicit base URL", () => {
-    const row = registry.insert({
-      kind: "openai-compatible",
-      name: "vLLM box",
-      baseUrl: "http://192.168.1.50:8000/v1",
-      defaultModel: "llama-3.1-70b",
-      apiKey: "secret-token",
-    });
-    expect(row.baseUrl).toBe("http://192.168.1.50:8000/v1");
-    expect(row.hasApiKey).toBe(true);
-    expect(row.apiKey).toBeNull();
-  });
-
-  it("getSecret returns the unredacted key", () => {
-    const row = registry.insert({
-      kind: "openai", name: "OpenAI prod", apiKey: "sk-real",
-    });
-    expect(registry.getSecret(row.id)).toBe("sk-real");
-  });
-
-  it("rejects duplicate names", () => {
-    registry.insert({ kind: "openai", name: "OpenAI", apiKey: "k" });
-    expect(() => registry.insert({ kind: "openai", name: "OpenAI", apiKey: "k2" }))
-      .toThrow();
-  });
-
-  it("update patches only supplied fields", () => {
-    const row = registry.insert({ kind: "openai", name: "OAI", apiKey: "k1" });
-    const updated = registry.update(row.id, { apiKey: "k2", enabled: false });
-    expect(updated?.enabled).toBe(false);
-    expect(registry.getSecret(row.id)).toBe("k2");
-  });
-
-  it("delete removes the row", () => {
-    const row = registry.insert({ kind: "openai", name: "Tmp", apiKey: "k" });
-    expect(registry.delete(row.id)).toBe(true);
-    expect(registry.get(row.id)).toBeNull();
-  });
-
-  it("fills in default base URL and model when omitted", () => {
-    const row = registry.insert({ kind: "anthropic", name: "Claude", apiKey: "k" });
-    expect(row.baseUrl).toBe("https://api.anthropic.com");
-    expect(row.defaultModel).toBe("claude-haiku-4-5-20251001");
-  });
-});

package/tests/integration/recall-golden.test.ts

@@ -1,59 +0,0 @@
-/**
- * Recall-quality regression gate. A fixed corpus + query/expectation pairs,
- * run through RecallService against a real SqliteSessionStore. Assertions are
- * tolerant (expected session within top 3) so they survive the swap from the
- * token-overlap scorer to FTS5 BM25 ranking. This test must stay green from
- * the current code through every task in this plan.
- */
-
-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 { RecallService } from "../../src/core/recall/recall-service.js";
-import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
-import type { EmbedResult, LLMClient } from "../../src/ports/llm-client.js";
-import { LLMUnreachableError } from "../../src/ports/llm-client.js";
-import { GOLDEN_CORPUS, GOLDEN_QUERIES } from "../fixtures/golden-corpus.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-// Keyword-only recall must never touch the embedder; this stub proves it.
-class UnreachableEmbedder implements LLMClient {
-  async embed(): Promise<EmbedResult> {
-    throw new LLMUnreachableError("ollama");
-  }
-  async classify(): Promise<never> {
-    throw new Error("not used");
-  }
-}
-
-describe("golden recall regression gate", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-golden-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    for (const session of GOLDEN_CORPUS) {
-      store.insertSessionForTest(session);
-    }
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  for (const { query, expectTop3 } of GOLDEN_QUERIES) {
-    it(`keyword recall surfaces "${expectTop3}" in the top 3 for "${query}"`, async () => {
-      const svc = new RecallService({ store, llm: new UnreachableEmbedder() });
-      const result = await svc.search({ query, mode: "keyword", limit: 10 });
-      const top3 = result.results.slice(0, 3).map((r) => r.id);
-      expect(top3).toContain(expectTop3);
-    });
-  }
-});