nlm-memory 0.4.2 → 0.5.1

package/tests/integration/fact-supersedence.test.ts

@@ -1,313 +0,0 @@
-/**
- * Phase B.4 — deterministic supersedence on (subject, predicate) collision.
- *
- * Drives SqliteSessionStore.insertSession with factSink wired and verifies
- * that prior non-superseded facts get marked superseded_by = newFactId
- * atomically with the session ingest. Tests live at the integration layer
- * because the behavior is inside a SQL transaction.
- */
-
-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 {
-  type IngestRecord,
-  SqliteSessionStore,
-} from "../../src/core/storage/sqlite-session-store.js";
-import type { Fact } from "../../src/shared/types.js";
-import { makeFact } from "../fixtures/facts.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-function makeRecord(overrides: Partial<IngestRecord> = {}): IngestRecord {
-  return {
-    id: "sess_test",
-    runtime: "claude-code",
-    runtimeSessionId: "test-1",
-    startedAt: "2026-05-19T10:00:00Z",
-    endedAt: "2026-05-19T10:30:00Z",
-    durationMin: 30,
-    label: "L",
-    summary: "S",
-    body: "",
-    status: "closed",
-    transcriptKind: "claude-code-jsonl",
-    transcriptPath: null,
-    transcriptOffset: null,
-    transcriptLength: null,
-    entities: [],
-    decisions: [],
-    openQuestions: [],
-    ...overrides,
-  };
-}
-
-function fact(overrides: Partial<Fact>): Fact {
-  return makeFact({
-    id: `fact_${Math.random().toString(36).slice(2, 10)}`,
-    confidence: 0.9,
-    ...overrides,
-  });
-}
-
-describe("Phase B.4 — supersedence-on-ingest", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-  let factStore: SqliteFactStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-b4-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    factStore = new SqliteFactStore(store.rawDb());
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("cross-session collision: new fact supersedes prior current fact for the same (s, p)", async () => {
-    // Session A asserts framework=Fastify
-    const factA = fact({
-      id: "f_A",
-      subject: "nlm-memory-ts",
-      predicate: "framework",
-      value: "Fastify",
-      sourceSessionId: "sess_A",
-      createdAt: "2026-05-18T10:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_A", startedAt: "2026-05-18T10:00:00Z" }),
-      null,
-      null,
-      { factStore, facts: [factA] },
-    );
-
-    // Session B asserts framework=Hono
-    const factB = fact({
-      id: "f_B",
-      subject: "nlm-memory-ts",
-      predicate: "framework",
-      value: "Hono",
-      sourceSessionId: "sess_B",
-      createdAt: "2026-05-19T10:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_B" }),
-      null,
-      null,
-      { factStore, facts: [factB] },
-    );
-
-    const fetchedA = await factStore.getById("f_A");
-    const fetchedB = await factStore.getById("f_B");
-    expect(fetchedA?.supersededBy).toBe("f_B");
-    expect(fetchedB?.supersededBy).toBeNull();
-
-    const current = await factStore.findCurrent("nlm-memory-ts", "framework");
-    expect(current?.id).toBe("f_B");
-    expect(current?.value).toBe("Hono");
-  });
-
-  it("no collision when subject differs", async () => {
-    await store.insertSession(
-      makeRecord({ id: "sess_A" }),
-      null, null,
-      {
-        factStore,
-        facts: [fact({ id: "fA", subject: "alpha", predicate: "framework", value: "v", sourceSessionId: "sess_A" })],
-      },
-    );
-    await store.insertSession(
-      makeRecord({ id: "sess_B" }),
-      null, null,
-      {
-        factStore,
-        facts: [fact({ id: "fB", subject: "beta", predicate: "framework", value: "v", sourceSessionId: "sess_B" })],
-      },
-    );
-    expect((await factStore.getById("fA"))?.supersededBy).toBeNull();
-    expect((await factStore.getById("fB"))?.supersededBy).toBeNull();
-  });
-
-  it("no collision when predicate differs", async () => {
-    await store.insertSession(
-      makeRecord({ id: "sess_A" }),
-      null, null,
-      {
-        factStore,
-        facts: [fact({ id: "fA", subject: "x", predicate: "framework", value: "v", sourceSessionId: "sess_A" })],
-      },
-    );
-    await store.insertSession(
-      makeRecord({ id: "sess_B" }),
-      null, null,
-      {
-        factStore,
-        facts: [fact({ id: "fB", subject: "x", predicate: "endpoint", value: "v", sourceSessionId: "sess_B" })],
-      },
-    );
-    expect((await factStore.getById("fA"))?.supersededBy).toBeNull();
-    expect((await factStore.getById("fB"))?.supersededBy).toBeNull();
-  });
-
-  it("always-supersede policy: same value from a new session still supersedes (provenance changes)", async () => {
-    const factA = fact({
-      id: "f_A", subject: "x", predicate: "framework", value: "Hono",
-      sourceSessionId: "sess_A", createdAt: "2026-05-18T10:00:00Z",
-    });
-    await store.insertSession(makeRecord({ id: "sess_A", startedAt: "2026-05-18T10:00:00Z" }), null, null,
-      { factStore, facts: [factA] });
-
-    const factB = fact({
-      id: "f_B", subject: "x", predicate: "framework", value: "Hono",
-      sourceSessionId: "sess_B", createdAt: "2026-05-19T10:00:00Z",
-    });
-    await store.insertSession(makeRecord({ id: "sess_B" }), null, null,
-      { factStore, facts: [factB] });
-
-    expect((await factStore.getById("f_A"))?.supersededBy).toBe("f_B");
-    expect((await factStore.getById("f_B"))?.supersededBy).toBeNull();
-  });
-
-  it("three-deep chain: A → B → C, only the immediate predecessor gets re-linked per ingest", async () => {
-    const factA = fact({ id: "f_A", subject: "x", predicate: "framework", value: "Fastify", sourceSessionId: "sess_A", createdAt: "2026-05-17T10:00:00Z" });
-    const factB = fact({ id: "f_B", subject: "x", predicate: "framework", value: "Hono", sourceSessionId: "sess_B", createdAt: "2026-05-18T10:00:00Z" });
-    const factC = fact({ id: "f_C", subject: "x", predicate: "framework", value: "Elysia", sourceSessionId: "sess_C", createdAt: "2026-05-19T10:00:00Z" });
-
-    await store.insertSession(makeRecord({ id: "sess_A", startedAt: "2026-05-17T10:00:00Z" }), null, null, { factStore, facts: [factA] });
-    await store.insertSession(makeRecord({ id: "sess_B", startedAt: "2026-05-18T10:00:00Z" }), null, null, { factStore, facts: [factB] });
-    await store.insertSession(makeRecord({ id: "sess_C", startedAt: "2026-05-19T10:00:00Z" }), null, null, { factStore, facts: [factC] });
-
-    expect((await factStore.getById("f_A"))?.supersededBy).toBe("f_B");
-    expect((await factStore.getById("f_B"))?.supersededBy).toBe("f_C");
-    expect((await factStore.getById("f_C"))?.supersededBy).toBeNull();
-
-    // History walks newest → oldest
-    const chains = await factStore.getHistory("x", "framework");
-    expect(chains[0]?.history.map((f) => f.id)).toEqual(["f_C", "f_B", "f_A"]);
-  });
-
-  it("re-ingest of same session re-establishes the chain (CASCADE-SET-NULL on the old self-fact)", async () => {
-    // First, an old session asserts framework=v1
-    const oldFact = fact({
-      id: "f_old", subject: "x", predicate: "framework", value: "v1",
-      sourceSessionId: "sess_old", createdAt: "2026-05-17T10:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_old", startedAt: "2026-05-17T10:00:00Z" }),
-      null, null, { factStore, facts: [oldFact] },
-    );
-
-    // Self session asserts framework=v2 — supersedes f_old
-    const selfFactV1 = fact({
-      id: "f_self_v1", subject: "x", predicate: "framework", value: "v2",
-      sourceSessionId: "sess_self", createdAt: "2026-05-18T10:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_self", startedAt: "2026-05-18T10:00:00Z" }),
-      null, null, { factStore, facts: [selfFactV1] },
-    );
-    expect((await factStore.getById("f_old"))?.supersededBy).toBe("f_self_v1");
-
-    // Re-ingest sess_self with a refreshed fact (e.g. classifier produced a
-    // new id on a re-classification). The old self fact is wiped via DELETE;
-    // ON DELETE SET NULL releases f_old; then the new self fact picks up
-    // the collision and re-supersedes f_old.
-    const selfFactV2 = fact({
-      id: "f_self_v2", subject: "x", predicate: "framework", value: "v2",
-      sourceSessionId: "sess_self", createdAt: "2026-05-18T11:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_self", startedAt: "2026-05-18T10:00:00Z" }),
-      null, null, { factStore, facts: [selfFactV2] },
-    );
-
-    expect(await factStore.getById("f_self_v1")).toBeNull(); // deleted
-    expect((await factStore.getById("f_old"))?.supersededBy).toBe("f_self_v2");
-    expect((await factStore.getById("f_self_v2"))?.supersededBy).toBeNull();
-
-    const current = await factStore.findCurrent("x", "framework");
-    expect(current?.id).toBe("f_self_v2");
-  });
-
-  it("does not supersede when factSink is omitted", async () => {
-    // Pre-seed a fact via the direct factStore API (no session txn route)
-    store.insertSessionForTest({
-      id: "sess_seed",
-      runtime: "claude-code",
-      runtimeSessionId: "seed",
-      startedAt: "2026-05-18T00:00:00Z",
-      endedAt: null,
-      durationMin: null,
-      label: "seed",
-      summary: "",
-      status: "closed",
-      transcriptKind: "claude-code-jsonl",
-      transcriptPath: null,
-      body: "",
-      entities: [],
-      decisions: [],
-      open: [],
-    });
-    await factStore.insert(
-      fact({ id: "f_seed", subject: "x", predicate: "framework", value: "v1", sourceSessionId: "sess_seed" }),
-    );
-
-    // Insert a session with NO factSink. The seed fact stays current.
-    await store.insertSession(makeRecord({ id: "sess_nofacts" }));
-    expect((await factStore.getById("f_seed"))?.supersededBy).toBeNull();
-  });
-
-  it("multi-fact ingest: each new fact supersedes its own (s, p) predecessor independently", async () => {
-    // Two prior facts, different (s, p) pairs
-    const sessFirst = "sess_first";
-    await store.insertSession(
-      makeRecord({ id: sessFirst, startedAt: "2026-05-18T10:00:00Z" }),
-      null, null,
-      {
-        factStore,
-        facts: [
-          fact({ id: "p1", subject: "a", predicate: "framework", value: "Fastify", sourceSessionId: sessFirst, createdAt: "2026-05-18T10:00:00Z" }),
-          fact({ id: "p2", subject: "b", predicate: "endpoint", value: ":8080", sourceSessionId: sessFirst, createdAt: "2026-05-18T10:00:00Z" }),
-        ],
-      },
-    );
-
-    // One ingest delivering supersedents to both
-    await store.insertSession(
-      makeRecord({ id: "sess_multi", startedAt: "2026-05-19T10:00:00Z" }),
-      null, null,
-      {
-        factStore,
-        facts: [
-          fact({ id: "n1", subject: "a", predicate: "framework", value: "Hono", sourceSessionId: "sess_multi", createdAt: "2026-05-19T10:00:00Z" }),
-          fact({ id: "n2", subject: "b", predicate: "endpoint", value: ":3940", sourceSessionId: "sess_multi", createdAt: "2026-05-19T10:00:00Z" }),
-        ],
-      },
-    );
-
-    expect((await factStore.getById("p1"))?.supersededBy).toBe("n1");
-    expect((await factStore.getById("p2"))?.supersededBy).toBe("n2");
-    expect((await factStore.getById("n1"))?.supersededBy).toBeNull();
-    expect((await factStore.getById("n2"))?.supersededBy).toBeNull();
-  });
-
-  it("FactRecallService default minConfidence respects supersedence — only current shows", async () => {
-    const factA = fact({ id: "f_old", subject: "x", predicate: "framework", value: "Fastify", sourceSessionId: "sess_A", createdAt: "2026-05-17T10:00:00Z" });
-    const factB = fact({ id: "f_new", subject: "x", predicate: "framework", value: "Hono", sourceSessionId: "sess_B", createdAt: "2026-05-19T10:00:00Z" });
-    await store.insertSession(makeRecord({ id: "sess_A", startedAt: "2026-05-17T10:00:00Z" }), null, null, { factStore, facts: [factA] });
-    await store.insertSession(makeRecord({ id: "sess_B", startedAt: "2026-05-19T10:00:00Z" }), null, null, { factStore, facts: [factB] });
-
-    const current = await factStore.list({ subject: "x", predicate: "framework" });
-    expect(current.map((f) => f.id)).toEqual(["f_new"]);
-
-    const all = await factStore.list({ subject: "x", predicate: "framework", includeSuperseded: true });
-    expect(all.map((f) => f.id).sort()).toEqual(["f_new", "f_old"]);
-  });
-});

package/tests/integration/fts-index.test.ts

@@ -1,60 +0,0 @@
-/**
- * Verifies the sessions_fts FTS5 index is present and kept in sync with the
- * sessions table after migrations run and rows are inserted.
- */
-
-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 { makeSession } from "../fixtures/sessions.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-describe("sessions_fts index", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-fts-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("populates sessions_fts via triggers on insert", () => {
-    store.insertSessionForTest(makeSession({ id: "s1", label: "alpha", body: "beta" }));
-    store.insertSessionForTest(makeSession({ id: "s2", label: "gamma", body: "delta" }));
-    const db = store.rawDb();
-    const fts = db.prepare<[], { n: number }>("SELECT count(*) AS n FROM sessions_fts").get();
-    const rows = db.prepare<[], { n: number }>("SELECT count(*) AS n FROM sessions").get();
-    expect(fts?.n).toBe(rows?.n);
-    expect(fts?.n).toBe(2);
-  });
-
-  it("records the 008 fts_rebuild migration as applied", () => {
-    const db = store.rawDb();
-    const row = db
-      .prepare<[number], { name: string }>("SELECT name FROM schema_migrations WHERE version = ?")
-      .get(8);
-    expect(row?.name).toBe("fts_rebuild");
-  });
-
-  it("answers a raw FTS5 MATCH query", () => {
-    store.insertSessionForTest(makeSession({ id: "s1", label: "pgvector plan", body: "" }));
-    const db = store.rawDb();
-    const hit = db
-      .prepare<[string], { id: string }>(
-        "SELECT s.id FROM sessions_fts JOIN sessions s ON s.rowid = sessions_fts.rowid WHERE sessions_fts MATCH ?",
-      )
-      .get('"pgvector"');
-    expect(hit?.id).toBe("s1");
-  });
-});

package/tests/integration/getbyids-sqlite.test.ts

@@ -1,60 +0,0 @@
-/**
- * SqliteSessionStore.getByIds — batched, body-free session fetch used by
- * the recall path so it never loads the full corpus.
- */
-
-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 { makeSession } from "../fixtures/sessions.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-describe("SqliteSessionStore.getByIds", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-getbyids-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    store.insertSessionForTest(
-      makeSession({ id: "s1", label: "alpha", body: "BODY ONE", entities: ["NLM"], decisions: ["d1"] }),
-    );
-    store.insertSessionForTest(
-      makeSession({ id: "s2", label: "beta", body: "BODY TWO", open: ["q1"] }),
-    );
-    store.insertSessionForTest(makeSession({ id: "s3", label: "gamma" }));
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("returns only the requested sessions", async () => {
-    const got = await store.getByIds(["s1", "s3"]);
-    expect(got.map((s) => s.id).sort()).toEqual(["s1", "s3"]);
-  });
-
-  it("returns an empty array for an empty id list", async () => {
-    expect(await store.getByIds([])).toEqual([]);
-  });
-
-  it("ignores ids that do not exist", async () => {
-    const got = await store.getByIds(["s2", "missing"]);
-    expect(got.map((s) => s.id)).toEqual(["s2"]);
-  });
-
-  it("populates entities and markers but omits body (body is empty)", async () => {
-    const got = await store.getByIds(["s1"]);
-    const s1 = got[0];
-    expect(s1?.entities).toEqual(["NLM"]);
-    expect(s1?.decisions).toEqual(["d1"]);
-    expect(s1?.body).toBe("");
-  });
-});

package/tests/integration/hermes-agent-hooks.test.ts

@@ -1,248 +0,0 @@
-/**
- * NousResearch Hermes Agent hook endpoints — integration tests.
- *
- * All three hermes-agent endpoints are tested against a real
- * SqliteSessionStore + RecallService running in-process (no network, no
- * TTY required). This mirrors the approach used in http.test.ts and
- * hook-pre-compact.test.ts.
- */
-
-import { existsSync, 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 type { Hono } from "hono";
-import { RecallService } from "../../src/core/recall/recall-service.js";
-import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
-import { createApp } from "../../src/http/app.js";
-import type { EmbedResult, LLMClient } from "../../src/ports/llm-client.js";
-import { makeSession } from "../fixtures/sessions.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-class NoopEmbedder implements LLMClient {
-  async embed(): Promise<EmbedResult> {
-    return { vector: new Float32Array(768), model: "noop" };
-  }
-  async classify(): Promise<never> {
-    throw new Error("not used");
-  }
-}
-
-describe("hermes-agent hook endpoints", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-  let app: Hono;
-  let citationLogPath: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-hermes-agent-"));
-    process.env["NLM_HOOK_STATE_DIR"] = join(tmp, "hook-state");
-    process.env["NLM_HOOK_LOG"] = join(tmp, "hook-log.jsonl");
-    citationLogPath = join(tmp, "citation-log.jsonl");
-
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    store.insertSessionForTest(
-      makeSession({ id: "sess_a", label: "recall hook design", body: "recall hook design work" }),
-    );
-    store.insertSessionForTest(
-      makeSession({ id: "sess_b", label: "sqlite migration plan", body: "database migration" }),
-    );
-
-    const recall = new RecallService({ store, llm: new NoopEmbedder() });
-    app = createApp({ recall, store, citationLogPath });
-  });
-
-  afterEach(() => {
-    delete process.env["NLM_HOOK_STATE_DIR"];
-    delete process.env["NLM_HOOK_LOG"];
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  // ── pre-turn ──────────────────────────────────────────────────────────────
-
-  it("pre-turn returns context for a matching query", async () => {
-    const res = await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: "sess_hermes_1", user_message: "recall hook" }),
-    });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(typeof body["context"]).toBe("string");
-    expect((body["context"] as string).length).toBeGreaterThan(0);
-    expect(body["context"]).toContain("sess_a");
-  });
-
-  it("pre-turn returns null context for a generative prompt", async () => {
-    const res = await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: "sess_hermes_2", user_message: "write a poem about autumn" }),
-    });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(body["context"]).toBeNull();
-  });
-
-  it("pre-turn returns null context for empty DB query", async () => {
-    const res = await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: "sess_hermes_3", user_message: "xyzzy completely unrelated" }),
-    });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(body["context"]).toBeNull();
-  });
-
-  it("pre-turn deduplicates: same session not re-surfaced on second fire", async () => {
-    const payload = { session_id: "sess_hermes_4", user_message: "recall hook" };
-    const first = await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload),
-    });
-    expect(first.status).toBe(200);
-    const firstBody = (await first.json()) as Record<string, unknown>;
-    expect(firstBody["context"]).toBeTruthy();
-
-    const second = await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload),
-    });
-    expect(second.status).toBe(200);
-    const secondBody = (await second.json()) as Record<string, unknown>;
-    expect(secondBody["context"]).toBeNull();
-  });
-
-  it("pre-turn returns 400 when session_id is missing", async () => {
-    const res = await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ user_message: "recall hook" }),
-    });
-    expect(res.status).toBe(400);
-  });
-
-  // ── post-turn ─────────────────────────────────────────────────────────────
-
-  it("post-turn detects and logs a cited session ID", async () => {
-    // Prime the memo so sess_a is in the surfaced set.
-    await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: "sess_hermes_5", user_message: "recall hook" }),
-    });
-
-    const res = await app.request("/api/hook/hermes-agent/post-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        session_id: "sess_hermes_5",
-        assistant_response: "Based on sess_a, here is the answer.",
-      }),
-    });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(body["ok"]).toBe(true);
-    expect(body["cited"]).toBe(1);
-    expect(existsSync(citationLogPath)).toBe(true);
-  });
-
-  it("post-turn returns cited=0 when no surfaced IDs appear in response", async () => {
-    const res = await app.request("/api/hook/hermes-agent/post-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        session_id: "sess_hermes_6",
-        assistant_response: "No session references here.",
-      }),
-    });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(body["cited"]).toBe(0);
-  });
-
-  it("post-turn returns 400 when session_id is missing", async () => {
-    const res = await app.request("/api/hook/hermes-agent/post-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ assistant_response: "some response" }),
-    });
-    expect(res.status).toBe(400);
-  });
-
-  // ── session-lifecycle ─────────────────────────────────────────────────────
-
-  it("session-lifecycle start is accepted without session_id requirement", async () => {
-    const res = await app.request("/api/hook/hermes-agent/session-lifecycle", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ event: "start", session_id: "sess_hermes_7" }),
-    });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as Record<string, unknown>;
-    expect(body["ok"]).toBe(true);
-    expect(body["event"]).toBe("start");
-  });
-
-  it("session-lifecycle end clears the surfaced-ID memo", async () => {
-    // Prime memo.
-    await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: "sess_hermes_8", user_message: "recall hook" }),
-    });
-    const memoPath = join(tmp, "hook-state", "sess_hermes_8.json");
-    expect(existsSync(memoPath)).toBe(true);
-
-    await app.request("/api/hook/hermes-agent/session-lifecycle", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ event: "end", session_id: "sess_hermes_8" }),
-    });
-    expect(existsSync(memoPath)).toBe(false);
-  });
-
-  it("session-lifecycle finalize clears the memo", async () => {
-    await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: "sess_hermes_9", user_message: "recall hook" }),
-    });
-    await app.request("/api/hook/hermes-agent/session-lifecycle", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ event: "finalize", session_id: "sess_hermes_9" }),
-    });
-    expect(existsSync(join(tmp, "hook-state", "sess_hermes_9.json"))).toBe(false);
-  });
-
-  it("session-lifecycle reset clears the memo", async () => {
-    await app.request("/api/hook/hermes-agent/pre-turn", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ session_id: "sess_hermes_10", user_message: "recall hook" }),
-    });
-    await app.request("/api/hook/hermes-agent/session-lifecycle", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ event: "reset", session_id: "sess_hermes_10" }),
-    });
-    expect(existsSync(join(tmp, "hook-state", "sess_hermes_10.json"))).toBe(false);
-  });
-
-  it("session-lifecycle returns 400 for an unknown event", async () => {
-    const res = await app.request("/api/hook/hermes-agent/session-lifecycle", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ event: "unknown", session_id: "sess_hermes_x" }),
-    });
-    expect(res.status).toBe(400);
-  });
-});